mirror of
https://github.com/hanzoai/insights.git
synced 2026-10-30 16:15:31 +00:00
zeekay
d696a015aa
The rename runs on the way in and nothing checked it afterwards, so paths and content drifted apart in three places, and each one broke something quietly. The script language had three names at once. Files on disk carried `.iql`/`.iqle`, the source matchers said `.script`, and the bytecode matchers said `.hoge`, so the test harness globbed zero files and the STL compiler regenerated an empty table. It is `script` now, in one place: `.script` source, `.scriptc` bytecode, `bin/script` to run one and `bin/scriptc` to compile one. 190 TypeScript specifiers named files that had been renamed away, which is the whole CDP consumer graph -- the event worker, not the web boot. `--check` only ever read Python imports; it reads both module systems now, and repoints both. `-hog-` became `-mascot-` in paths while content said `script`, so the code review product's skill directories stopped matching the prefix that discovers them and it ran with no perspectives at all. PATH_REGEX is CONTENT_REGEX -- the same list, not a copy -- so a rule can no longer land in one and miss the other, and the four disagreeing `hog` path rules collapse into the one word rule content already had. `HOGLI_*` becomes `INSIGHTSCLI_*` at every reader and writer, with no alias: an env var read under two names is two names. The seven casings of `hogql` and five of `hogvm` collapse into one rule per prefix casing, which leaves the suffix alone because `QL` is SQL's and `VM` is a virtual machine's. `--check` now refuses every retired spelling, in content and in paths, and draws the line the rules draw: `insights_hogfunction` is a Postgres table so it is left alone, and a migration filename is its identity in `django_migrations` so it is frozen rather than failed. Third-party names we cannot rename are reported as pending, never exempted.
3750 lines
128 KiB
C++
Generated
3750 lines
128 KiB
C++
Generated
|
|
// Generated from InsightsQLParser.g4 by ANTLR 4.13.2
|
|
|
|
#pragma once
|
|
|
|
|
|
#include "antlr4-runtime.h"
|
|
|
|
|
|
|
|
|
|
class InsightsQLParser : public antlr4::Parser {
|
|
public:
|
|
enum {
|
|
ALL = 1, AND = 2, ANTI = 3, ANY = 4, ARRAY = 5, AS = 6, ASCENDING = 7,
|
|
ASOF = 8, BETWEEN = 9, BOTH = 10, BY = 11, CASE = 12, CAST = 13, CATCH = 14,
|
|
COHORT = 15, COLLATE = 16, COLUMNS = 17, CROSS = 18, CUBE = 19, CURRENT = 20,
|
|
DATE = 21, DAY = 22, DESC = 23, DESCENDING = 24, DISTINCT = 25, ELSE = 26,
|
|
END = 27, EXCEPT = 28, EXCLUDE = 29, EXTRACT = 30, FINAL = 31, FILL = 32,
|
|
FILTER = 33, FINALLY = 34, FIRST = 35, FN = 36, FOLLOWING = 37, FOR = 38,
|
|
FROM = 39, FULL = 40, FUN = 41, GROUP = 42, GROUPING = 43, HAVING = 44,
|
|
HOUR = 45, ID = 46, IF = 47, ILIKE = 48, IGNORE = 49, INCLUDE = 50,
|
|
IN = 51, INF = 52, INNER = 53, INTERSECT = 54, INTERPOLATE = 55, INTERVAL = 56,
|
|
IS = 57, JOIN = 58, KEY = 59, LAMBDA = 60, LAST = 61, LEADING = 62,
|
|
LEFT = 63, LET = 64, LIKE = 65, LIMIT = 66, MATERIALIZED = 67, MINUTE = 68,
|
|
MONTH = 69, NAME = 70, NATURAL = 71, NAN_SQL = 72, NOT = 73, NULL_SQL = 74,
|
|
NULLS = 75, OFFSET = 76, ON = 77, OR = 78, ORDER = 79, OUTER = 80, OVER = 81,
|
|
PARTITION = 82, PIVOT = 83, POSITIONAL = 84, PRECEDING = 85, PREWHERE = 86,
|
|
QUALIFY = 87, QUARTER = 88, RANGE = 89, RECURSIVE = 90, REPLACE = 91,
|
|
RETURN = 92, RIGHT = 93, ROLLUP = 94, ROW = 95, ROWS = 96, SAMPLE = 97,
|
|
SECOND = 98, SELECT = 99, SEMI = 100, SETS = 101, SETTINGS = 102, STEP = 103,
|
|
SUBSTRING = 104, THEN = 105, THROW = 106, TIES = 107, TIMESTAMP = 108,
|
|
TIME = 109, LOCAL = 110, ZONE = 111, TO = 112, TOP = 113, TOTALS = 114,
|
|
TRAILING = 115, TRIM = 116, TRUNCATE = 117, TRY = 118, TRY_CAST = 119,
|
|
UNBOUNDED = 120, UNION = 121, UNPIVOT = 122, USING = 123, VALUES = 124,
|
|
WEEK = 125, WHEN = 126, WHERE = 127, WHILE = 128, WINDOW = 129, WITH = 130,
|
|
WITHIN = 131, YEAR = 132, ESCAPE_CHAR_COMMON = 133, IDENTIFIER = 134,
|
|
QUOTED_IDENTIFIER = 135, FLOATING_LITERAL = 136, BINARY_LITERAL = 137,
|
|
OCTAL_LITERAL = 138, DECIMAL_LITERAL = 139, HEXADECIMAL_LITERAL = 140,
|
|
OCTAL_PREFIX_LITERAL = 141, MALFORMED_BINARY_LITERAL = 142, STRING_LITERAL = 143,
|
|
ARROW = 144, ASTERISK = 145, BACKQUOTE = 146, BACKSLASH = 147, DOUBLECOLON = 148,
|
|
COLONEQUALS = 149, COLON = 150, COMMA = 151, CONCAT = 152, DASH = 153,
|
|
DOLLAR = 154, DOT = 155, EQ_DOUBLE = 156, EQ_SINGLE = 157, GT_EQ = 158,
|
|
GT = 159, HASH = 160, IREGEX_SINGLE = 161, IREGEX_DOUBLE = 162, LBRACE = 163,
|
|
LBRACKET = 164, LPAREN = 165, NULL_SAFE_EQ = 166, LT_EQ = 167, LT = 168,
|
|
LT_SLASH = 169, NOT_EQ = 170, NOT_IREGEX = 171, NOT_REGEX = 172, NULL_PROPERTY = 173,
|
|
NULLISH = 174, PERCENT = 175, PLUS = 176, QUERY = 177, QUOTE_DOUBLE = 178,
|
|
QUOTE_SINGLE_TEMPLATE = 179, QUOTE_SINGLE_TEMPLATE_FULL = 180, QUOTE_SINGLE = 181,
|
|
REGEX_SINGLE = 182, REGEX_DOUBLE = 183, RBRACE = 184, RBRACKET = 185,
|
|
RPAREN = 186, SEMICOLON = 187, SLASH = 188, SLASH_GT = 189, UNDERSCORE = 190,
|
|
MULTI_LINE_COMMENT = 191, SINGLE_LINE_COMMENT = 192, HASH_COMMENT = 193,
|
|
WHITESPACE = 194, UNEXPECTED_CHARACTER = 195, STRING_TEXT = 196, STRING_ESCAPE_TRIGGER = 197,
|
|
FULL_STRING_TEXT = 198, FULL_STRING_ESCAPE_TRIGGER = 199, TAG_MULTI_LINE_COMMENT = 200,
|
|
TAG_SINGLE_LINE_COMMENT = 201, TAG_WS = 202, TAGC_MULTI_LINE_COMMENT = 203,
|
|
TAGC_SINGLE_LINE_COMMENT = 204, TAGC_WS = 205, INSIGHTSQLX_TEXT_TEXT = 206,
|
|
INSIGHTSQLX_TEXT_WS = 207
|
|
};
|
|
|
|
enum {
|
|
RuleProgram = 0, RuleDeclaration = 1, RuleExpression = 2, RuleVarDecl = 3,
|
|
RuleIdentifierList = 4, RuleStatement = 5, RuleReturnStmt = 6, RuleThrowStmt = 7,
|
|
RuleCatchBlock = 8, RuleTryCatchStmt = 9, RuleIfStmt = 10, RuleWhileStmt = 11,
|
|
RuleForStmt = 12, RuleForInStmt = 13, RuleFuncStmt = 14, RuleVarAssignment = 15,
|
|
RuleExprStmt = 16, RuleEmptyStmt = 17, RuleBlock = 18, RuleKvPair = 19,
|
|
RuleKvPairList = 20, RuleSelect = 21, RuleSelectStmtWithParens = 22,
|
|
RuleSubsequentSelectSetClause = 23, RuleSelectSetStmt = 24, RuleLimitAndOffsetClauseOptional = 25,
|
|
RuleSelectStmt = 26, RuleWithClause = 27, RuleTopClause = 28, RuleFromClause = 29,
|
|
RuleArrayJoinClause = 30, RuleWindowClause = 31, RulePrewhereClause = 32,
|
|
RuleWhereClause = 33, RuleGroupByClause = 34, RuleGroupingSetList = 35,
|
|
RuleGroupingSet = 36, RuleHavingClause = 37, RuleQualifyClause = 38,
|
|
RuleOrderByClause = 39, RuleInterpolateClause = 40, RuleProjectionOrderByClause = 41,
|
|
RuleLimitByClause = 42, RuleLimitAndOffsetClause = 43, RuleOffsetOnlyClause = 44,
|
|
RuleSettingsClause = 45, RuleValuesClause = 46, RuleValuesRow = 47,
|
|
RuleJoinExpr = 48, RuleJoinOp = 49, RuleJoinOpCross = 50, RuleJoinConstraintClause = 51,
|
|
RuleSampleClause = 52, RuleLimitExpr = 53, RuleOrderExprList = 54, RuleOrderExpr = 55,
|
|
RuleWithFillClause = 56, RuleInterpolateExpr = 57, RuleRatioExpr = 58,
|
|
RuleSettingExprList = 59, RuleSettingExpr = 60, RuleWindowExpr = 61,
|
|
RuleWinPartitionByClause = 62, RuleWinOrderByClause = 63, RuleWithinGroupClause = 64,
|
|
RuleWinFrameClause = 65, RuleWinFrameExtend = 66, RuleWinFrameBound = 67,
|
|
RuleExpr = 68, RuleColumnTypeExpr = 69, RuleColumnTypeCastExpr = 70,
|
|
RuleColumnTypeCastIdentifier = 71, RuleKeywordForTypeCast = 72, RuleColumnExprList = 73,
|
|
RuleSelectColumnExprListBeforeFrom = 74, RuleSelectColumnExprList = 75,
|
|
RuleSelectColumnExpr = 76, RuleColumnExpr = 77, RuleColumnExprValue = 78,
|
|
RuleColumnLambdaExpr = 79, RuleColumnsReplaceList = 80, RuleColumnsReplaceItem = 81,
|
|
RuleInsightsqlxChildElement = 82, RuleInsightsqlxText = 83, RuleInsightsqlxTagElement = 84,
|
|
RuleInsightsqlxTagAttribute = 85, RuleWithExprList = 86, RuleWithExpr = 87,
|
|
RuleWithExprColumnNameList = 88, RuleColumnIdentifier = 89, RuleNestedIdentifier = 90,
|
|
RuleTableExpr = 91, RulePivotColumnList = 92, RulePivotColumn = 93,
|
|
RuleUnpivotColumnList = 94, RuleUnpivotColumn = 95, RuleColumnExprTupleOrSingle = 96,
|
|
RuleColumnAliases = 97, RuleTableFunctionExpr = 98, RuleTableIdentifier = 99,
|
|
RuleTableArgList = 100, RuleDatabaseIdentifier = 101, RuleFloatingLiteral = 102,
|
|
RuleNumberLiteral = 103, RuleLiteral = 104, RuleInterval = 105, RuleKeyword = 106,
|
|
RuleKeywordForAlias = 107, RuleKeywordForImplicitAlias = 108, RuleAlias = 109,
|
|
RuleImplicitAlias = 110, RuleIdentifier = 111, RuleEnumValue = 112,
|
|
RulePlaceholder = 113, RuleString = 114, RuleTemplateString = 115, RuleStringContents = 116,
|
|
RuleFullTemplateString = 117, RuleStringContentsFull = 118
|
|
};
|
|
|
|
explicit InsightsQLParser(antlr4::TokenStream *input);
|
|
|
|
InsightsQLParser(antlr4::TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options);
|
|
|
|
~InsightsQLParser() override;
|
|
|
|
std::string getGrammarFileName() const override;
|
|
|
|
const antlr4::atn::ATN& getATN() const override;
|
|
|
|
const std::vector<std::string>& getRuleNames() const override;
|
|
|
|
const antlr4::dfa::Vocabulary& getVocabulary() const override;
|
|
|
|
antlr4::atn::SerializedATNView getSerializedATN() const override;
|
|
|
|
|
|
class ProgramContext;
|
|
class DeclarationContext;
|
|
class ExpressionContext;
|
|
class VarDeclContext;
|
|
class IdentifierListContext;
|
|
class StatementContext;
|
|
class ReturnStmtContext;
|
|
class ThrowStmtContext;
|
|
class CatchBlockContext;
|
|
class TryCatchStmtContext;
|
|
class IfStmtContext;
|
|
class WhileStmtContext;
|
|
class ForStmtContext;
|
|
class ForInStmtContext;
|
|
class FuncStmtContext;
|
|
class VarAssignmentContext;
|
|
class ExprStmtContext;
|
|
class EmptyStmtContext;
|
|
class BlockContext;
|
|
class KvPairContext;
|
|
class KvPairListContext;
|
|
class SelectContext;
|
|
class SelectStmtWithParensContext;
|
|
class SubsequentSelectSetClauseContext;
|
|
class SelectSetStmtContext;
|
|
class LimitAndOffsetClauseOptionalContext;
|
|
class SelectStmtContext;
|
|
class WithClauseContext;
|
|
class TopClauseContext;
|
|
class FromClauseContext;
|
|
class ArrayJoinClauseContext;
|
|
class WindowClauseContext;
|
|
class PrewhereClauseContext;
|
|
class WhereClauseContext;
|
|
class GroupByClauseContext;
|
|
class GroupingSetListContext;
|
|
class GroupingSetContext;
|
|
class HavingClauseContext;
|
|
class QualifyClauseContext;
|
|
class OrderByClauseContext;
|
|
class InterpolateClauseContext;
|
|
class ProjectionOrderByClauseContext;
|
|
class LimitByClauseContext;
|
|
class LimitAndOffsetClauseContext;
|
|
class OffsetOnlyClauseContext;
|
|
class SettingsClauseContext;
|
|
class ValuesClauseContext;
|
|
class ValuesRowContext;
|
|
class JoinExprContext;
|
|
class JoinOpContext;
|
|
class JoinOpCrossContext;
|
|
class JoinConstraintClauseContext;
|
|
class SampleClauseContext;
|
|
class LimitExprContext;
|
|
class OrderExprListContext;
|
|
class OrderExprContext;
|
|
class WithFillClauseContext;
|
|
class InterpolateExprContext;
|
|
class RatioExprContext;
|
|
class SettingExprListContext;
|
|
class SettingExprContext;
|
|
class WindowExprContext;
|
|
class WinPartitionByClauseContext;
|
|
class WinOrderByClauseContext;
|
|
class WithinGroupClauseContext;
|
|
class WinFrameClauseContext;
|
|
class WinFrameExtendContext;
|
|
class WinFrameBoundContext;
|
|
class ExprContext;
|
|
class ColumnTypeExprContext;
|
|
class ColumnTypeCastExprContext;
|
|
class ColumnTypeCastIdentifierContext;
|
|
class KeywordForTypeCastContext;
|
|
class ColumnExprListContext;
|
|
class SelectColumnExprListBeforeFromContext;
|
|
class SelectColumnExprListContext;
|
|
class SelectColumnExprContext;
|
|
class ColumnExprContext;
|
|
class ColumnExprValueContext;
|
|
class ColumnLambdaExprContext;
|
|
class ColumnsReplaceListContext;
|
|
class ColumnsReplaceItemContext;
|
|
class InsightsqlxChildElementContext;
|
|
class InsightsqlxTextContext;
|
|
class InsightsqlxTagElementContext;
|
|
class InsightsqlxTagAttributeContext;
|
|
class WithExprListContext;
|
|
class WithExprContext;
|
|
class WithExprColumnNameListContext;
|
|
class ColumnIdentifierContext;
|
|
class NestedIdentifierContext;
|
|
class TableExprContext;
|
|
class PivotColumnListContext;
|
|
class PivotColumnContext;
|
|
class UnpivotColumnListContext;
|
|
class UnpivotColumnContext;
|
|
class ColumnExprTupleOrSingleContext;
|
|
class ColumnAliasesContext;
|
|
class TableFunctionExprContext;
|
|
class TableIdentifierContext;
|
|
class TableArgListContext;
|
|
class DatabaseIdentifierContext;
|
|
class FloatingLiteralContext;
|
|
class NumberLiteralContext;
|
|
class LiteralContext;
|
|
class IntervalContext;
|
|
class KeywordContext;
|
|
class KeywordForAliasContext;
|
|
class KeywordForImplicitAliasContext;
|
|
class AliasContext;
|
|
class ImplicitAliasContext;
|
|
class IdentifierContext;
|
|
class EnumValueContext;
|
|
class PlaceholderContext;
|
|
class StringContext;
|
|
class TemplateStringContext;
|
|
class StringContentsContext;
|
|
class FullTemplateStringContext;
|
|
class StringContentsFullContext;
|
|
|
|
class ProgramContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *EOF();
|
|
std::vector<DeclarationContext *> declaration();
|
|
DeclarationContext* declaration(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ProgramContext* program();
|
|
|
|
class DeclarationContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
DeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
VarDeclContext *varDecl();
|
|
StatementContext *statement();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
DeclarationContext* declaration();
|
|
|
|
class ExpressionContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExpressionContext* expression();
|
|
|
|
class VarDeclContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
VarDeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LET();
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *COLONEQUALS();
|
|
ExpressionContext *expression();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
VarDeclContext* varDecl();
|
|
|
|
class IdentifierListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
IdentifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<NestedIdentifierContext *> nestedIdentifier();
|
|
NestedIdentifierContext* nestedIdentifier(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IdentifierListContext* identifierList();
|
|
|
|
class StatementContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ReturnStmtContext *returnStmt();
|
|
ThrowStmtContext *throwStmt();
|
|
TryCatchStmtContext *tryCatchStmt();
|
|
IfStmtContext *ifStmt();
|
|
WhileStmtContext *whileStmt();
|
|
ForInStmtContext *forInStmt();
|
|
ForStmtContext *forStmt();
|
|
FuncStmtContext *funcStmt();
|
|
BlockContext *block();
|
|
ExprStmtContext *exprStmt();
|
|
EmptyStmtContext *emptyStmt();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StatementContext* statement();
|
|
|
|
class ReturnStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ReturnStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *RETURN();
|
|
ExpressionContext *expression();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ReturnStmtContext* returnStmt();
|
|
|
|
class ThrowStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ThrowStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *THROW();
|
|
ExpressionContext *expression();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ThrowStmtContext* throwStmt();
|
|
|
|
class CatchBlockContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsQLParser::IdentifierContext *catchVar = nullptr;
|
|
InsightsQLParser::IdentifierContext *catchType = nullptr;
|
|
InsightsQLParser::BlockContext *catchStmt = nullptr;
|
|
CatchBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CATCH();
|
|
BlockContext *block();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *COLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
CatchBlockContext* catchBlock();
|
|
|
|
class TryCatchStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsQLParser::BlockContext *tryStmt = nullptr;
|
|
InsightsQLParser::BlockContext *finallyStmt = nullptr;
|
|
TryCatchStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *TRY();
|
|
std::vector<BlockContext *> block();
|
|
BlockContext* block(size_t i);
|
|
std::vector<CatchBlockContext *> catchBlock();
|
|
CatchBlockContext* catchBlock(size_t i);
|
|
antlr4::tree::TerminalNode *FINALLY();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TryCatchStmtContext* tryCatchStmt();
|
|
|
|
class IfStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
IfStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IF();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ExpressionContext *expression();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<StatementContext *> statement();
|
|
StatementContext* statement(size_t i);
|
|
antlr4::tree::TerminalNode *ELSE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IfStmtContext* ifStmt();
|
|
|
|
class WhileStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WhileStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WHILE();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ExpressionContext *expression();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
StatementContext *statement();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WhileStmtContext* whileStmt();
|
|
|
|
class ForStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsQLParser::VarDeclContext *initializerVarDeclr = nullptr;
|
|
InsightsQLParser::VarAssignmentContext *initializerVarAssignment = nullptr;
|
|
InsightsQLParser::ExpressionContext *initializerExpression = nullptr;
|
|
InsightsQLParser::ExpressionContext *condition = nullptr;
|
|
InsightsQLParser::VarDeclContext *incrementVarDeclr = nullptr;
|
|
InsightsQLParser::VarAssignmentContext *incrementVarAssignment = nullptr;
|
|
InsightsQLParser::ExpressionContext *incrementExpression = nullptr;
|
|
ForStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FOR();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> SEMICOLON();
|
|
antlr4::tree::TerminalNode* SEMICOLON(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
StatementContext *statement();
|
|
std::vector<VarDeclContext *> varDecl();
|
|
VarDeclContext* varDecl(size_t i);
|
|
std::vector<VarAssignmentContext *> varAssignment();
|
|
VarAssignmentContext* varAssignment(size_t i);
|
|
std::vector<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ForStmtContext* forStmt();
|
|
|
|
class ForInStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ForInStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FOR();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *LET();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *IN();
|
|
ExpressionContext *expression();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
StatementContext *statement();
|
|
antlr4::tree::TerminalNode *COMMA();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ForInStmtContext* forInStmt();
|
|
|
|
class FuncStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FuncStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
BlockContext *block();
|
|
antlr4::tree::TerminalNode *FN();
|
|
antlr4::tree::TerminalNode *FUN();
|
|
IdentifierListContext *identifierList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FuncStmtContext* funcStmt();
|
|
|
|
class VarAssignmentContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
VarAssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
antlr4::tree::TerminalNode *COLONEQUALS();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
VarAssignmentContext* varAssignment();
|
|
|
|
class ExprStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExprStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
antlr4::tree::TerminalNode *COLONEQUALS();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExprStmtContext* exprStmt();
|
|
|
|
class EmptyStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
EmptyStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EmptyStmtContext* emptyStmt();
|
|
|
|
class BlockContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
std::vector<DeclarationContext *> declaration();
|
|
DeclarationContext* declaration(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
BlockContext* block();
|
|
|
|
class KvPairContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KvPairContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ExpressionContext *> expression();
|
|
ExpressionContext* expression(size_t i);
|
|
antlr4::tree::TerminalNode *COLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KvPairContext* kvPair();
|
|
|
|
class KvPairListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KvPairListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<KvPairContext *> kvPair();
|
|
KvPairContext* kvPair(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KvPairListContext* kvPairList();
|
|
|
|
class SelectContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *EOF();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
SelectStmtContext *selectStmt();
|
|
InsightsqlxTagElementContext *insightsqlxTagElement();
|
|
antlr4::tree::TerminalNode *SEMICOLON();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SelectContext* select();
|
|
|
|
class SelectStmtWithParensContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectStmtWithParensContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
SelectStmtContext *selectStmt();
|
|
WithClauseContext *withClause();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
PlaceholderContext *placeholder();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SelectStmtWithParensContext* selectStmtWithParens();
|
|
|
|
class SubsequentSelectSetClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SubsequentSelectSetClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
SelectStmtWithParensContext *selectStmtWithParens();
|
|
antlr4::tree::TerminalNode *EXCEPT();
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *UNION();
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
antlr4::tree::TerminalNode *INTERSECT();
|
|
antlr4::tree::TerminalNode *BY();
|
|
antlr4::tree::TerminalNode *NAME();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SubsequentSelectSetClauseContext* subsequentSelectSetClause();
|
|
|
|
class SelectSetStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectSetStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
SelectStmtWithParensContext *selectStmtWithParens();
|
|
std::vector<SubsequentSelectSetClauseContext *> subsequentSelectSetClause();
|
|
SubsequentSelectSetClauseContext* subsequentSelectSetClause(size_t i);
|
|
OrderByClauseContext *orderByClause();
|
|
LimitAndOffsetClauseOptionalContext *limitAndOffsetClauseOptional();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SelectSetStmtContext* selectSetStmt();
|
|
|
|
class LimitAndOffsetClauseOptionalContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LimitAndOffsetClauseOptionalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LIMIT();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *PERCENT();
|
|
antlr4::tree::TerminalNode *COMMA();
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *TIES();
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LimitAndOffsetClauseOptionalContext* limitAndOffsetClauseOptional();
|
|
|
|
class SelectStmtContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsQLParser::WithClauseContext *with = nullptr;
|
|
InsightsQLParser::SelectColumnExprListBeforeFromContext *columns = nullptr;
|
|
InsightsQLParser::FromClauseContext *from = nullptr;
|
|
InsightsQLParser::WhereClauseContext *where = nullptr;
|
|
SelectStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SELECT();
|
|
SelectColumnExprListBeforeFromContext *selectColumnExprListBeforeFrom();
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
TopClauseContext *topClause();
|
|
ArrayJoinClauseContext *arrayJoinClause();
|
|
PrewhereClauseContext *prewhereClause();
|
|
std::vector<SampleClauseContext *> sampleClause();
|
|
SampleClauseContext* sampleClause(size_t i);
|
|
GroupByClauseContext *groupByClause();
|
|
std::vector<antlr4::tree::TerminalNode *> WITH();
|
|
antlr4::tree::TerminalNode* WITH(size_t i);
|
|
antlr4::tree::TerminalNode *TOTALS();
|
|
HavingClauseContext *havingClause();
|
|
QualifyClauseContext *qualifyClause();
|
|
std::vector<antlr4::tree::TerminalNode *> USING();
|
|
antlr4::tree::TerminalNode* USING(size_t i);
|
|
WindowClauseContext *windowClause();
|
|
OrderByClauseContext *orderByClause();
|
|
LimitByClauseContext *limitByClause();
|
|
LimitAndOffsetClauseContext *limitAndOffsetClause();
|
|
OffsetOnlyClauseContext *offsetOnlyClause();
|
|
SettingsClauseContext *settingsClause();
|
|
WithClauseContext *withClause();
|
|
FromClauseContext *fromClause();
|
|
WhereClauseContext *whereClause();
|
|
antlr4::tree::TerminalNode *CUBE();
|
|
antlr4::tree::TerminalNode *ROLLUP();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SelectStmtContext* selectStmt();
|
|
|
|
class WithClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WITH();
|
|
WithExprListContext *withExprList();
|
|
antlr4::tree::TerminalNode *RECURSIVE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WithClauseContext* withClause();
|
|
|
|
class TopClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TopClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *TOP();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *TIES();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TopClauseContext* topClause();
|
|
|
|
class FromClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FromClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FROM();
|
|
JoinExprContext *joinExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FromClauseContext* fromClause();
|
|
|
|
class ArrayJoinClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ArrayJoinClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ARRAY();
|
|
antlr4::tree::TerminalNode *JOIN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *LEFT();
|
|
antlr4::tree::TerminalNode *INNER();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ArrayJoinClauseContext* arrayJoinClause();
|
|
|
|
class WindowClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WindowClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WINDOW();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> AS();
|
|
antlr4::tree::TerminalNode* AS(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
std::vector<WindowExprContext *> windowExpr();
|
|
WindowExprContext* windowExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WindowClauseContext* windowClause();
|
|
|
|
class PrewhereClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
PrewhereClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *PREWHERE();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PrewhereClauseContext* prewhereClause();
|
|
|
|
class WhereClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WhereClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WHERE();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WhereClauseContext* whereClause();
|
|
|
|
class GroupByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
GroupByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *GROUP();
|
|
antlr4::tree::TerminalNode *BY();
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *GROUPING();
|
|
antlr4::tree::TerminalNode *SETS();
|
|
GroupingSetListContext *groupingSetList();
|
|
antlr4::tree::TerminalNode *CUBE();
|
|
antlr4::tree::TerminalNode *ROLLUP();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
GroupByClauseContext* groupByClause();
|
|
|
|
class GroupingSetListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
GroupingSetListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<GroupingSetContext *> groupingSet();
|
|
GroupingSetContext* groupingSet(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
GroupingSetListContext* groupingSetList();
|
|
|
|
class GroupingSetContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
GroupingSetContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
GroupingSetContext* groupingSet();
|
|
|
|
class HavingClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
HavingClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *HAVING();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
HavingClauseContext* havingClause();
|
|
|
|
class QualifyClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
QualifyClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *QUALIFY();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
QualifyClauseContext* qualifyClause();
|
|
|
|
class OrderByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
OrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ORDER();
|
|
antlr4::tree::TerminalNode *BY();
|
|
OrderExprListContext *orderExprList();
|
|
InterpolateClauseContext *interpolateClause();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
OrderByClauseContext* orderByClause();
|
|
|
|
class InterpolateClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InterpolateClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *INTERPOLATE();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<InterpolateExprContext *> interpolateExpr();
|
|
InterpolateExprContext* interpolateExpr(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
InterpolateClauseContext* interpolateClause();
|
|
|
|
class ProjectionOrderByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ProjectionOrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ORDER();
|
|
antlr4::tree::TerminalNode *BY();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ProjectionOrderByClauseContext* projectionOrderByClause();
|
|
|
|
class LimitByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LimitByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LIMIT();
|
|
LimitExprContext *limitExpr();
|
|
antlr4::tree::TerminalNode *BY();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LimitByClauseContext* limitByClause();
|
|
|
|
class LimitAndOffsetClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LimitAndOffsetClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LIMIT();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *PERCENT();
|
|
antlr4::tree::TerminalNode *COMMA();
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *TIES();
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LimitAndOffsetClauseContext* limitAndOffsetClause();
|
|
|
|
class OffsetOnlyClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
OffsetOnlyClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
OffsetOnlyClauseContext* offsetOnlyClause();
|
|
|
|
class SettingsClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SettingsClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SETTINGS();
|
|
SettingExprListContext *settingExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SettingsClauseContext* settingsClause();
|
|
|
|
class ValuesClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ValuesClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *VALUES();
|
|
std::vector<ValuesRowContext *> valuesRow();
|
|
ValuesRowContext* valuesRow(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ValuesClauseContext* valuesClause();
|
|
|
|
class ValuesRowContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ValuesRowContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ValuesRowContext* valuesRow();
|
|
|
|
class JoinExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
JoinExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
JoinExprContext() = default;
|
|
void copyFrom(JoinExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class JoinExprPositionalContext : public JoinExprContext {
|
|
public:
|
|
JoinExprPositionalContext(JoinExprContext *ctx);
|
|
|
|
std::vector<JoinExprContext *> joinExpr();
|
|
JoinExprContext* joinExpr(size_t i);
|
|
antlr4::tree::TerminalNode *POSITIONAL();
|
|
antlr4::tree::TerminalNode *JOIN();
|
|
JoinConstraintClauseContext *joinConstraintClause();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprOpContext : public JoinExprContext {
|
|
public:
|
|
JoinExprOpContext(JoinExprContext *ctx);
|
|
|
|
std::vector<JoinExprContext *> joinExpr();
|
|
JoinExprContext* joinExpr(size_t i);
|
|
antlr4::tree::TerminalNode *JOIN();
|
|
antlr4::tree::TerminalNode *NATURAL();
|
|
JoinOpContext *joinOp();
|
|
JoinConstraintClauseContext *joinConstraintClause();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprTableContext : public JoinExprContext {
|
|
public:
|
|
JoinExprTableContext(JoinExprContext *ctx);
|
|
|
|
TableExprContext *tableExpr();
|
|
antlr4::tree::TerminalNode *FINAL();
|
|
SampleClauseContext *sampleClause();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprUnpivotContext : public JoinExprContext {
|
|
public:
|
|
JoinExprUnpivotContext(JoinExprContext *ctx);
|
|
|
|
JoinExprContext *joinExpr();
|
|
antlr4::tree::TerminalNode *UNPIVOT();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
UnpivotColumnListContext *unpivotColumnList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *INCLUDE();
|
|
antlr4::tree::TerminalNode *NULLS();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprParensContext : public JoinExprContext {
|
|
public:
|
|
JoinExprParensContext(JoinExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
JoinExprContext *joinExpr();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprCrossOpContext : public JoinExprContext {
|
|
public:
|
|
JoinExprCrossOpContext(JoinExprContext *ctx);
|
|
|
|
std::vector<JoinExprContext *> joinExpr();
|
|
JoinExprContext* joinExpr(size_t i);
|
|
JoinOpCrossContext *joinOpCross();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinExprPivotContext : public JoinExprContext {
|
|
public:
|
|
JoinExprPivotContext(JoinExprContext *ctx);
|
|
|
|
JoinExprContext *joinExpr();
|
|
antlr4::tree::TerminalNode *PIVOT();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
PivotColumnListContext *pivotColumnList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *GROUP();
|
|
antlr4::tree::TerminalNode *BY();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
JoinExprContext* joinExpr();
|
|
JoinExprContext* joinExpr(int precedence);
|
|
class JoinOpContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
JoinOpContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
JoinOpContext() = default;
|
|
void copyFrom(JoinOpContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class JoinOpFullContext : public JoinOpContext {
|
|
public:
|
|
JoinOpFullContext(JoinOpContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *FULL();
|
|
antlr4::tree::TerminalNode *OUTER();
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *ANY();
|
|
antlr4::tree::TerminalNode *ASOF();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinOpInnerContext : public JoinOpContext {
|
|
public:
|
|
JoinOpInnerContext(JoinOpContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *INNER();
|
|
antlr4::tree::TerminalNode *ANTI();
|
|
antlr4::tree::TerminalNode *SEMI();
|
|
antlr4::tree::TerminalNode *ASOF();
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *ANY();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class JoinOpLeftRightContext : public JoinOpContext {
|
|
public:
|
|
JoinOpLeftRightContext(JoinOpContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *ASOF();
|
|
antlr4::tree::TerminalNode *LEFT();
|
|
antlr4::tree::TerminalNode *RIGHT();
|
|
antlr4::tree::TerminalNode *ANTI();
|
|
antlr4::tree::TerminalNode *SEMI();
|
|
antlr4::tree::TerminalNode *OUTER();
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *ANY();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
JoinOpContext* joinOp();
|
|
|
|
class JoinOpCrossContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
JoinOpCrossContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CROSS();
|
|
antlr4::tree::TerminalNode *JOIN();
|
|
antlr4::tree::TerminalNode *COMMA();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
JoinOpCrossContext* joinOpCross();
|
|
|
|
class JoinConstraintClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
JoinConstraintClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ON();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *USING();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
JoinConstraintClauseContext* joinConstraintClause();
|
|
|
|
class SampleClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SampleClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SAMPLE();
|
|
std::vector<RatioExprContext *> ratioExpr();
|
|
RatioExprContext* ratioExpr(size_t i);
|
|
antlr4::tree::TerminalNode *PERCENT();
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SampleClauseContext* sampleClause();
|
|
|
|
class LimitExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LimitExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *COMMA();
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LimitExprContext* limitExpr();
|
|
|
|
class OrderExprListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
OrderExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<OrderExprContext *> orderExpr();
|
|
OrderExprContext* orderExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
OrderExprListContext* orderExprList();
|
|
|
|
class OrderExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
OrderExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *NULLS();
|
|
antlr4::tree::TerminalNode *COLLATE();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
WithFillClauseContext *withFillClause();
|
|
antlr4::tree::TerminalNode *ASCENDING();
|
|
antlr4::tree::TerminalNode *DESCENDING();
|
|
antlr4::tree::TerminalNode *DESC();
|
|
antlr4::tree::TerminalNode *FIRST();
|
|
antlr4::tree::TerminalNode *LAST();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
OrderExprContext* orderExpr();
|
|
|
|
class WithFillClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithFillClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *FILL();
|
|
antlr4::tree::TerminalNode *FROM();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *TO();
|
|
antlr4::tree::TerminalNode *STEP();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WithFillClauseContext* withFillClause();
|
|
|
|
class InterpolateExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InterpolateExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *AS();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
InterpolateExprContext* interpolateExpr();
|
|
|
|
class RatioExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
RatioExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
PlaceholderContext *placeholder();
|
|
std::vector<NumberLiteralContext *> numberLiteral();
|
|
NumberLiteralContext* numberLiteral(size_t i);
|
|
antlr4::tree::TerminalNode *SLASH();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
RatioExprContext* ratioExpr();
|
|
|
|
class SettingExprListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SettingExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<SettingExprContext *> settingExpr();
|
|
SettingExprContext* settingExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SettingExprListContext* settingExprList();
|
|
|
|
class SettingExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SettingExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *EQ_SINGLE();
|
|
LiteralContext *literal();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SettingExprContext* settingExpr();
|
|
|
|
class WindowExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WindowExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
WinPartitionByClauseContext *winPartitionByClause();
|
|
WinOrderByClauseContext *winOrderByClause();
|
|
WinFrameClauseContext *winFrameClause();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WindowExprContext* windowExpr();
|
|
|
|
class WinPartitionByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WinPartitionByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *PARTITION();
|
|
antlr4::tree::TerminalNode *BY();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WinPartitionByClauseContext* winPartitionByClause();
|
|
|
|
class WinOrderByClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WinOrderByClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ORDER();
|
|
antlr4::tree::TerminalNode *BY();
|
|
OrderExprListContext *orderExprList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WinOrderByClauseContext* winOrderByClause();
|
|
|
|
class WithinGroupClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithinGroupClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *WITHIN();
|
|
antlr4::tree::TerminalNode *GROUP();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
OrderByClauseContext *orderByClause();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WithinGroupClauseContext* withinGroupClause();
|
|
|
|
class WinFrameClauseContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WinFrameClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
WinFrameExtendContext *winFrameExtend();
|
|
antlr4::tree::TerminalNode *ROWS();
|
|
antlr4::tree::TerminalNode *RANGE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WinFrameClauseContext* winFrameClause();
|
|
|
|
class WinFrameExtendContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WinFrameExtendContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
WinFrameExtendContext() = default;
|
|
void copyFrom(WinFrameExtendContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class FrameStartContext : public WinFrameExtendContext {
|
|
public:
|
|
FrameStartContext(WinFrameExtendContext *ctx);
|
|
|
|
WinFrameBoundContext *winFrameBound();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class FrameBetweenContext : public WinFrameExtendContext {
|
|
public:
|
|
FrameBetweenContext(WinFrameExtendContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *BETWEEN();
|
|
std::vector<WinFrameBoundContext *> winFrameBound();
|
|
WinFrameBoundContext* winFrameBound(size_t i);
|
|
antlr4::tree::TerminalNode *AND();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
WinFrameExtendContext* winFrameExtend();
|
|
|
|
class WinFrameBoundContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WinFrameBoundContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *CURRENT();
|
|
antlr4::tree::TerminalNode *ROW();
|
|
antlr4::tree::TerminalNode *UNBOUNDED();
|
|
antlr4::tree::TerminalNode *PRECEDING();
|
|
antlr4::tree::TerminalNode *FOLLOWING();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WinFrameBoundContext* winFrameBound();
|
|
|
|
class ExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *EOF();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ExprContext* expr();
|
|
|
|
class ColumnTypeExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnTypeExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
ColumnTypeExprContext() = default;
|
|
void copyFrom(ColumnTypeExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ColumnTypeExprNestedContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprNestedContext(ColumnTypeExprContext *ctx);
|
|
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnTypeExprContext *> columnTypeExpr();
|
|
ColumnTypeExprContext* columnTypeExpr(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprParamContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprParamContext(ColumnTypeExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprArrayContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprArrayContext(ColumnTypeExprContext *ctx);
|
|
|
|
ColumnTypeExprContext *columnTypeExpr();
|
|
antlr4::tree::TerminalNode *LBRACKET();
|
|
antlr4::tree::TerminalNode *RBRACKET();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprComplexContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprComplexContext(ColumnTypeExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnTypeExprContext *> columnTypeExpr();
|
|
ColumnTypeExprContext* columnTypeExpr(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprSimpleContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprSimpleContext(ColumnTypeExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprEnumContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprEnumContext(ColumnTypeExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<EnumValueContext *> enumValue();
|
|
EnumValueContext* enumValue(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeExprCompoundContext : public ColumnTypeExprContext {
|
|
public:
|
|
ColumnTypeExprCompoundContext(ColumnTypeExprContext *ctx);
|
|
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
ColumnTypeExprContext* columnTypeExpr();
|
|
ColumnTypeExprContext* columnTypeExpr(int precedence);
|
|
class ColumnTypeCastExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnTypeCastExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
ColumnTypeCastExprContext() = default;
|
|
void copyFrom(ColumnTypeCastExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ColumnTypeCastExprSimpleContext : public ColumnTypeCastExprContext {
|
|
public:
|
|
ColumnTypeCastExprSimpleContext(ColumnTypeCastExprContext *ctx);
|
|
|
|
ColumnTypeCastIdentifierContext *columnTypeCastIdentifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnTypeCastExprWithTimeZoneContext : public ColumnTypeCastExprContext {
|
|
public:
|
|
ColumnTypeCastExprWithTimeZoneContext(ColumnTypeCastExprContext *ctx);
|
|
|
|
ColumnTypeCastIdentifierContext *columnTypeCastIdentifier();
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *TIME();
|
|
antlr4::tree::TerminalNode *ZONE();
|
|
antlr4::tree::TerminalNode *LOCAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
ColumnTypeCastExprContext* columnTypeCastExpr();
|
|
|
|
class ColumnTypeCastIdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnTypeCastIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
|
|
IntervalContext *interval();
|
|
KeywordForTypeCastContext *keywordForTypeCast();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnTypeCastIdentifierContext* columnTypeCastIdentifier();
|
|
|
|
class KeywordForTypeCastContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KeywordForTypeCastContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *DATE();
|
|
antlr4::tree::TerminalNode *TIME();
|
|
antlr4::tree::TerminalNode *TIMESTAMP();
|
|
antlr4::tree::TerminalNode *INTERVAL();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KeywordForTypeCastContext* keywordForTypeCast();
|
|
|
|
class ColumnExprListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnExprListContext* columnExprList();
|
|
|
|
class SelectColumnExprListBeforeFromContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectColumnExprListBeforeFromContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
SelectColumnExprListBeforeFromContext() = default;
|
|
void copyFrom(SelectColumnExprListBeforeFromContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class SelectColumnExprListBeforeFromTrailingCommaContext : public SelectColumnExprListBeforeFromContext {
|
|
public:
|
|
SelectColumnExprListBeforeFromTrailingCommaContext(SelectColumnExprListBeforeFromContext *ctx);
|
|
|
|
std::vector<SelectColumnExprContext *> selectColumnExpr();
|
|
SelectColumnExprContext* selectColumnExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class SelectColumnExprListBeforeFromPlainContext : public SelectColumnExprListBeforeFromContext {
|
|
public:
|
|
SelectColumnExprListBeforeFromPlainContext(SelectColumnExprListBeforeFromContext *ctx);
|
|
|
|
SelectColumnExprListContext *selectColumnExprList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
SelectColumnExprListBeforeFromContext* selectColumnExprListBeforeFrom();
|
|
|
|
class SelectColumnExprListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectColumnExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<SelectColumnExprContext *> selectColumnExpr();
|
|
SelectColumnExprContext* selectColumnExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
SelectColumnExprListContext* selectColumnExprList();
|
|
|
|
class SelectColumnExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
SelectColumnExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
SelectColumnExprContext() = default;
|
|
void copyFrom(SelectColumnExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ColumnExprAliasBeforeContext : public SelectColumnExprContext {
|
|
public:
|
|
ColumnExprAliasBeforeContext(SelectColumnExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *COLON();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprInvalidFromImplicitAliasContext : public SelectColumnExprContext {
|
|
public:
|
|
ColumnExprInvalidFromImplicitAliasContext(SelectColumnExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *FROM();
|
|
ImplicitAliasContext *implicitAlias();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprAliasImplicitContext : public SelectColumnExprContext {
|
|
public:
|
|
ColumnExprAliasImplicitContext(SelectColumnExprContext *ctx);
|
|
|
|
ColumnExprContext *columnExpr();
|
|
ImplicitAliasContext *implicitAlias();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprSelectValueContext : public SelectColumnExprContext {
|
|
public:
|
|
ColumnExprSelectValueContext(SelectColumnExprContext *ctx);
|
|
|
|
ColumnExprContext *columnExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
SelectColumnExprContext* selectColumnExpr();
|
|
|
|
class ColumnExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
ColumnExprContext() = default;
|
|
void copyFrom(ColumnExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ColumnExprTernaryOpContext : public ColumnExprContext {
|
|
public:
|
|
ColumnExprTernaryOpContext(ColumnExprContext *ctx);
|
|
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *QUERY();
|
|
antlr4::tree::TerminalNode *COLON();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprAliasContext : public ColumnExprContext {
|
|
public:
|
|
ColumnExprAliasContext(ColumnExprContext *ctx);
|
|
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *AS();
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprAndContext : public ColumnExprContext {
|
|
public:
|
|
ColumnExprAndContext(ColumnExprContext *ctx);
|
|
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *AND();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprValuePassthroughContext : public ColumnExprContext {
|
|
public:
|
|
ColumnExprValuePassthroughContext(ColumnExprContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprOrContext : public ColumnExprContext {
|
|
public:
|
|
ColumnExprOrContext(ColumnExprContext *ctx);
|
|
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *OR();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
ColumnExprContext* columnExpr();
|
|
ColumnExprContext* columnExpr(int precedence);
|
|
class ColumnExprValueContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnExprValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
ColumnExprValueContext() = default;
|
|
void copyFrom(ColumnExprValueContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ColumnExprColumnsAllContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsAllContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNegateContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNegateContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *DASH();
|
|
ColumnExprValueContext *columnExprValue();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprLiteralContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprLiteralContext(ColumnExprValueContext *ctx);
|
|
|
|
LiteralContext *literal();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprArrayContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprArrayContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LBRACKET();
|
|
antlr4::tree::TerminalNode *RBRACKET();
|
|
antlr4::tree::TerminalNode *ARRAY();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprPrecedence1Context : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprPrecedence1Context(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprValueContext *left = nullptr;
|
|
antlr4::Token *operator_ = nullptr;
|
|
InsightsQLParser::ColumnExprValueContext *right = nullptr;
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *SLASH();
|
|
antlr4::tree::TerminalNode *PERCENT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprPrecedence2Context : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprPrecedence2Context(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprValueContext *left = nullptr;
|
|
antlr4::Token *operator_ = nullptr;
|
|
InsightsQLParser::ColumnExprValueContext *right = nullptr;
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *PLUS();
|
|
antlr4::tree::TerminalNode *DASH();
|
|
antlr4::tree::TerminalNode *CONCAT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNullSafeEqContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNullSafeEqContext(ColumnExprValueContext *ctx);
|
|
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *NULL_SAFE_EQ();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprPrecedence3Context : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprPrecedence3Context(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprValueContext *left = nullptr;
|
|
antlr4::Token *operator_ = nullptr;
|
|
InsightsQLParser::ColumnExprValueContext *right = nullptr;
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *IN();
|
|
antlr4::tree::TerminalNode *EQ_DOUBLE();
|
|
antlr4::tree::TerminalNode *EQ_SINGLE();
|
|
antlr4::tree::TerminalNode *NOT_EQ();
|
|
antlr4::tree::TerminalNode *LT_EQ();
|
|
antlr4::tree::TerminalNode *LT();
|
|
antlr4::tree::TerminalNode *GT_EQ();
|
|
antlr4::tree::TerminalNode *GT();
|
|
antlr4::tree::TerminalNode *LIKE();
|
|
antlr4::tree::TerminalNode *ILIKE();
|
|
antlr4::tree::TerminalNode *REGEX_SINGLE();
|
|
antlr4::tree::TerminalNode *REGEX_DOUBLE();
|
|
antlr4::tree::TerminalNode *NOT_REGEX();
|
|
antlr4::tree::TerminalNode *IREGEX_SINGLE();
|
|
antlr4::tree::TerminalNode *IREGEX_DOUBLE();
|
|
antlr4::tree::TerminalNode *NOT_IREGEX();
|
|
antlr4::tree::TerminalNode *COHORT();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIntervalContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIntervalContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *INTERVAL();
|
|
ColumnExprContext *columnExpr();
|
|
IntervalContext *interval();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIsNullContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIsNullContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *IS();
|
|
antlr4::tree::TerminalNode *NULL_SQL();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprWinFunctionTargetContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprWinFunctionTargetContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprListContext *columnExprs = nullptr;
|
|
InsightsQLParser::ColumnExprListContext *columnArgList = nullptr;
|
|
InsightsQLParser::ColumnExprContext *filterExpr = nullptr;
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *OVER();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *FILTER();
|
|
antlr4::tree::TerminalNode *WHERE();
|
|
ColumnExprContext *columnExpr();
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNamedArgContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNamedArgContext(ColumnExprValueContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *COLONEQUALS();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNullPropertyAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNullPropertyAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *NULL_PROPERTY();
|
|
IdentifierContext *identifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIntervalStringContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIntervalStringContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *INTERVAL();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTagElementContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTagElementContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsqlxTagElementContext *insightsqlxTagElement();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprCallContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprCallContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprArrayAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprArrayAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *LBRACKET();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACKET();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprBetweenContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprBetweenContext(ColumnExprValueContext *ctx);
|
|
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *BETWEEN();
|
|
antlr4::tree::TerminalNode *AND();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprParensContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprParensContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTimestampContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTimestampContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *TIMESTAMP();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsQualifiedExcludeContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsQualifiedExcludeContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
IdentifierListContext *identifierList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNotContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNotContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *NOT();
|
|
ColumnExprValueContext *columnExprValue();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprFunctionContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprFunctionContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprListContext *columnExprs = nullptr;
|
|
InsightsQLParser::ColumnExprListContext *columnArgList = nullptr;
|
|
InsightsQLParser::ColumnExprContext *filterExpr = nullptr;
|
|
IdentifierContext *identifier();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
antlr4::tree::TerminalNode *ORDER();
|
|
antlr4::tree::TerminalNode *BY();
|
|
OrderExprListContext *orderExprList();
|
|
antlr4::tree::TerminalNode *FILTER();
|
|
antlr4::tree::TerminalNode *WHERE();
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
ColumnExprContext *columnExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprDictContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprDictContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
KvPairListContext *kvPairList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprSubqueryContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprSubqueryContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprSubstringContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprSubstringContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *SUBSTRING();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
antlr4::tree::TerminalNode *FROM();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *FOR();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprCastContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprCastContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *CAST();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *AS();
|
|
ColumnTypeExprContext *columnTypeExpr();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprArraySliceContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprArraySliceContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *LBRACKET();
|
|
antlr4::tree::TerminalNode *COLON();
|
|
antlr4::tree::TerminalNode *RBRACKET();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsQualifiedReplaceContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsQualifiedReplaceContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *REPLACE();
|
|
ColumnsReplaceListContext *columnsReplaceList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNullTupleAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNullTupleAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *NULL_PROPERTY();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprFunctionWithinGroupContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprFunctionWithinGroupContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprListContext *columnExprs = nullptr;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
WithinGroupClauseContext *withinGroupClause();
|
|
ColumnExprListContext *columnExprList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprPositionalContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprPositionalContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *HASH();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsRegexContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsRegexContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTypeCastContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTypeCastContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *DOUBLECOLON();
|
|
ColumnTypeCastExprContext *columnTypeCastExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIsDistinctFromContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIsDistinctFromContext(ColumnExprValueContext *ctx);
|
|
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *IS();
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
antlr4::tree::TerminalNode *FROM();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprSpreadColumnsListContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprSpreadColumnsListContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsExcludeReplaceContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsExcludeReplaceContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
IdentifierListContext *identifierList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *REPLACE();
|
|
ColumnsReplaceListContext *columnsReplaceList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsQualifiedExcludeReplaceContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsQualifiedExcludeReplaceContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
IdentifierListContext *identifierList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *REPLACE();
|
|
ColumnsReplaceListContext *columnsReplaceList();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsExcludeContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsExcludeContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
IdentifierListContext *identifierList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColonLambdaContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColonLambdaContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LAMBDA();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *COLON();
|
|
ColumnExprContext *columnExpr();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprCallSelectContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprCallSelectContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsQualifiedAllContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsQualifiedAllContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTrimContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTrimContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *TRIM();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
StringContext *string();
|
|
antlr4::tree::TerminalNode *FROM();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *BOTH();
|
|
antlr4::tree::TerminalNode *LEADING();
|
|
antlr4::tree::TerminalNode *TRAILING();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTemplateStringContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTemplateStringContext(ColumnExprValueContext *ctx);
|
|
|
|
TemplateStringContext *templateString();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTupleContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTupleContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTryCastContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTryCastContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *TRY_CAST();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *AS();
|
|
ColumnTypeExprContext *columnTypeExpr();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsListContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsListContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprColumnsReplaceContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprColumnsReplaceContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *REPLACE();
|
|
ColumnsReplaceListContext *columnsReplaceList();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprSpreadColumnsRegexContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprSpreadColumnsRegexContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprPropertyAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprPropertyAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
IdentifierContext *identifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNullArrayAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNullArrayAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *NULL_PROPERTY();
|
|
antlr4::tree::TerminalNode *LBRACKET();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACKET();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIgnoreNullsContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIgnoreNullsContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *IGNORE();
|
|
antlr4::tree::TerminalNode *NULLS();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprNullishContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprNullishContext(ColumnExprValueContext *ctx);
|
|
|
|
std::vector<ColumnExprValueContext *> columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(size_t i);
|
|
antlr4::tree::TerminalNode *NULLISH();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprTupleAccessContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprTupleAccessContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnExprValueContext *columnExprValue();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprCaseContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprCaseContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprContext *caseExpr = nullptr;
|
|
InsightsQLParser::ColumnExprContext *whenExpr = nullptr;
|
|
InsightsQLParser::ColumnExprContext *thenExpr = nullptr;
|
|
InsightsQLParser::ColumnExprContext *elseExpr = nullptr;
|
|
antlr4::tree::TerminalNode *CASE();
|
|
antlr4::tree::TerminalNode *END();
|
|
std::vector<antlr4::tree::TerminalNode *> WHEN();
|
|
antlr4::tree::TerminalNode* WHEN(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> THEN();
|
|
antlr4::tree::TerminalNode* THEN(size_t i);
|
|
antlr4::tree::TerminalNode *ELSE();
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprDateContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprDateContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *DATE();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprWinFunctionContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprWinFunctionContext(ColumnExprValueContext *ctx);
|
|
|
|
InsightsQLParser::ColumnExprListContext *columnExprs = nullptr;
|
|
InsightsQLParser::ColumnExprListContext *columnArgList = nullptr;
|
|
InsightsQLParser::ColumnExprContext *filterExpr = nullptr;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *OVER();
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
WindowExprContext *windowExpr();
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
antlr4::tree::TerminalNode *FILTER();
|
|
antlr4::tree::TerminalNode *WHERE();
|
|
ColumnExprContext *columnExpr();
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprLambdaContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprLambdaContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnLambdaExprContext *columnLambdaExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprIdentifierContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprIdentifierContext(ColumnExprValueContext *ctx);
|
|
|
|
ColumnIdentifierContext *columnIdentifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColumnExprAsteriskContext : public ColumnExprValueContext {
|
|
public:
|
|
ColumnExprAsteriskContext(ColumnExprValueContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *ASTERISK();
|
|
TableIdentifierContext *tableIdentifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
IdentifierListContext *identifierList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
ColumnExprValueContext* columnExprValue();
|
|
ColumnExprValueContext* columnExprValue(int precedence);
|
|
class ColumnLambdaExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnLambdaExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
ColumnLambdaExprContext() = default;
|
|
void copyFrom(ColumnLambdaExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class ArrowLambdaContext : public ColumnLambdaExprContext {
|
|
public:
|
|
ArrowLambdaContext(ColumnLambdaExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *ARROW();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
ColumnExprContext *columnExpr();
|
|
BlockContext *block();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class ColonLambdaContext : public ColumnLambdaExprContext {
|
|
public:
|
|
ColonLambdaContext(ColumnLambdaExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LAMBDA();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *COLON();
|
|
ColumnExprContext *columnExpr();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
ColumnLambdaExprContext* columnLambdaExpr();
|
|
|
|
class ColumnsReplaceListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnsReplaceListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnsReplaceItemContext *> columnsReplaceItem();
|
|
ColumnsReplaceItemContext* columnsReplaceItem(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnsReplaceListContext* columnsReplaceList();
|
|
|
|
class ColumnsReplaceItemContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnsReplaceItemContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *AS();
|
|
IdentifierContext *identifier();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnsReplaceItemContext* columnsReplaceItem();
|
|
|
|
class InsightsqlxChildElementContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsqlxChildElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
InsightsqlxTagElementContext *insightsqlxTagElement();
|
|
InsightsqlxTextContext *insightsqlxText();
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
InsightsqlxChildElementContext* insightsqlxChildElement();
|
|
|
|
class InsightsqlxTextContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsqlxTextContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *INSIGHTSQLX_TEXT_TEXT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
InsightsqlxTextContext* insightsqlxText();
|
|
|
|
class InsightsqlxTagElementContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsqlxTagElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
InsightsqlxTagElementContext() = default;
|
|
void copyFrom(InsightsqlxTagElementContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class InsightsqlxTagElementClosedContext : public InsightsqlxTagElementContext {
|
|
public:
|
|
InsightsqlxTagElementClosedContext(InsightsqlxTagElementContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LT();
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *SLASH_GT();
|
|
std::vector<InsightsqlxTagAttributeContext *> insightsqlxTagAttribute();
|
|
InsightsqlxTagAttributeContext* insightsqlxTagAttribute(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class InsightsqlxTagElementNestedContext : public InsightsqlxTagElementContext {
|
|
public:
|
|
InsightsqlxTagElementNestedContext(InsightsqlxTagElementContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LT();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> GT();
|
|
antlr4::tree::TerminalNode* GT(size_t i);
|
|
antlr4::tree::TerminalNode *LT_SLASH();
|
|
std::vector<InsightsqlxTagAttributeContext *> insightsqlxTagAttribute();
|
|
InsightsqlxTagAttributeContext* insightsqlxTagAttribute(size_t i);
|
|
std::vector<InsightsqlxChildElementContext *> insightsqlxChildElement();
|
|
InsightsqlxChildElementContext* insightsqlxChildElement(size_t i);
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
InsightsqlxTagElementContext* insightsqlxTagElement();
|
|
|
|
class InsightsqlxTagAttributeContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
InsightsqlxTagAttributeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *EQ_SINGLE();
|
|
StringContext *string();
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
InsightsqlxTagAttributeContext* insightsqlxTagAttribute();
|
|
|
|
class WithExprListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithExprListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<WithExprContext *> withExpr();
|
|
WithExprContext* withExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WithExprListContext* withExprList();
|
|
|
|
class WithExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
WithExprContext() = default;
|
|
void copyFrom(WithExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class WithExprColumnContext : public WithExprContext {
|
|
public:
|
|
WithExprColumnContext(WithExprContext *ctx);
|
|
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *AS();
|
|
IdentifierContext *identifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class WithExprSubqueryContext : public WithExprContext {
|
|
public:
|
|
WithExprSubqueryContext(WithExprContext *ctx);
|
|
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *AS();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<WithExprColumnNameListContext *> withExprColumnNameList();
|
|
WithExprColumnNameListContext* withExprColumnNameList(size_t i);
|
|
antlr4::tree::TerminalNode *USING();
|
|
antlr4::tree::TerminalNode *KEY();
|
|
antlr4::tree::TerminalNode *MATERIALIZED();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
WithExprContext* withExpr();
|
|
|
|
class WithExprColumnNameListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
WithExprColumnNameListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
WithExprColumnNameListContext* withExprColumnNameList();
|
|
|
|
class ColumnIdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
PlaceholderContext *placeholder();
|
|
NestedIdentifierContext *nestedIdentifier();
|
|
TableIdentifierContext *tableIdentifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnIdentifierContext* columnIdentifier();
|
|
|
|
class NestedIdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
NestedIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> DOT();
|
|
antlr4::tree::TerminalNode* DOT(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
NestedIdentifierContext* nestedIdentifier();
|
|
|
|
class TableExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TableExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
|
|
TableExprContext() = default;
|
|
void copyFrom(TableExprContext *context);
|
|
using antlr4::ParserRuleContext::copyFrom;
|
|
|
|
virtual size_t getRuleIndex() const override;
|
|
|
|
|
|
};
|
|
|
|
class TableExprTagContext : public TableExprContext {
|
|
public:
|
|
TableExprTagContext(TableExprContext *ctx);
|
|
|
|
InsightsqlxTagElementContext *insightsqlxTagElement();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprIdentifierContext : public TableExprContext {
|
|
public:
|
|
TableExprIdentifierContext(TableExprContext *ctx);
|
|
|
|
TableIdentifierContext *tableIdentifier();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprPlaceholderContext : public TableExprContext {
|
|
public:
|
|
TableExprPlaceholderContext(TableExprContext *ctx);
|
|
|
|
PlaceholderContext *placeholder();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprSubqueryContext : public TableExprContext {
|
|
public:
|
|
TableExprSubqueryContext(TableExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
SelectSetStmtContext *selectSetStmt();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprPivotContext : public TableExprContext {
|
|
public:
|
|
TableExprPivotContext(TableExprContext *ctx);
|
|
|
|
TableExprContext *tableExpr();
|
|
antlr4::tree::TerminalNode *PIVOT();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
PivotColumnListContext *pivotColumnList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *GROUP();
|
|
antlr4::tree::TerminalNode *BY();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprValuesContext : public TableExprContext {
|
|
public:
|
|
TableExprValuesContext(TableExprContext *ctx);
|
|
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ValuesClauseContext *valuesClause();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprAliasContext : public TableExprContext {
|
|
public:
|
|
TableExprAliasContext(TableExprContext *ctx);
|
|
|
|
TableExprContext *tableExpr();
|
|
AliasContext *alias();
|
|
antlr4::tree::TerminalNode *AS();
|
|
IdentifierContext *identifier();
|
|
ColumnAliasesContext *columnAliases();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprFunctionContext : public TableExprContext {
|
|
public:
|
|
TableExprFunctionContext(TableExprContext *ctx);
|
|
|
|
TableFunctionExprContext *tableFunctionExpr();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
class TableExprUnpivotContext : public TableExprContext {
|
|
public:
|
|
TableExprUnpivotContext(TableExprContext *ctx);
|
|
|
|
TableExprContext *tableExpr();
|
|
antlr4::tree::TerminalNode *UNPIVOT();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
UnpivotColumnListContext *unpivotColumnList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
antlr4::tree::TerminalNode *INCLUDE();
|
|
antlr4::tree::TerminalNode *NULLS();
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
};
|
|
|
|
TableExprContext* tableExpr();
|
|
TableExprContext* tableExpr(int precedence);
|
|
class PivotColumnListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
PivotColumnListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FOR();
|
|
std::vector<PivotColumnContext *> pivotColumn();
|
|
PivotColumnContext* pivotColumn(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PivotColumnListContext* pivotColumnList();
|
|
|
|
class PivotColumnContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
PivotColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
ColumnExprTupleOrSingleContext *columnExprTupleOrSingle();
|
|
antlr4::tree::TerminalNode *IN();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PivotColumnContext* pivotColumn();
|
|
|
|
class UnpivotColumnListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
UnpivotColumnListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<UnpivotColumnContext *> unpivotColumn();
|
|
UnpivotColumnContext* unpivotColumn(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
UnpivotColumnListContext* unpivotColumnList();
|
|
|
|
class UnpivotColumnContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
UnpivotColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnExprTupleOrSingleContext *> columnExprTupleOrSingle();
|
|
ColumnExprTupleOrSingleContext* columnExprTupleOrSingle(size_t i);
|
|
antlr4::tree::TerminalNode *FOR();
|
|
std::vector<antlr4::tree::TerminalNode *> IN();
|
|
antlr4::tree::TerminalNode* IN(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> LPAREN();
|
|
antlr4::tree::TerminalNode* LPAREN(size_t i);
|
|
std::vector<ColumnExprListContext *> columnExprList();
|
|
ColumnExprListContext* columnExprList(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> RPAREN();
|
|
antlr4::tree::TerminalNode* RPAREN(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
UnpivotColumnContext* unpivotColumn();
|
|
|
|
class ColumnExprTupleOrSingleContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnExprTupleOrSingleContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
ColumnExprListContext *columnExprList();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
ColumnExprContext *columnExpr();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnExprTupleOrSingleContext* columnExprTupleOrSingle();
|
|
|
|
class ColumnAliasesContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ColumnAliasesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
std::vector<IdentifierContext *> identifier();
|
|
IdentifierContext* identifier(size_t i);
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ColumnAliasesContext* columnAliases();
|
|
|
|
class TableFunctionExprContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TableFunctionExprContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IdentifierContext *identifier();
|
|
antlr4::tree::TerminalNode *LPAREN();
|
|
antlr4::tree::TerminalNode *RPAREN();
|
|
TableArgListContext *tableArgList();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TableFunctionExprContext* tableFunctionExpr();
|
|
|
|
class TableIdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TableIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
NestedIdentifierContext *nestedIdentifier();
|
|
DatabaseIdentifierContext *databaseIdentifier();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TableIdentifierContext* tableIdentifier();
|
|
|
|
class TableArgListContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TableArgListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
std::vector<ColumnExprContext *> columnExpr();
|
|
ColumnExprContext* columnExpr(size_t i);
|
|
std::vector<antlr4::tree::TerminalNode *> COMMA();
|
|
antlr4::tree::TerminalNode* COMMA(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TableArgListContext* tableArgList();
|
|
|
|
class DatabaseIdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
DatabaseIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
IdentifierContext *identifier();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
DatabaseIdentifierContext* databaseIdentifier();
|
|
|
|
class FloatingLiteralContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FloatingLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FLOATING_LITERAL();
|
|
antlr4::tree::TerminalNode *DOT();
|
|
std::vector<antlr4::tree::TerminalNode *> DECIMAL_LITERAL();
|
|
antlr4::tree::TerminalNode* DECIMAL_LITERAL(size_t i);
|
|
antlr4::tree::TerminalNode *OCTAL_LITERAL();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FloatingLiteralContext* floatingLiteral();
|
|
|
|
class NumberLiteralContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
NumberLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
FloatingLiteralContext *floatingLiteral();
|
|
antlr4::tree::TerminalNode *BINARY_LITERAL();
|
|
antlr4::tree::TerminalNode *OCTAL_LITERAL();
|
|
antlr4::tree::TerminalNode *OCTAL_PREFIX_LITERAL();
|
|
antlr4::tree::TerminalNode *DECIMAL_LITERAL();
|
|
antlr4::tree::TerminalNode *HEXADECIMAL_LITERAL();
|
|
antlr4::tree::TerminalNode *INF();
|
|
antlr4::tree::TerminalNode *NAN_SQL();
|
|
antlr4::tree::TerminalNode *PLUS();
|
|
antlr4::tree::TerminalNode *DASH();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
NumberLiteralContext* numberLiteral();
|
|
|
|
class LiteralContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
NumberLiteralContext *numberLiteral();
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
antlr4::tree::TerminalNode *NULL_SQL();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
LiteralContext* literal();
|
|
|
|
class IntervalContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
IntervalContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *SECOND();
|
|
antlr4::tree::TerminalNode *MINUTE();
|
|
antlr4::tree::TerminalNode *HOUR();
|
|
antlr4::tree::TerminalNode *DAY();
|
|
antlr4::tree::TerminalNode *WEEK();
|
|
antlr4::tree::TerminalNode *MONTH();
|
|
antlr4::tree::TerminalNode *QUARTER();
|
|
antlr4::tree::TerminalNode *YEAR();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IntervalContext* interval();
|
|
|
|
class KeywordContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KeywordContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ALL();
|
|
antlr4::tree::TerminalNode *AND();
|
|
antlr4::tree::TerminalNode *ANTI();
|
|
antlr4::tree::TerminalNode *ANY();
|
|
antlr4::tree::TerminalNode *ARRAY();
|
|
antlr4::tree::TerminalNode *AS();
|
|
antlr4::tree::TerminalNode *ASCENDING();
|
|
antlr4::tree::TerminalNode *ASOF();
|
|
antlr4::tree::TerminalNode *BETWEEN();
|
|
antlr4::tree::TerminalNode *BOTH();
|
|
antlr4::tree::TerminalNode *BY();
|
|
antlr4::tree::TerminalNode *CASE();
|
|
antlr4::tree::TerminalNode *CAST();
|
|
antlr4::tree::TerminalNode *COHORT();
|
|
antlr4::tree::TerminalNode *COLLATE();
|
|
antlr4::tree::TerminalNode *COLUMNS();
|
|
antlr4::tree::TerminalNode *CROSS();
|
|
antlr4::tree::TerminalNode *CUBE();
|
|
antlr4::tree::TerminalNode *CURRENT();
|
|
antlr4::tree::TerminalNode *DATE();
|
|
antlr4::tree::TerminalNode *DESC();
|
|
antlr4::tree::TerminalNode *DESCENDING();
|
|
antlr4::tree::TerminalNode *DISTINCT();
|
|
antlr4::tree::TerminalNode *ELSE();
|
|
antlr4::tree::TerminalNode *END();
|
|
antlr4::tree::TerminalNode *EXCLUDE();
|
|
antlr4::tree::TerminalNode *EXTRACT();
|
|
antlr4::tree::TerminalNode *FILL();
|
|
antlr4::tree::TerminalNode *FILTER();
|
|
antlr4::tree::TerminalNode *FINAL();
|
|
antlr4::tree::TerminalNode *FIRST();
|
|
antlr4::tree::TerminalNode *FOR();
|
|
antlr4::tree::TerminalNode *FOLLOWING();
|
|
antlr4::tree::TerminalNode *FROM();
|
|
antlr4::tree::TerminalNode *FULL();
|
|
antlr4::tree::TerminalNode *GROUP();
|
|
antlr4::tree::TerminalNode *HAVING();
|
|
antlr4::tree::TerminalNode *ID();
|
|
antlr4::tree::TerminalNode *INTERPOLATE();
|
|
antlr4::tree::TerminalNode *IS();
|
|
antlr4::tree::TerminalNode *GROUPING();
|
|
antlr4::tree::TerminalNode *IF();
|
|
antlr4::tree::TerminalNode *IGNORE();
|
|
antlr4::tree::TerminalNode *ILIKE();
|
|
antlr4::tree::TerminalNode *INCLUDE();
|
|
antlr4::tree::TerminalNode *IN();
|
|
antlr4::tree::TerminalNode *INNER();
|
|
antlr4::tree::TerminalNode *INTERVAL();
|
|
antlr4::tree::TerminalNode *JOIN();
|
|
antlr4::tree::TerminalNode *KEY();
|
|
antlr4::tree::TerminalNode *LAMBDA();
|
|
antlr4::tree::TerminalNode *LAST();
|
|
antlr4::tree::TerminalNode *LEADING();
|
|
antlr4::tree::TerminalNode *LEFT();
|
|
antlr4::tree::TerminalNode *LIKE();
|
|
antlr4::tree::TerminalNode *LIMIT();
|
|
antlr4::tree::TerminalNode *LOCAL();
|
|
antlr4::tree::TerminalNode *NAME();
|
|
antlr4::tree::TerminalNode *NATURAL();
|
|
antlr4::tree::TerminalNode *NOT();
|
|
antlr4::tree::TerminalNode *NULLS();
|
|
antlr4::tree::TerminalNode *OFFSET();
|
|
antlr4::tree::TerminalNode *ON();
|
|
antlr4::tree::TerminalNode *OR();
|
|
antlr4::tree::TerminalNode *ORDER();
|
|
antlr4::tree::TerminalNode *OUTER();
|
|
antlr4::tree::TerminalNode *OVER();
|
|
antlr4::tree::TerminalNode *PARTITION();
|
|
antlr4::tree::TerminalNode *PIVOT();
|
|
antlr4::tree::TerminalNode *POSITIONAL();
|
|
antlr4::tree::TerminalNode *PRECEDING();
|
|
antlr4::tree::TerminalNode *PREWHERE();
|
|
antlr4::tree::TerminalNode *QUALIFY();
|
|
antlr4::tree::TerminalNode *RANGE();
|
|
antlr4::tree::TerminalNode *RECURSIVE();
|
|
antlr4::tree::TerminalNode *REPLACE();
|
|
antlr4::tree::TerminalNode *RETURN();
|
|
antlr4::tree::TerminalNode *RIGHT();
|
|
antlr4::tree::TerminalNode *ROLLUP();
|
|
antlr4::tree::TerminalNode *ROW();
|
|
antlr4::tree::TerminalNode *ROWS();
|
|
antlr4::tree::TerminalNode *SAMPLE();
|
|
antlr4::tree::TerminalNode *SELECT();
|
|
antlr4::tree::TerminalNode *SEMI();
|
|
antlr4::tree::TerminalNode *SETS();
|
|
antlr4::tree::TerminalNode *SETTINGS();
|
|
antlr4::tree::TerminalNode *STEP();
|
|
antlr4::tree::TerminalNode *SUBSTRING();
|
|
antlr4::tree::TerminalNode *THEN();
|
|
antlr4::tree::TerminalNode *TIES();
|
|
antlr4::tree::TerminalNode *TIME();
|
|
antlr4::tree::TerminalNode *TIMESTAMP();
|
|
antlr4::tree::TerminalNode *TOTALS();
|
|
antlr4::tree::TerminalNode *TRAILING();
|
|
antlr4::tree::TerminalNode *TRIM();
|
|
antlr4::tree::TerminalNode *TRUNCATE();
|
|
antlr4::tree::TerminalNode *TRY_CAST();
|
|
antlr4::tree::TerminalNode *TO();
|
|
antlr4::tree::TerminalNode *TOP();
|
|
antlr4::tree::TerminalNode *UNBOUNDED();
|
|
antlr4::tree::TerminalNode *UNION();
|
|
antlr4::tree::TerminalNode *UNPIVOT();
|
|
antlr4::tree::TerminalNode *USING();
|
|
antlr4::tree::TerminalNode *VALUES();
|
|
antlr4::tree::TerminalNode *WHEN();
|
|
antlr4::tree::TerminalNode *WHERE();
|
|
antlr4::tree::TerminalNode *WINDOW();
|
|
antlr4::tree::TerminalNode *WITH();
|
|
antlr4::tree::TerminalNode *ZONE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KeywordContext* keyword();
|
|
|
|
class KeywordForAliasContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KeywordForAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *DATE();
|
|
antlr4::tree::TerminalNode *FIRST();
|
|
antlr4::tree::TerminalNode *ID();
|
|
antlr4::tree::TerminalNode *KEY();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KeywordForAliasContext* keywordForAlias();
|
|
|
|
class KeywordForImplicitAliasContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
KeywordForImplicitAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *ASCENDING();
|
|
antlr4::tree::TerminalNode *COHORT();
|
|
antlr4::tree::TerminalNode *DATE();
|
|
antlr4::tree::TerminalNode *DESCENDING();
|
|
antlr4::tree::TerminalNode *FINAL();
|
|
antlr4::tree::TerminalNode *ID();
|
|
antlr4::tree::TerminalNode *RETURN();
|
|
antlr4::tree::TerminalNode *TOP();
|
|
antlr4::tree::TerminalNode *TOTALS();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
KeywordForImplicitAliasContext* keywordForImplicitAlias();
|
|
|
|
class AliasContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
AliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
|
|
KeywordForAliasContext *keywordForAlias();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
AliasContext* alias();
|
|
|
|
class ImplicitAliasContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
ImplicitAliasContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
|
|
KeywordForImplicitAliasContext *keywordForImplicitAlias();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
ImplicitAliasContext* implicitAlias();
|
|
|
|
class IdentifierContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *IDENTIFIER();
|
|
antlr4::tree::TerminalNode *QUOTED_IDENTIFIER();
|
|
IntervalContext *interval();
|
|
KeywordContext *keyword();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
IdentifierContext* identifier();
|
|
|
|
class EnumValueContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
EnumValueContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
StringContext *string();
|
|
antlr4::tree::TerminalNode *EQ_SINGLE();
|
|
NumberLiteralContext *numberLiteral();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
EnumValueContext* enumValue();
|
|
|
|
class PlaceholderContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
PlaceholderContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *LBRACE();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
PlaceholderContext* placeholder();
|
|
|
|
class StringContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *STRING_LITERAL();
|
|
TemplateStringContext *templateString();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StringContext* string();
|
|
|
|
class TemplateStringContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
TemplateStringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *QUOTE_SINGLE_TEMPLATE();
|
|
antlr4::tree::TerminalNode *QUOTE_SINGLE();
|
|
std::vector<StringContentsContext *> stringContents();
|
|
StringContentsContext* stringContents(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
TemplateStringContext* templateString();
|
|
|
|
class StringContentsContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StringContentsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *STRING_ESCAPE_TRIGGER();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
antlr4::tree::TerminalNode *STRING_TEXT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StringContentsContext* stringContents();
|
|
|
|
class FullTemplateStringContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
FullTemplateStringContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *QUOTE_SINGLE_TEMPLATE_FULL();
|
|
antlr4::tree::TerminalNode *EOF();
|
|
std::vector<StringContentsFullContext *> stringContentsFull();
|
|
StringContentsFullContext* stringContentsFull(size_t i);
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
FullTemplateStringContext* fullTemplateString();
|
|
|
|
class StringContentsFullContext : public antlr4::ParserRuleContext {
|
|
public:
|
|
StringContentsFullContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
|
virtual size_t getRuleIndex() const override;
|
|
antlr4::tree::TerminalNode *FULL_STRING_ESCAPE_TRIGGER();
|
|
ColumnExprContext *columnExpr();
|
|
antlr4::tree::TerminalNode *RBRACE();
|
|
antlr4::tree::TerminalNode *FULL_STRING_TEXT();
|
|
|
|
|
|
virtual std::any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
|
|
|
|
};
|
|
|
|
StringContentsFullContext* stringContentsFull();
|
|
|
|
|
|
bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
|
|
|
|
bool joinExprSempred(JoinExprContext *_localctx, size_t predicateIndex);
|
|
bool columnTypeExprSempred(ColumnTypeExprContext *_localctx, size_t predicateIndex);
|
|
bool columnExprSempred(ColumnExprContext *_localctx, size_t predicateIndex);
|
|
bool columnExprValueSempred(ColumnExprValueContext *_localctx, size_t predicateIndex);
|
|
bool tableExprSempred(TableExprContext *_localctx, size_t predicateIndex);
|
|
|
|
// By default the static state used to implement the parser is lazily initialized during the first
|
|
// call to the constructor. You can call this function if you wish to initialize the static state
|
|
// ahead of time.
|
|
static void initialize();
|
|
|
|
private:
|
|
};
|
|
|