2017-04-01 09:19:00 +00:00
|
|
|
#include <IO/ConcatReadBuffer.h>
|
|
|
|
|
2017-07-13 20:58:19 +00:00
|
|
|
#include <Common/typeid_cast.h>
|
|
|
|
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <DataStreams/AddingDefaultBlockOutputStream.h>
|
2017-12-20 07:39:52 +00:00
|
|
|
#include <DataStreams/CastTypeBlockInputStream.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <DataStreams/CountingBlockOutputStream.h>
|
2017-12-20 07:39:52 +00:00
|
|
|
#include <DataStreams/MaterializingBlockOutputStream.h>
|
|
|
|
#include <DataStreams/NullAndDoCopyBlockInputStream.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <DataStreams/NullableAdapterBlockInputStream.h>
|
2017-12-20 07:39:52 +00:00
|
|
|
#include <DataStreams/PushingToViewsBlockOutputStream.h>
|
|
|
|
#include <DataStreams/SquashingBlockOutputStream.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <DataStreams/copyData.h>
|
|
|
|
|
2017-12-20 07:39:52 +00:00
|
|
|
#include <Parsers/ASTIdentifier.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Parsers/ASTInsertQuery.h>
|
|
|
|
#include <Parsers/ASTSelectQuery.h>
|
|
|
|
|
|
|
|
#include <Interpreters/InterpreterInsertQuery.h>
|
2017-12-20 07:39:52 +00:00
|
|
|
#include <Interpreters/InterpreterSelectQuery.h>
|
2011-10-30 11:30:52 +00:00
|
|
|
|
2017-11-02 14:01:11 +00:00
|
|
|
#include <TableFunctions/TableFunctionFactory.h>
|
|
|
|
#include <Parsers/ASTFunction.h>
|
2016-10-24 02:02:37 +00:00
|
|
|
|
2018-02-19 03:00:16 +00:00
|
|
|
|
2016-10-24 02:02:37 +00:00
|
|
|
namespace ProfileEvents
|
|
|
|
{
|
2018-02-19 00:45:32 +00:00
|
|
|
extern const Event InsertQuery;
|
2016-10-24 02:02:37 +00:00
|
|
|
}
|
|
|
|
|
2011-10-30 11:30:52 +00:00
|
|
|
namespace DB
|
|
|
|
{
|
2018-02-19 03:00:16 +00:00
|
|
|
|
2016-01-11 21:46:36 +00:00
|
|
|
namespace ErrorCodes
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
extern const int NO_SUCH_COLUMN_IN_TABLE;
|
2017-12-20 07:39:52 +00:00
|
|
|
extern const int READONLY;
|
2018-02-19 00:45:32 +00:00
|
|
|
extern const int ILLEGAL_COLUMN;
|
2016-01-11 21:46:36 +00:00
|
|
|
}
|
|
|
|
|
2011-10-30 11:30:52 +00:00
|
|
|
|
2018-01-12 13:03:19 +00:00
|
|
|
InterpreterInsertQuery::InterpreterInsertQuery(
|
|
|
|
const ASTPtr & query_ptr_, const Context & context_, bool allow_materialized_)
|
|
|
|
: query_ptr(query_ptr_), context(context_), allow_materialized(allow_materialized_)
|
2011-10-30 11:30:52 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
ProfileEvents::increment(ProfileEvents::InsertQuery);
|
2011-10-30 11:30:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
StoragePtr InterpreterInsertQuery::getTable(const ASTInsertQuery & query)
|
2011-10-30 11:30:52 +00:00
|
|
|
{
|
2017-11-02 14:01:11 +00:00
|
|
|
if (query.table_function)
|
|
|
|
{
|
|
|
|
auto table_function = typeid_cast<const ASTFunction *>(query.table_function.get());
|
|
|
|
const auto & factory = TableFunctionFactory::instance();
|
|
|
|
return factory.get(table_function->name, context)->execute(query.table_function, context);
|
|
|
|
}
|
|
|
|
|
2018-02-19 03:00:16 +00:00
|
|
|
/// Into what table to write.
|
2017-04-01 07:20:54 +00:00
|
|
|
return context.getTable(query.database, query.table);
|
2011-10-30 11:30:52 +00:00
|
|
|
}
|
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
Block InterpreterInsertQuery::getSampleBlock(const ASTInsertQuery & query, const StoragePtr & table)
|
2017-11-02 14:01:11 +00:00
|
|
|
{
|
2018-02-19 00:45:32 +00:00
|
|
|
Block table_sample_non_materialized = table->getSampleBlockNonMaterialized();
|
2013-10-25 14:56:47 +00:00
|
|
|
|
2017-04-02 17:37:49 +00:00
|
|
|
/// If the query does not include information about columns
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!query.columns)
|
2018-02-19 00:45:32 +00:00
|
|
|
return table_sample_non_materialized;
|
2014-10-13 14:35:40 +00:00
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
Block table_sample = table->getSampleBlock();
|
2013-10-25 14:56:47 +00:00
|
|
|
|
2017-04-02 17:37:49 +00:00
|
|
|
/// Form the block based on the column names from the query
|
2017-04-01 07:20:54 +00:00
|
|
|
Block res;
|
|
|
|
for (const auto & identifier : query.columns->children)
|
|
|
|
{
|
|
|
|
std::string current_name = identifier->getColumnName();
|
2013-10-25 14:56:47 +00:00
|
|
|
|
2017-04-02 17:37:49 +00:00
|
|
|
/// The table does not have a column with that name
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!table_sample.has(current_name))
|
|
|
|
throw Exception("No such column " + current_name + " in table " + query.table, ErrorCodes::NO_SUCH_COLUMN_IN_TABLE);
|
2012-03-19 12:57:56 +00:00
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
if (!allow_materialized && !table_sample_non_materialized.has(current_name))
|
|
|
|
throw Exception("Cannot insert column " + current_name + ", because it is MATERIALIZED column.", ErrorCodes::ILLEGAL_COLUMN);
|
2014-06-26 00:58:14 +00:00
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
res.insert(ColumnWithTypeAndName(table_sample.getByName(current_name).type, current_name));
|
|
|
|
}
|
2017-04-01 07:20:54 +00:00
|
|
|
return res;
|
2013-10-25 14:56:47 +00:00
|
|
|
}
|
2012-03-19 12:57:56 +00:00
|
|
|
|
2011-10-30 11:30:52 +00:00
|
|
|
|
2014-03-20 10:59:45 +00:00
|
|
|
BlockIO InterpreterInsertQuery::execute()
|
2012-03-11 08:52:56 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
ASTInsertQuery & query = typeid_cast<ASTInsertQuery &>(*query_ptr);
|
2017-12-20 07:39:52 +00:00
|
|
|
checkAccess(query);
|
2018-02-19 00:45:32 +00:00
|
|
|
StoragePtr table = getTable(query);
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2017-09-01 15:05:23 +00:00
|
|
|
auto table_lock = table->lockStructure(true, __PRETTY_FUNCTION__);
|
2014-03-19 10:45:13 +00:00
|
|
|
|
2017-12-25 21:57:29 +00:00
|
|
|
NamesAndTypesList required_columns = table->getColumnsList();
|
2013-11-13 14:39:48 +00:00
|
|
|
|
2017-04-02 17:37:49 +00:00
|
|
|
/// We create a pipeline of several streams, into which we will write data.
|
2017-04-01 07:20:54 +00:00
|
|
|
BlockOutputStreamPtr out;
|
2016-07-07 01:57:48 +00:00
|
|
|
|
2017-11-02 14:01:11 +00:00
|
|
|
out = std::make_shared<PushingToViewsBlockOutputStream>(query.database, query.table, table, context, query_ptr, query.no_destination);
|
2016-07-07 01:57:48 +00:00
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
out = std::make_shared<MaterializingBlockOutputStream>(out, table->getSampleBlock());
|
2016-07-07 01:57:48 +00:00
|
|
|
|
2017-12-20 07:39:52 +00:00
|
|
|
out = std::make_shared<AddingDefaultBlockOutputStream>(
|
2018-02-19 00:45:32 +00:00
|
|
|
out, getSampleBlock(query, table), required_columns, table->column_defaults, context,
|
|
|
|
static_cast<bool>(context.getSettingsRef().strict_insert_defaults));
|
2016-07-07 01:57:48 +00:00
|
|
|
|
2017-12-20 07:39:52 +00:00
|
|
|
out = std::make_shared<SquashingBlockOutputStream>(
|
|
|
|
out, context.getSettingsRef().min_insert_block_size_rows, context.getSettingsRef().min_insert_block_size_bytes);
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
auto out_wrapper = std::make_shared<CountingBlockOutputStream>(out);
|
|
|
|
out_wrapper->setProcessListElement(context.getProcessListElement());
|
|
|
|
out = std::move(out_wrapper);
|
2016-12-06 20:55:13 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
BlockIO res;
|
2018-02-19 03:00:16 +00:00
|
|
|
res.out = std::move(out);
|
2014-03-19 10:45:13 +00:00
|
|
|
|
2017-04-02 17:37:49 +00:00
|
|
|
/// What type of query: INSERT or INSERT SELECT?
|
2018-02-19 03:00:16 +00:00
|
|
|
if (query.select)
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
|
|
|
InterpreterSelectQuery interpreter_select{query.select, context};
|
2016-08-25 12:38:47 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
res.in = interpreter_select.execute().in;
|
2017-04-21 10:25:29 +00:00
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
res.in = std::make_shared<NullableAdapterBlockInputStream>(res.in, res.in->getHeader(), res.out->getHeader());
|
|
|
|
res.in = std::make_shared<CastTypeBlockInputStream>(context, res.in, res.out->getHeader());
|
2018-02-19 03:00:16 +00:00
|
|
|
res.in = std::make_shared<NullAndDoCopyBlockInputStream>(res.in, res.out);
|
|
|
|
|
|
|
|
res.out = nullptr;
|
2018-02-19 00:45:32 +00:00
|
|
|
|
|
|
|
if (!allow_materialized)
|
|
|
|
{
|
|
|
|
Block in_header = res.in->getHeader();
|
|
|
|
for (const auto & name_type : table->materialized_columns)
|
|
|
|
if (in_header.has(name_type.name))
|
|
|
|
throw Exception("Cannot insert column " + name_type.name + ", because it is MATERIALIZED column.", ErrorCodes::ILLEGAL_COLUMN);
|
|
|
|
}
|
2017-04-01 07:20:54 +00:00
|
|
|
}
|
2014-03-20 10:59:45 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
return res;
|
2012-03-11 08:52:56 +00:00
|
|
|
}
|
|
|
|
|
2018-02-19 00:45:32 +00:00
|
|
|
|
2017-12-20 07:39:52 +00:00
|
|
|
void InterpreterInsertQuery::checkAccess(const ASTInsertQuery & query)
|
|
|
|
{
|
|
|
|
const Settings & settings = context.getSettingsRef();
|
|
|
|
auto readonly = settings.limits.readonly;
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2017-12-20 07:39:52 +00:00
|
|
|
if (!readonly || (query.database.empty() && context.tryGetExternalTable(query.table) && readonly >= 2))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
throw Exception("Cannot insert into table in readonly mode", ErrorCodes::READONLY);
|
|
|
|
}
|
2018-02-19 00:45:32 +00:00
|
|
|
|
2011-10-30 11:30:52 +00:00
|
|
|
}
|