ClickHouse/src/Parsers/ParserInsertQuery.cpp

210 lines
6.0 KiB
C++
Raw Normal View History

#include <Parsers/ASTIdentifier.h>
2018-02-25 06:34:20 +00:00
#include <Parsers/ASTSelectWithUnionQuery.h>
#include <Parsers/ASTInsertQuery.h>
#include <Parsers/CommonParsers.h>
#include <Parsers/ExpressionElementParsers.h>
#include <Parsers/ExpressionListParsers.h>
2018-02-25 06:34:20 +00:00
#include <Parsers/ParserSelectWithUnionQuery.h>
#include <Parsers/ParserWatchQuery.h>
#include <Parsers/ParserInsertQuery.h>
#include <Parsers/ParserSetQuery.h>
#include <Parsers/InsertQuerySettingsPushDownVisitor.h>
2019-05-28 18:30:10 +00:00
#include <Common/typeid_cast.h>
2011-10-30 05:19:41 +00:00
namespace DB
{
namespace ErrorCodes
{
extern const int SYNTAX_ERROR;
}
2011-10-30 05:19:41 +00:00
bool ParserInsertQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
2011-10-30 05:19:41 +00:00
{
ParserKeyword s_insert_into("INSERT INTO");
ParserKeyword s_table("TABLE");
ParserKeyword s_function("FUNCTION");
ParserToken s_dot(TokenType::Dot);
ParserKeyword s_values("VALUES");
ParserKeyword s_format("FORMAT");
ParserKeyword s_settings("SETTINGS");
ParserKeyword s_select("SELECT");
ParserKeyword s_watch("WATCH");
ParserKeyword s_with("WITH");
ParserToken s_lparen(TokenType::OpeningRoundBracket);
ParserToken s_rparen(TokenType::ClosingRoundBracket);
ParserIdentifier name_p;
2020-09-03 17:51:16 +00:00
ParserList columns_p(std::make_unique<ParserInsertElement>(), std::make_unique<ParserToken>(TokenType::Comma), false);
ParserFunction table_function_p{false};
ASTPtr database;
ASTPtr table;
ASTPtr columns;
ASTPtr format;
ASTPtr select;
ASTPtr watch;
ASTPtr table_function;
ASTPtr settings_ast;
2017-04-02 17:37:49 +00:00
/// Insertion data
const char * data = nullptr;
if (!s_insert_into.ignore(pos, expected))
return false;
s_table.ignore(pos, expected);
if (s_function.ignore(pos, expected))
{
if (!table_function_p.parse(pos, table_function, expected))
return false;
}
else
{
if (!name_p.parse(pos, table, expected))
return false;
if (s_dot.ignore(pos, expected))
{
database = table;
if (!name_p.parse(pos, table, expected))
return false;
}
}
2017-04-02 17:37:49 +00:00
/// Is there a list of columns
if (s_lparen.ignore(pos, expected))
{
if (!columns_p.parse(pos, columns, expected))
return false;
if (!s_rparen.ignore(pos, expected))
return false;
}
Pos before_values = pos;
2017-04-02 17:37:49 +00:00
/// VALUES or FORMAT or SELECT
if (s_values.ignore(pos, expected))
{
data = pos->begin;
}
else if (s_format.ignore(pos, expected))
{
if (!name_p.parse(pos, format, expected))
return false;
}
else if (s_select.ignore(pos, expected) || s_with.ignore(pos,expected))
{
pos = before_values;
ParserSelectWithUnionQuery select_p;
select_p.parse(pos, select, expected);
2019-05-28 18:30:10 +00:00
/// FORMAT section is expected if we have input() in SELECT part
if (s_format.ignore(pos, expected) && !name_p.parse(pos, format, expected))
return false;
}
else if (s_watch.ignore(pos, expected))
{
pos = before_values;
ParserWatchQuery watch_p;
watch_p.parse(pos, watch, expected);
/// FORMAT section is expected if we have input() in SELECT part
if (s_format.ignore(pos, expected) && !name_p.parse(pos, format, expected))
return false;
}
else
{
return false;
}
if (s_settings.ignore(pos, expected))
{
ParserSetQuery parser_settings(true);
if (!parser_settings.parse(pos, settings_ast, expected))
return false;
}
if (select)
{
/// Copy SETTINGS from the INSERT ... SELECT ... SETTINGS
InsertQuerySettingsPushDownVisitor::Data visitor_data{settings_ast};
InsertQuerySettingsPushDownVisitor(visitor_data).visit(select);
}
if (format)
{
Pos last_token = pos;
--last_token;
data = last_token->end;
if (data < end && *data == ';')
throw Exception("You have excessive ';' symbol before data for INSERT.\n"
"Example:\n\n"
"INSERT INTO t (x, y) FORMAT TabSeparated\n"
";\tHello\n"
"2\tWorld\n"
"\n"
"Note that there is no ';' just after format name, "
"you need to put at least one whitespace symbol before the data.", ErrorCodes::SYNTAX_ERROR);
while (data < end && (*data == ' ' || *data == '\t' || *data == '\f'))
++data;
/// Data starts after the first newline, if there is one, or after all the whitespace characters, otherwise.
if (data < end && *data == '\r')
++data;
if (data < end && *data == '\n')
++data;
}
2011-10-31 06:37:12 +00:00
2018-02-26 03:37:08 +00:00
auto query = std::make_shared<ASTInsertQuery>();
node = query;
2011-10-30 05:19:41 +00:00
if (table_function)
{
query->table_function = table_function;
}
else
{
2020-03-02 20:23:58 +00:00
tryGetIdentifierNameInto(database, query->table_id.database_name);
tryGetIdentifierNameInto(table, query->table_id.table_name);
}
2011-10-31 06:37:12 +00:00
2019-08-08 20:02:30 +00:00
tryGetIdentifierNameInto(format, query->format);
query->columns = columns;
query->select = select;
query->watch = watch;
query->settings_ast = settings_ast;
query->data = data != end ? data : nullptr;
query->end = end;
2011-10-30 05:19:41 +00:00
if (columns)
query->children.push_back(columns);
if (select)
query->children.push_back(select);
if (watch)
query->children.push_back(watch);
if (settings_ast)
query->children.push_back(settings_ast);
return true;
2011-10-30 05:19:41 +00:00
}
2020-09-03 17:51:16 +00:00
bool ParserInsertElement::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
return ParserColumnsMatcher().parse(pos, node, expected)
|| ParserQualifiedAsterisk().parse(pos, node, expected)
|| ParserAsterisk().parse(pos, node, expected)
|| ParserCompoundIdentifier().parse(pos, node, expected);
}
2011-10-30 05:19:41 +00:00
}