2011-08-18 18:48:00 +00:00
|
|
|
#pragma once
|
|
|
|
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Parsers/IParserBase.h>
|
|
|
|
#include <Parsers/ExpressionElementParsers.h>
|
|
|
|
#include <Parsers/ExpressionListParsers.h>
|
|
|
|
#include <Parsers/ASTNameTypePair.h>
|
|
|
|
#include <Parsers/ASTColumnDeclaration.h>
|
|
|
|
#include <Parsers/ASTIdentifier.h>
|
2018-11-06 13:26:43 +00:00
|
|
|
#include <Parsers/ASTLiteral.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Parsers/CommonParsers.h>
|
2014-10-07 09:09:59 +00:00
|
|
|
#include <Poco/String.h>
|
2011-08-18 18:48:00 +00:00
|
|
|
|
2020-05-26 20:58:51 +00:00
|
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
|
2011-08-18 18:48:00 +00:00
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2017-05-27 17:29:55 +00:00
|
|
|
/** A nested table. For example, Nested(UInt32 CounterID, FixedString(2) UserAgentMajor)
|
2013-07-11 17:35:56 +00:00
|
|
|
*/
|
|
|
|
class ParserNestedTable : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "nested table"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2013-07-11 17:35:56 +00:00
|
|
|
};
|
|
|
|
|
2014-06-26 00:58:14 +00:00
|
|
|
|
2017-05-27 17:29:55 +00:00
|
|
|
/** Parametric type or Storage. For example:
|
|
|
|
* FixedString(10) or
|
|
|
|
* Partitioned(Log, ChunkID) or
|
2017-04-01 07:20:54 +00:00
|
|
|
* Nested(UInt32 CounterID, FixedString(2) UserAgentMajor)
|
2017-05-27 17:29:55 +00:00
|
|
|
* Result of parsing - ASTFunction with or without parameters.
|
|
|
|
*/
|
2013-07-11 17:35:56 +00:00
|
|
|
class ParserIdentifierWithParameters : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "identifier with parameters"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2013-07-11 17:35:56 +00:00
|
|
|
};
|
|
|
|
|
2017-09-15 12:16:12 +00:00
|
|
|
template <typename NameParser>
|
2014-05-20 16:46:33 +00:00
|
|
|
class IParserNameTypePair : public IParserBase
|
2011-08-18 18:48:00 +00:00
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override{ return "name and type pair"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2011-08-18 18:48:00 +00:00
|
|
|
};
|
|
|
|
|
2017-05-27 17:29:55 +00:00
|
|
|
/** The name and type are separated by a space. For example, URL String. */
|
2016-05-28 10:35:44 +00:00
|
|
|
using ParserNameTypePair = IParserNameTypePair<ParserIdentifier>;
|
2017-05-27 17:29:55 +00:00
|
|
|
/** Name and type separated by a space. The name can contain a dot. For example, Hits.URL String. */
|
2016-05-28 10:35:44 +00:00
|
|
|
using ParserCompoundNameTypePair = IParserNameTypePair<ParserCompoundIdentifier>;
|
2014-05-20 16:46:33 +00:00
|
|
|
|
2017-09-15 12:16:12 +00:00
|
|
|
template <typename NameParser>
|
2017-07-10 03:28:12 +00:00
|
|
|
bool IParserNameTypePair<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
|
2014-05-20 16:46:33 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
NameParser name_parser;
|
|
|
|
ParserIdentifierWithOptionalParameters type_parser;
|
|
|
|
|
|
|
|
ASTPtr name, type;
|
2017-07-10 03:28:12 +00:00
|
|
|
if (name_parser.parse(pos, name, expected)
|
|
|
|
&& type_parser.parse(pos, type, expected))
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
2018-02-26 03:40:20 +00:00
|
|
|
auto name_type_pair = std::make_shared<ASTNameTypePair>();
|
2019-08-08 20:02:30 +00:00
|
|
|
tryGetIdentifierNameInto(name, name_type_pair->name);
|
2017-04-01 07:20:54 +00:00
|
|
|
name_type_pair->type = type;
|
|
|
|
name_type_pair->children.push_back(type);
|
|
|
|
node = name_type_pair;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2014-05-20 16:46:33 +00:00
|
|
|
}
|
2011-08-18 18:48:00 +00:00
|
|
|
|
2017-05-27 17:29:55 +00:00
|
|
|
/** List of columns. */
|
2013-07-11 17:35:56 +00:00
|
|
|
class ParserNameTypePairList : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "name and type pair list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2014-09-24 14:44:57 +00:00
|
|
|
};
|
|
|
|
|
2019-05-28 21:17:48 +00:00
|
|
|
/** List of table names. */
|
|
|
|
class ParserNameList : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "name list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2019-05-28 21:17:48 +00:00
|
|
|
};
|
|
|
|
|
2014-09-24 14:44:57 +00:00
|
|
|
|
2017-09-15 12:16:12 +00:00
|
|
|
template <typename NameParser>
|
2014-09-24 14:44:57 +00:00
|
|
|
class IParserColumnDeclaration : public IParserBase
|
|
|
|
{
|
2018-11-14 22:46:39 +00:00
|
|
|
public:
|
|
|
|
explicit IParserColumnDeclaration(bool require_type_ = true) : require_type(require_type_)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-09-24 14:44:57 +00:00
|
|
|
protected:
|
2018-10-11 02:57:48 +00:00
|
|
|
using ASTDeclarePtr = std::shared_ptr<ASTColumnDeclaration>;
|
|
|
|
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override{ return "column declaration"; }
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2020-01-21 08:54:26 +00:00
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2018-11-14 22:46:39 +00:00
|
|
|
|
|
|
|
bool require_type = true;
|
2014-09-24 14:44:57 +00:00
|
|
|
};
|
|
|
|
|
2016-05-28 10:35:44 +00:00
|
|
|
using ParserColumnDeclaration = IParserColumnDeclaration<ParserIdentifier>;
|
|
|
|
using ParserCompoundColumnDeclaration = IParserColumnDeclaration<ParserCompoundIdentifier>;
|
2014-09-24 14:44:57 +00:00
|
|
|
|
2017-09-15 12:16:12 +00:00
|
|
|
template <typename NameParser>
|
2017-07-10 03:28:12 +00:00
|
|
|
bool IParserColumnDeclaration<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
|
2014-09-24 14:44:57 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
NameParser name_parser;
|
|
|
|
ParserIdentifierWithOptionalParameters type_parser;
|
2018-12-13 15:26:28 +00:00
|
|
|
ParserKeyword s_default{"DEFAULT"};
|
|
|
|
ParserKeyword s_materialized{"MATERIALIZED"};
|
|
|
|
ParserKeyword s_alias{"ALIAS"};
|
|
|
|
ParserKeyword s_comment{"COMMENT"};
|
|
|
|
ParserKeyword s_codec{"CODEC"};
|
2019-04-15 09:30:45 +00:00
|
|
|
ParserKeyword s_ttl{"TTL"};
|
2018-12-13 15:26:28 +00:00
|
|
|
ParserTernaryOperatorExpression expr_parser;
|
|
|
|
ParserStringLiteral string_literal_parser;
|
|
|
|
ParserCodec codec_parser;
|
2019-04-15 09:30:45 +00:00
|
|
|
ParserExpression expression_parser;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
/// mandatory column name
|
|
|
|
ASTPtr name;
|
|
|
|
if (!name_parser.parse(pos, name, expected))
|
2017-04-01 07:20:54 +00:00
|
|
|
return false;
|
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
/** column name should be followed by type name if it
|
|
|
|
* is not immediately followed by {DEFAULT, MATERIALIZED, ALIAS, COMMENT}
|
|
|
|
*/
|
|
|
|
ASTPtr type;
|
|
|
|
String default_specifier;
|
|
|
|
ASTPtr default_expression;
|
|
|
|
ASTPtr comment_expression;
|
|
|
|
ASTPtr codec_expression;
|
2019-04-15 09:30:45 +00:00
|
|
|
ASTPtr ttl_expression;
|
2018-12-13 15:26:28 +00:00
|
|
|
|
2019-10-08 13:26:15 +00:00
|
|
|
if (!s_default.checkWithoutMoving(pos, expected) &&
|
|
|
|
!s_materialized.checkWithoutMoving(pos, expected) &&
|
|
|
|
!s_alias.checkWithoutMoving(pos, expected) &&
|
|
|
|
!s_comment.checkWithoutMoving(pos, expected) &&
|
|
|
|
!s_codec.checkWithoutMoving(pos, expected))
|
2018-10-11 02:57:48 +00:00
|
|
|
{
|
2018-12-13 15:26:28 +00:00
|
|
|
if (!type_parser.parse(pos, type, expected))
|
|
|
|
return false;
|
2018-10-11 02:57:48 +00:00
|
|
|
}
|
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
Pos pos_before_specifier = pos;
|
|
|
|
if (s_default.ignore(pos, expected) || s_materialized.ignore(pos, expected) || s_alias.ignore(pos, expected))
|
|
|
|
{
|
|
|
|
default_specifier = Poco::toUpper(std::string{pos_before_specifier->begin, pos_before_specifier->end});
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
/// should be followed by an expression
|
|
|
|
if (!expr_parser.parse(pos, default_expression, expected))
|
|
|
|
return false;
|
|
|
|
}
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (require_type && !type && !default_expression)
|
|
|
|
return false; /// reject column name without type
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2020-05-26 20:58:51 +00:00
|
|
|
auto first_word = type->getID();
|
|
|
|
|
|
|
|
if (boost::algorithm::to_lower_copy(first_word) == "function_double") {
|
|
|
|
ParserKeyword s_presicion{"PRESICION"};
|
|
|
|
s_presicion.ignore(pos);
|
|
|
|
} else if (boost::algorithm::to_lower_copy(first_word) == "function_char") {
|
|
|
|
ParserKeyword s_varying{"VARYING"};
|
|
|
|
s_varying.ignore(pos);
|
|
|
|
} else if (boost::algorithm::to_lower_copy(first_word) == "function_native") {
|
|
|
|
ParserIdentifierWithOptionalParameters tmp;
|
|
|
|
ASTPtr second_word;
|
|
|
|
if (!tmp.parse(pos, second_word, expected)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (boost::algorithm::to_lower_copy(second_word->getID()) != "function_character") {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
type = second_word;
|
|
|
|
} else if (boost::algorithm::to_lower_copy(first_word) == "function_varying")
|
|
|
|
{
|
|
|
|
ParserIdentifierWithOptionalParameters tmp;
|
|
|
|
ASTPtr second_word;
|
|
|
|
if (!tmp.parse(pos, second_word, expected))
|
|
|
|
return false;
|
|
|
|
if (boost::algorithm::to_lower_copy(second_word->getID()) != "function_char")
|
|
|
|
return false;
|
|
|
|
type = second_word;
|
|
|
|
}
|
|
|
|
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (s_comment.ignore(pos, expected))
|
2018-11-14 22:46:39 +00:00
|
|
|
{
|
2018-12-13 15:26:28 +00:00
|
|
|
/// should be followed by a string literal
|
|
|
|
if (!string_literal_parser.parse(pos, comment_expression, expected))
|
2018-11-14 22:46:39 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (s_codec.ignore(pos, expected))
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
2018-12-13 15:26:28 +00:00
|
|
|
if (!codec_parser.parse(pos, codec_expression, expected))
|
2017-04-01 07:20:54 +00:00
|
|
|
return false;
|
|
|
|
}
|
2018-11-14 22:46:39 +00:00
|
|
|
|
2019-04-15 09:30:45 +00:00
|
|
|
if (s_ttl.ignore(pos, expected))
|
|
|
|
{
|
|
|
|
if (!expression_parser.parse(pos, ttl_expression, expected))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
const auto column_declaration = std::make_shared<ASTColumnDeclaration>();
|
|
|
|
node = column_declaration;
|
2019-08-08 20:02:30 +00:00
|
|
|
tryGetIdentifierNameInto(name, column_declaration->name);
|
2018-10-11 02:57:48 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (type)
|
|
|
|
{
|
|
|
|
column_declaration->type = type;
|
|
|
|
column_declaration->children.push_back(std::move(type));
|
|
|
|
}
|
2018-11-14 22:46:39 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (default_expression)
|
|
|
|
{
|
|
|
|
column_declaration->default_specifier = default_specifier;
|
|
|
|
column_declaration->default_expression = default_expression;
|
|
|
|
column_declaration->children.push_back(std::move(default_expression));
|
|
|
|
}
|
2018-11-14 22:46:39 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (comment_expression)
|
2018-10-01 20:16:50 +00:00
|
|
|
{
|
2018-12-13 15:26:28 +00:00
|
|
|
column_declaration->comment = comment_expression;
|
|
|
|
column_declaration->children.push_back(std::move(comment_expression));
|
|
|
|
}
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-12-13 15:26:28 +00:00
|
|
|
if (codec_expression)
|
|
|
|
{
|
|
|
|
column_declaration->codec = codec_expression;
|
|
|
|
column_declaration->children.push_back(std::move(codec_expression));
|
2018-10-01 20:16:50 +00:00
|
|
|
}
|
|
|
|
|
2019-04-15 09:30:45 +00:00
|
|
|
if (ttl_expression)
|
|
|
|
{
|
|
|
|
column_declaration->ttl = ttl_expression;
|
|
|
|
column_declaration->children.push_back(std::move(ttl_expression));
|
|
|
|
}
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
return true;
|
2014-09-24 14:44:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class ParserColumnDeclarationList : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "column declaration list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2013-07-11 17:35:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2019-02-05 14:50:25 +00:00
|
|
|
/** name BY expr TYPE typename(arg1, arg2, ...) GRANULARITY value */
|
|
|
|
class ParserIndexDeclaration : public IParserBase
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ParserIndexDeclaration() {}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
const char * getName() const override { return "index declaration"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
2019-05-12 11:36:02 +00:00
|
|
|
class ParserConstraintDeclaration : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
const char * getName() const override { return "constraint declaration"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
2019-02-05 14:50:25 +00:00
|
|
|
|
2019-05-12 11:36:02 +00:00
|
|
|
class ParserTablePropertyDeclaration : public IParserBase
|
2019-02-05 14:50:25 +00:00
|
|
|
{
|
|
|
|
protected:
|
2019-11-20 07:07:27 +00:00
|
|
|
const char * getName() const override { return "table property (column, index, constraint) declaration"; }
|
2019-02-05 14:50:25 +00:00
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class ParserIndexDeclarationList : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
const char * getName() const override { return "index declaration list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
2019-05-12 11:36:02 +00:00
|
|
|
class ParserConstraintDeclarationList : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
const char * getName() const override { return "constraint declaration list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
2019-02-05 14:50:25 +00:00
|
|
|
|
2019-05-12 11:36:02 +00:00
|
|
|
class ParserTablePropertiesDeclarationList : public IParserBase
|
2019-02-05 14:50:25 +00:00
|
|
|
{
|
2019-07-31 14:06:22 +00:00
|
|
|
protected:
|
2019-02-05 14:50:25 +00:00
|
|
|
const char * getName() const override { return "columns or indices declaration list"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ENGINE = name [PARTITION BY expr] [ORDER BY expr] [PRIMARY KEY expr] [SAMPLE BY expr] [SETTINGS name = value, ...]
|
|
|
|
*/
|
2017-09-17 18:49:43 +00:00
|
|
|
class ParserStorage : public IParserBase
|
2011-11-01 15:16:04 +00:00
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "storage definition"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2011-11-01 15:16:04 +00:00
|
|
|
};
|
|
|
|
|
2019-10-09 20:09:10 +00:00
|
|
|
/** Query like this:
|
2019-10-23 13:46:38 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name [UUID 'uuid'] [ON CLUSTER cluster]
|
2019-10-09 20:09:10 +00:00
|
|
|
* (
|
|
|
|
* name1 type1,
|
|
|
|
* name2 type2,
|
|
|
|
* ...
|
|
|
|
* INDEX name1 expr TYPE type1(args) GRANULARITY value,
|
|
|
|
* ...
|
|
|
|
* ) ENGINE = engine
|
|
|
|
*
|
|
|
|
* Or:
|
2019-10-23 13:46:38 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name [UUID 'uuid'] [ON CLUSTER cluster] AS [db2.]name2 [ENGINE = engine]
|
2019-10-09 20:09:10 +00:00
|
|
|
*
|
|
|
|
* Or:
|
2019-10-23 13:46:38 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name [UUID 'uuid'] [ON CLUSTER cluster] AS ENGINE = engine SELECT ...
|
2019-10-09 20:09:10 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
class ParserCreateTableQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "CREATE TABLE or ATTACH TABLE query"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2019-10-09 20:09:10 +00:00
|
|
|
};
|
|
|
|
|
2019-11-11 11:34:03 +00:00
|
|
|
/// CREATE|ATTACH LIVE VIEW [IF NOT EXISTS] [db.]name [UUID 'uuid'] [TO [db.]name] AS SELECT ...
|
2019-10-09 20:09:10 +00:00
|
|
|
class ParserCreateLiveViewQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "CREATE LIVE VIEW query"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2019-10-09 20:09:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// CREATE|ATTACH DATABASE db [ENGINE = engine]
|
|
|
|
class ParserCreateDatabaseQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "CREATE DATABASE query"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2019-10-09 20:09:10 +00:00
|
|
|
};
|
|
|
|
|
2019-11-11 11:34:03 +00:00
|
|
|
/// CREATE[OR REPLACE]|ATTACH [[MATERIALIZED] VIEW] | [VIEW]] [IF NOT EXISTS] [db.]name [UUID 'uuid'] [TO [db.]name] [ENGINE = engine] [POPULATE] AS SELECT ...
|
2019-10-09 20:09:10 +00:00
|
|
|
class ParserCreateViewQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "CREATE VIEW query"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2019-10-09 20:09:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/// Parses complete dictionary create query. Uses ParserDictionary and
|
|
|
|
/// ParserDictionaryAttributeDeclaration. Produces ASTCreateQuery.
|
|
|
|
/// CREATE DICTIONAY [IF NOT EXISTS] [db.]name (attrs) PRIMARY KEY key SOURCE(s(params)) LAYOUT(l(params)) LIFETIME([min v1 max] v2) [RANGE(min v1 max v2)]
|
|
|
|
class ParserCreateDictionaryQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
const char * getName() const override { return "CREATE DICTIONARY"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
|
|
|
};
|
|
|
|
|
2011-11-01 15:16:04 +00:00
|
|
|
|
2017-05-27 17:29:55 +00:00
|
|
|
/** Query like this:
|
2011-10-31 06:37:12 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name
|
2011-08-18 18:48:00 +00:00
|
|
|
* (
|
2017-04-01 07:20:54 +00:00
|
|
|
* name1 type1,
|
|
|
|
* name2 type2,
|
|
|
|
* ...
|
2019-02-05 14:50:25 +00:00
|
|
|
* INDEX name1 expr TYPE type1(args) GRANULARITY value,
|
|
|
|
* ...
|
2011-08-18 18:48:00 +00:00
|
|
|
* ) ENGINE = engine
|
2011-10-31 06:37:12 +00:00
|
|
|
*
|
2017-05-27 17:29:55 +00:00
|
|
|
* Or:
|
2012-07-12 20:06:45 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name AS [db2.]name2 [ENGINE = engine]
|
2011-11-01 15:16:04 +00:00
|
|
|
*
|
2017-05-27 17:29:55 +00:00
|
|
|
* Or:
|
2012-12-11 20:32:08 +00:00
|
|
|
* CREATE|ATTACH TABLE [IF NOT EXISTS] [db.]name AS ENGINE = engine SELECT ...
|
2011-11-05 23:31:19 +00:00
|
|
|
*
|
2017-05-27 17:29:55 +00:00
|
|
|
* Or:
|
2016-03-19 01:18:49 +00:00
|
|
|
* CREATE|ATTACH DATABASE db [ENGINE = engine]
|
2014-04-24 18:49:07 +00:00
|
|
|
*
|
2017-05-27 17:29:55 +00:00
|
|
|
* Or:
|
2019-08-23 05:08:06 +00:00
|
|
|
* CREATE[OR REPLACE]|ATTACH [[MATERIALIZED] VIEW] | [VIEW]] [IF NOT EXISTS] [db.]name [TO [db.]name] [ENGINE = engine] [POPULATE] AS SELECT ...
|
2011-08-18 18:48:00 +00:00
|
|
|
*/
|
|
|
|
class ParserCreateQuery : public IParserBase
|
|
|
|
{
|
|
|
|
protected:
|
2020-01-21 08:54:26 +00:00
|
|
|
const char * getName() const override { return "CREATE TABLE or ATTACH TABLE query"; }
|
|
|
|
bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
|
2011-08-18 18:48:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|