ClickHouse/dbms/include/DB/Parsers/ExpressionListParsers.h

314 lines
8.3 KiB
C
Raw Normal View History

2011-09-04 05:14:52 +00:00
#pragma once
2010-06-24 19:12:10 +00:00
2010-06-25 16:36:13 +00:00
#include <list>
2010-06-24 19:12:10 +00:00
#include <DB/Parsers/IParserBase.h>
#include <DB/Parsers/CommonParsers.h>
namespace DB
{
/** Идущие подряд пары строк: оператор и соответствующая ему функция. Например, "+" -> "plus".
* Порядок парсинга операторов имеет значение.
2010-06-25 16:36:13 +00:00
*/
typedef const char ** Operators_t;
2010-06-24 19:12:10 +00:00
2011-08-18 18:48:00 +00:00
/** Список элементов, разделённых чем-либо. */
class ParserList : public IParserBase
{
public:
ParserList(ParserPtr && elem_parser_, ParserPtr && separator_parser_, bool allow_empty_ = true)
: elem_parser(std::move(elem_parser_)), separator_parser(std::move(separator_parser_)), allow_empty(allow_empty_)
2011-08-18 18:48:00 +00:00
{
}
protected:
const char * getName() const { return "list of elements"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2011-08-18 18:48:00 +00:00
private:
ParserPtr elem_parser;
ParserPtr separator_parser;
bool allow_empty;
};
2010-06-24 19:12:10 +00:00
/** Выражение с инфиксным бинарным лево-ассоциативным оператором.
* Например, a + b - c + d.
*/
class ParserLeftAssociativeBinaryOperatorList : public IParserBase
{
private:
2010-06-24 19:37:23 +00:00
Operators_t operators;
ParserPtr first_elem_parser;
ParserPtr remaining_elem_parser;
2010-06-24 19:12:10 +00:00
public:
/** operators_ - допустимые операторы и соответствующие им функции
*/
ParserLeftAssociativeBinaryOperatorList(Operators_t operators_, ParserPtr && first_elem_parser_)
: operators(operators_), first_elem_parser(std::move(first_elem_parser_))
{
}
ParserLeftAssociativeBinaryOperatorList(Operators_t operators_, ParserPtr && first_elem_parser_,
ParserPtr && remaining_elem_parser_)
: operators(operators_), first_elem_parser(std::move(first_elem_parser_)),
remaining_elem_parser(std::move(remaining_elem_parser_))
2010-06-24 19:12:10 +00:00
{
}
protected:
const char * getName() const { return "list, delimited by binary operators"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
/** Выражение с инфиксным оператором произвольной арности.
* Например, a AND b AND c AND d.
*/
class ParserVariableArityOperatorList : public IParserBase
{
private:
ParserString infix_parser;
const char * function_name;
ParserPtr elem_parser;
public:
ParserVariableArityOperatorList(const char * infix_, const char * function_, ParserPtr && elem_parser_)
: infix_parser(infix_, true, true), function_name(function_), elem_parser(std::move(elem_parser_))
{
}
protected:
const char * getName() const { return "list, delimited by operator of variable arity"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
};
2010-06-24 19:12:10 +00:00
/** Выражение с префиксным унарным оператором.
* Например, NOT x.
*/
class ParserPrefixUnaryOperatorExpression : public IParserBase
{
private:
2010-06-24 19:37:23 +00:00
Operators_t operators;
2010-06-24 19:12:10 +00:00
ParserPtr elem_parser;
public:
/** operators_ - допустимые операторы и соответствующие им функции
*/
ParserPrefixUnaryOperatorExpression(Operators_t operators_, ParserPtr && elem_parser_)
: operators(operators_), elem_parser(std::move(elem_parser_))
2010-06-24 19:12:10 +00:00
{
}
protected:
const char * getName() const { return "expression with prefix unary operator"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
class ParserAccessExpression : public IParserBase
{
private:
static const char * operators[];
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "access expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
class ParserUnaryMinusExpression : public IParserBase
{
private:
static const char * operators[];
ParserPrefixUnaryOperatorExpression operator_parser {operators, ParserPtr(new ParserAccessExpression)};
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "unary minus expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
class ParserMultiplicativeExpression : public IParserBase
{
private:
static const char * operators[];
ParserLeftAssociativeBinaryOperatorList operator_parser {operators, ParserPtr(new ParserUnaryMinusExpression)};
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "multiplicative expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
class ParserAdditiveExpression : public IParserBase
{
private:
static const char * operators[];
ParserLeftAssociativeBinaryOperatorList operator_parser {operators, ParserPtr(new ParserMultiplicativeExpression)};
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "additive expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
class ParserComparisonExpression : public IParserBase
{
private:
static const char * operators[];
ParserLeftAssociativeBinaryOperatorList operator_parser {operators, ParserPtr(new ParserAdditiveExpression)};
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "comparison expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
class ParserLogicalNotExpression : public IParserBase
{
private:
static const char * operators[];
ParserPrefixUnaryOperatorExpression operator_parser {operators, ParserPtr(new ParserComparisonExpression)};
2010-06-24 19:12:10 +00:00
protected:
const char * getName() const { return "logical-NOT expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
class ParserLogicalAndExpression : public IParserBase
{
private:
ParserVariableArityOperatorList operator_parser;
2010-06-24 19:12:10 +00:00
public:
ParserLogicalAndExpression()
: operator_parser("AND", "and", ParserPtr(new ParserLogicalNotExpression))
2010-06-24 19:12:10 +00:00
{
}
protected:
const char * getName() const { return "logical-AND expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
class ParserLogicalOrExpression : public IParserBase
{
private:
ParserVariableArityOperatorList operator_parser;
2010-06-24 19:12:10 +00:00
public:
ParserLogicalOrExpression()
: operator_parser("OR", "or", ParserPtr(new ParserLogicalAndExpression))
2010-06-24 19:12:10 +00:00
{
}
protected:
const char * getName() const { return "logical-OR expression"; }
2010-06-24 19:12:10 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2010-06-24 19:12:10 +00:00
{
return operator_parser.parse(pos, end, node, expected);
}
};
/** Выражение с тернарным оператором.
* Например, a = 1 ? b + 1 : c * 2.
*/
class ParserTernaryOperatorExpression : public IParserBase
{
private:
ParserLogicalOrExpression elem_parser;
protected:
const char * getName() const { return "expression with ternary operator"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
};
class ParserLambdaExpression : public IParserBase
{
private:
ParserTernaryOperatorExpression elem_parser;
protected:
const char * getName() const { return "lambda expression"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
};
2011-11-06 20:47:07 +00:00
class ParserExpressionWithOptionalAlias : public IParserBase
{
public:
ParserExpressionWithOptionalAlias();
protected:
ParserPtr impl;
const char * getName() const { return "expression with optional alias"; }
2011-11-06 20:47:07 +00:00
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected)
2011-11-06 20:47:07 +00:00
{
return impl->parse(pos, end, node, expected);
}
};
2010-06-24 19:12:10 +00:00
/** Список выражений, разделённых запятыми, возможно пустой. */
class ParserExpressionList : public IParserBase
{
protected:
const char * getName() const { return "list of expressions"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
class ParserNotEmptyExpressionList : public IParserBase
{
private:
ParserExpressionList nested_parser;
protected:
const char * getName() const { return "not empty list of expressions"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2010-06-24 19:12:10 +00:00
};
2011-09-04 05:14:52 +00:00
class ParserOrderByExpressionList : public IParserBase
{
protected:
const char * getName() const { return "order by expression"; }
bool parseImpl(Pos & pos, Pos end, ASTPtr & node, Expected & expected);
2011-09-04 05:14:52 +00:00
};
2010-06-24 19:12:10 +00:00
2011-09-04 05:14:52 +00:00
}