2017-04-01 09:19:00 +00:00
|
|
|
#include <Parsers/ParserAlterQuery.h>
|
|
|
|
#include <Parsers/CommonParsers.h>
|
|
|
|
#include <Parsers/ExpressionElementParsers.h>
|
|
|
|
#include <Parsers/ParserCreateQuery.h>
|
|
|
|
#include <Parsers/ASTIdentifier.h>
|
|
|
|
#include <Parsers/ExpressionElementParsers.h>
|
|
|
|
#include <Parsers/ASTAlterQuery.h>
|
|
|
|
#include <Parsers/ASTLiteral.h>
|
2013-08-07 13:07:42 +00:00
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2015-04-11 03:10:23 +00:00
|
|
|
bool ParserAlterQuery::parseImpl(Pos & pos, Pos end, ASTPtr & node, Pos & max_parsed_pos, Expected & expected)
|
2013-08-07 13:07:42 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
Pos begin = pos;
|
|
|
|
|
2017-05-24 21:38:56 +00:00
|
|
|
ParserString s_alter( "ALTER", true, true);
|
|
|
|
ParserString s_table( "TABLE", true, true);
|
|
|
|
ParserString s_add( "ADD", true, true);
|
|
|
|
ParserString s_column( "COLUMN", true, true);
|
|
|
|
ParserString s_after( "AFTER", true, true);
|
|
|
|
ParserString s_modify( "MODIFY", true, true);
|
|
|
|
ParserString s_primary( "PRIMARY", true, true);
|
|
|
|
ParserString s_key( "KEY", true, true);
|
|
|
|
ParserString s_reshard( "RESHARD", true, true);
|
|
|
|
ParserString s_drop( "DROP", true, true);
|
|
|
|
ParserString s_detach( "DETACH", true, true);
|
|
|
|
ParserString s_attach( "ATTACH", true, true);
|
|
|
|
ParserString s_fetch( "FETCH", true, true);
|
|
|
|
ParserString s_freeze( "FREEZE", true, true);
|
|
|
|
ParserString s_part( "PART", true, true);
|
|
|
|
ParserString s_partition( "PARTITION", true, true);
|
|
|
|
ParserString s_from( "FROM", true, true);
|
|
|
|
ParserString s_copy( "COPY", true, true);
|
|
|
|
ParserString s_to( "TO", true, true);
|
|
|
|
ParserString s_using( "USING", true, true);
|
|
|
|
ParserString s_coordinate("COORDINATE", true, true);
|
|
|
|
ParserString s_with( "WITH", true, true);
|
|
|
|
ParserString s_name( "NAME", true, true);
|
2017-04-01 07:20:54 +00:00
|
|
|
|
|
|
|
ParserString s_dot(".");
|
|
|
|
ParserString s_comma(",");
|
|
|
|
ParserString s_doubledot("..");
|
|
|
|
|
|
|
|
ParserWhiteSpaceOrComments ws;
|
|
|
|
|
|
|
|
ParserIdentifier table_parser;
|
|
|
|
ParserCompoundIdentifier parser_name;
|
|
|
|
ParserCompoundColumnDeclaration parser_col_decl;
|
|
|
|
ParserLiteral parser_literal;
|
|
|
|
ParserUnsignedInteger parser_uint;
|
|
|
|
ParserStringLiteral parser_string_literal;
|
|
|
|
|
|
|
|
ASTPtr table;
|
|
|
|
ASTPtr database;
|
|
|
|
ASTPtr col_type;
|
|
|
|
ASTPtr col_after;
|
|
|
|
ASTPtr col_drop;
|
|
|
|
|
|
|
|
auto query = std::make_shared<ASTAlterQuery>();
|
|
|
|
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
if (!s_alter.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
if (!s_table.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!table_parser.parse(pos, end, database, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/// Parse [db].name
|
|
|
|
if (s_dot.ignore(pos, end))
|
|
|
|
{
|
|
|
|
if (!table_parser.parse(pos, end, table, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
query->table = typeid_cast<ASTIdentifier &>(*table).name;
|
|
|
|
query->database = typeid_cast<ASTIdentifier &>(*database).name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
table = database;
|
|
|
|
query->table = typeid_cast<ASTIdentifier &>(*table).name;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool parsing_finished = false;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ASTAlterQuery::Parameters params;
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (s_add.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
if (!s_column.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!parser_col_decl.parse(pos, end, params.col_decl, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
if (s_after.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if(!parser_name.parse(pos, end, params.column, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
params.type = ASTAlterQuery::ADD_COLUMN;
|
|
|
|
}
|
|
|
|
else if (s_drop.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
2017-05-24 21:38:56 +00:00
|
|
|
if (s_partition.ignore(pos, end, max_parsed_pos, expected))
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
params.type = ASTAlterQuery::DROP_PARTITION;
|
|
|
|
}
|
|
|
|
else if (s_column.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!parser_name.parse(pos, end, params.column, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
params.type = ASTAlterQuery::DROP_COLUMN;
|
|
|
|
params.detach = false;
|
2017-04-14 12:40:48 +00:00
|
|
|
|
|
|
|
if (s_from.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
}
|
2017-04-01 07:20:54 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if (s_detach.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
params.type = ASTAlterQuery::DROP_PARTITION;
|
|
|
|
params.detach = true;
|
|
|
|
}
|
|
|
|
else if (s_attach.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
|
|
|
|
if (s_part.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
params.part = true;
|
|
|
|
else if (!s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-08-07 11:46:01 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-08-07 11:46:01 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-08-07 11:46:01 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.type = ASTAlterQuery::ATTACH_PARTITION;
|
|
|
|
}
|
|
|
|
else if (s_fetch.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_from.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ASTPtr ast_from;
|
|
|
|
if (!parser_string_literal.parse(pos, end, ast_from, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-10-09 20:28:33 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.from = typeid_cast<const ASTLiteral &>(*ast_from).value.get<const String &>();
|
|
|
|
params.type = ASTAlterQuery::FETCH_PARTITION;
|
|
|
|
}
|
|
|
|
else if (s_freeze.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2014-11-11 04:11:07 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-11-11 04:11:07 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-11-11 04:11:07 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_literal.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-11-11 04:11:07 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2014-11-11 04:11:07 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// WITH NAME 'name' - place local backup to directory with specified name
|
|
|
|
if (s_with.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_name.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ASTPtr ast_with_name;
|
|
|
|
if (!parser_string_literal.parse(pos, end, ast_with_name, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.with_name = typeid_cast<const ASTLiteral &>(*ast_with_name).value.get<const String &>();
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
|
|
|
}
|
2016-06-28 20:50:37 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.type = ASTAlterQuery::FREEZE_PARTITION;
|
|
|
|
}
|
|
|
|
else if (s_modify.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2014-02-28 08:22:15 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (s_column.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2014-02-28 08:22:15 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_col_decl.parse(pos, end, params.col_decl, max_parsed_pos, expected))
|
|
|
|
return false;
|
2014-02-28 08:22:15 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.type = ASTAlterQuery::MODIFY_COLUMN;
|
|
|
|
}
|
|
|
|
else if (s_primary.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_key.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!ParserString("(").ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-05-17 20:11:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-05-17 20:11:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!ParserNotEmptyExpressionList(false).parse(pos, end, params.primary_key, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-05-17 20:11:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-05-17 20:11:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!ParserString(")").ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-05-05 18:28:46 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.type = ASTAlterQuery::MODIFY_PRIMARY_KEY;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if (s_reshard.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ParserList weighted_zookeeper_paths_p(std::make_unique<ParserWeightedZooKeeperPath>(), std::make_unique<ParserString>(","), false);
|
|
|
|
ParserExpressionWithOptionalAlias parser_sharding_key_expr(false);
|
|
|
|
ParserStringLiteral parser_coordinator;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (s_copy.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
params.do_copy = true;
|
2016-03-25 11:48:45 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-03-25 11:48:45 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (s_partition.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_uint.parse(pos, end, params.partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (s_doubledot.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_uint.parse(pos, end, params.last_partition, max_parsed_pos, expected))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_to.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!weighted_zookeeper_paths_p.parse(pos, end, params.weighted_zookeeper_paths, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_using.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_sharding_key_expr.parse(pos, end, params.sharding_key_expr, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-01-28 01:00:27 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (s_coordinate.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
2016-03-01 17:47:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_with.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-03-01 17:47:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2016-03-01 17:47:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!parser_coordinator.parse(pos, end, params.coordinator, max_parsed_pos, expected))
|
|
|
|
return false;
|
2016-03-01 17:47:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
|
|
|
}
|
2016-03-01 17:47:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
params.type = ASTAlterQuery::RESHARD_PARTITION;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
2013-08-07 13:07:42 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
ws.ignore(pos, end);
|
2013-08-07 13:07:42 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!s_comma.ignore(pos, end, max_parsed_pos, expected))
|
|
|
|
{
|
|
|
|
ws.ignore(pos, end);
|
|
|
|
parsing_finished = true;
|
|
|
|
}
|
2013-08-07 13:07:42 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
query->addParameters(params);
|
|
|
|
}
|
|
|
|
while (!parsing_finished);
|
2013-08-07 13:07:42 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
query->range = StringRange(begin, end);
|
|
|
|
node = query;
|
2013-08-07 13:07:42 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
return true;
|
2013-08-07 13:07:42 +00:00
|
|
|
}
|
|
|
|
}
|