hanzoai/insights
2
0
Fork 0
mirror of https://github.com/hanzoai/insights.git synced 2026-10-30 16:15:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
insights/common/insightsql_parser/InsightsQLParser.cpp
T
zeekay d696a015aa fix(brand): one name for the script language, and a guard that keeps it 
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.
2026-08-08 18:38:11 -07:00

18348 lines
613 KiB
C++
Generated
Raw Permalink Blame History

// Generated from InsightsQLParser.g4 by ANTLR 4.13.2
#include "InsightsQLParserVisitor.h"
#include "InsightsQLParser.h"
using namespace antlrcpp;
using namespace antlr4;
namespace {
struct InsightsQLParserStaticData final {
InsightsQLParserStaticData(std::vector<std::string> ruleNames,
std::vector<std::string> literalNames,
std::vector<std::string> symbolicNames)
: ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
symbolicNames(std::move(symbolicNames)),
vocabulary(this->literalNames, this->symbolicNames) {}
InsightsQLParserStaticData(const InsightsQLParserStaticData&) = delete;
InsightsQLParserStaticData(InsightsQLParserStaticData&&) = delete;
InsightsQLParserStaticData& operator=(const InsightsQLParserStaticData&) = delete;
InsightsQLParserStaticData& operator=(InsightsQLParserStaticData&&) = delete;
std::vector<antlr4::dfa::DFA> decisionToDFA;
antlr4::atn::PredictionContextCache sharedContextCache;
const std::vector<std::string> ruleNames;
const std::vector<std::string> literalNames;
const std::vector<std::string> symbolicNames;
const antlr4::dfa::Vocabulary vocabulary;
antlr4::atn::SerializedATNView serializedATN;
std::unique_ptr<antlr4::atn::ATN> atn;
};
::antlr4::internal::OnceFlag insightsqlparserParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
std::unique_ptr<InsightsQLParserStaticData> insightsqlparserParserStaticData = nullptr;
void insightsqlparserParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
if (insightsqlparserParserStaticData != nullptr) {
return;
}
#else
assert(insightsqlparserParserStaticData == nullptr);
#endif
auto staticData = std::make_unique<InsightsQLParserStaticData>(
std::vector<std::string>{
"program", "declaration", "expression", "varDecl", "identifierList",
"statement", "returnStmt", "throwStmt", "catchBlock", "tryCatchStmt",
"ifStmt", "whileStmt", "forStmt", "forInStmt", "funcStmt", "varAssignment",
"exprStmt", "emptyStmt", "block", "kvPair", "kvPairList", "select",
"selectStmtWithParens", "subsequentSelectSetClause", "selectSetStmt",
"limitAndOffsetClauseOptional", "selectStmt", "withClause", "topClause",
"fromClause", "arrayJoinClause", "windowClause", "prewhereClause",
"whereClause", "groupByClause", "groupingSetList", "groupingSet",
"havingClause", "qualifyClause", "orderByClause", "interpolateClause",
"projectionOrderByClause", "limitByClause", "limitAndOffsetClause",
"offsetOnlyClause", "settingsClause", "valuesClause", "valuesRow",
"joinExpr", "joinOp", "joinOpCross", "joinConstraintClause", "sampleClause",
"limitExpr", "orderExprList", "orderExpr", "withFillClause", "interpolateExpr",
"ratioExpr", "settingExprList", "settingExpr", "windowExpr", "winPartitionByClause",
"winOrderByClause", "withinGroupClause", "winFrameClause", "winFrameExtend",
"winFrameBound", "expr", "columnTypeExpr", "columnTypeCastExpr", "columnTypeCastIdentifier",
"keywordForTypeCast", "columnExprList", "selectColumnExprListBeforeFrom",
"selectColumnExprList", "selectColumnExpr", "columnExpr", "columnExprValue",
"columnLambdaExpr", "columnsReplaceList", "columnsReplaceItem", "insightsqlxChildElement",
"insightsqlxText", "insightsqlxTagElement", "insightsqlxTagAttribute", "withExprList",
"withExpr", "withExprColumnNameList", "columnIdentifier", "nestedIdentifier",
"tableExpr", "pivotColumnList", "pivotColumn", "unpivotColumnList",
"unpivotColumn", "columnExprTupleOrSingle", "columnAliases", "tableFunctionExpr",
"tableIdentifier", "tableArgList", "databaseIdentifier", "floatingLiteral",
"numberLiteral", "literal", "interval", "keyword", "keywordForAlias",
"keywordForImplicitAlias", "alias", "implicitAlias", "identifier",
"enumValue", "placeholder", "string", "templateString", "stringContents",
"fullTemplateString", "stringContentsFull"
},
std::vector<std::string>{
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "'->'", "'*'", "'`'", "'\\'", "'::'",
"':='", "':'", "','", "'||'", "'-'", "'$'", "'.'", "'=='", "", "'>='",
"", "'#'", "'~*'", "'=~*'", "'{'", "'['", "'('", "'<=>'", "'<='",
"'<'", "'</'", "", "'!~*'", "'!~'", "'\\u003F.'", "'\\u003F\\u003F'",
"'%'", "'+'", "'\\u003F'", "'\"'", "'f''", "'F''", "'''", "'~'", "'=~'",
"'}'", "']'", "')'", "';'", "'/'", "", "'_'"
},
std::vector<std::string>{
"", "ALL", "AND", "ANTI", "ANY", "ARRAY", "AS", "ASCENDING", "ASOF",
"BETWEEN", "BOTH", "BY", "CASE", "CAST", "CATCH", "COHORT", "COLLATE",
"COLUMNS", "CROSS", "CUBE", "CURRENT", "DATE", "DAY", "DESC", "DESCENDING",
"DISTINCT", "ELSE", "END", "EXCEPT", "EXCLUDE", "EXTRACT", "FINAL",
"FILL", "FILTER", "FINALLY", "FIRST", "FN", "FOLLOWING", "FOR", "FROM",
"FULL", "FUN", "GROUP", "GROUPING", "HAVING", "HOUR", "ID", "IF",
"ILIKE", "IGNORE", "INCLUDE", "IN", "INF", "INNER", "INTERSECT", "INTERPOLATE",
"INTERVAL", "IS", "JOIN", "KEY", "LAMBDA", "LAST", "LEADING", "LEFT",
"LET", "LIKE", "LIMIT", "MATERIALIZED", "MINUTE", "MONTH", "NAME",
"NATURAL", "NAN_SQL", "NOT", "NULL_SQL", "NULLS", "OFFSET", "ON",
"OR", "ORDER", "OUTER", "OVER", "PARTITION", "PIVOT", "POSITIONAL",
"PRECEDING", "PREWHERE", "QUALIFY", "QUARTER", "RANGE", "RECURSIVE",
"REPLACE", "RETURN", "RIGHT", "ROLLUP", "ROW", "ROWS", "SAMPLE", "SECOND",
"SELECT", "SEMI", "SETS", "SETTINGS", "STEP", "SUBSTRING", "THEN",
"THROW", "TIES", "TIMESTAMP", "TIME", "LOCAL", "ZONE", "TO", "TOP",
"TOTALS", "TRAILING", "TRIM", "TRUNCATE", "TRY", "TRY_CAST", "UNBOUNDED",
"UNION", "UNPIVOT", "USING", "VALUES", "WEEK", "WHEN", "WHERE", "WHILE",
"WINDOW", "WITH", "WITHIN", "YEAR", "ESCAPE_CHAR_COMMON", "IDENTIFIER",
"QUOTED_IDENTIFIER", "FLOATING_LITERAL", "BINARY_LITERAL", "OCTAL_LITERAL",
"DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "OCTAL_PREFIX_LITERAL",
"MALFORMED_BINARY_LITERAL", "STRING_LITERAL", "ARROW", "ASTERISK",
"BACKQUOTE", "BACKSLASH", "DOUBLECOLON", "COLONEQUALS", "COLON", "COMMA",
"CONCAT", "DASH", "DOLLAR", "DOT", "EQ_DOUBLE", "EQ_SINGLE", "GT_EQ",
"GT", "HASH", "IREGEX_SINGLE", "IREGEX_DOUBLE", "LBRACE", "LBRACKET",
"LPAREN", "NULL_SAFE_EQ", "LT_EQ", "LT", "LT_SLASH", "NOT_EQ", "NOT_IREGEX",
"NOT_REGEX", "NULL_PROPERTY", "NULLISH", "PERCENT", "PLUS", "QUERY",
"QUOTE_DOUBLE", "QUOTE_SINGLE_TEMPLATE", "QUOTE_SINGLE_TEMPLATE_FULL",
"QUOTE_SINGLE", "REGEX_SINGLE", "REGEX_DOUBLE", "RBRACE", "RBRACKET",
"RPAREN", "SEMICOLON", "SLASH", "SLASH_GT", "UNDERSCORE", "MULTI_LINE_COMMENT",
"SINGLE_LINE_COMMENT", "HASH_COMMENT", "WHITESPACE", "UNEXPECTED_CHARACTER",
"STRING_TEXT", "STRING_ESCAPE_TRIGGER", "FULL_STRING_TEXT", "FULL_STRING_ESCAPE_TRIGGER",
"TAG_MULTI_LINE_COMMENT", "TAG_SINGLE_LINE_COMMENT", "TAG_WS", "TAGC_MULTI_LINE_COMMENT",
"TAGC_SINGLE_LINE_COMMENT", "TAGC_WS", "INSIGHTSQLX_TEXT_TEXT", "INSIGHTSQLX_TEXT_WS"
}
);
static const int32_t serializedATNSegment[] = {
4,1,207,2094,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
7,116,2,117,7,117,2,118,7,118,1,0,5,0,240,8,0,10,0,12,0,243,9,0,1,0,1,
0,1,1,1,1,3,1,249,8,1,1,2,1,2,1,3,1,3,1,3,1,3,3,3,257,8,3,1,4,1,4,1,4,
5,4,262,8,4,10,4,12,4,265,9,4,1,4,3,4,268,8,4,1,5,1,5,1,5,1,5,1,5,1,5,
1,5,1,5,1,5,1,5,1,5,3,5,281,8,5,1,6,1,6,3,6,285,8,6,1,6,3,6,288,8,6,1,
7,1,7,1,7,3,7,293,8,7,1,8,1,8,1,8,1,8,1,8,3,8,300,8,8,1,8,1,8,3,8,304,
8,8,1,8,1,8,1,9,1,9,1,9,5,9,311,8,9,10,9,12,9,314,9,9,1,9,1,9,3,9,318,
8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10,327,8,10,1,11,1,11,1,11,1,
11,1,11,1,11,3,11,335,8,11,1,12,1,12,1,12,1,12,1,12,3,12,342,8,12,1,12,
1,12,3,12,346,8,12,1,12,1,12,1,12,1,12,3,12,352,8,12,1,12,1,12,1,12,3,
12,357,8,12,1,13,1,13,1,13,1,13,1,13,1,13,3,13,365,8,13,1,13,1,13,1,13,
1,13,1,13,3,13,372,8,13,1,14,1,14,1,14,1,14,3,14,378,8,14,1,14,1,14,1,
14,1,15,1,15,1,15,1,15,1,16,1,16,1,16,3,16,390,8,16,1,16,3,16,393,8,16,
1,17,1,17,1,18,1,18,5,18,399,8,18,10,18,12,18,402,9,18,1,18,1,18,1,19,
1,19,1,19,1,19,1,20,1,20,1,20,5,20,413,8,20,10,20,12,20,416,9,20,1,20,
3,20,419,8,20,1,21,1,21,1,21,3,21,424,8,21,1,21,3,21,427,8,21,1,21,1,
21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,442,8,
22,1,23,1,23,1,23,1,23,3,23,448,8,23,1,23,1,23,1,23,3,23,453,8,23,1,23,
1,23,1,23,1,23,3,23,459,8,23,1,23,1,23,1,23,1,23,3,23,465,8,23,1,23,1,
23,1,23,3,23,470,8,23,1,23,1,23,1,23,1,23,3,23,476,8,23,1,23,1,23,1,23,
1,23,3,23,482,8,23,1,23,1,23,1,23,3,23,487,8,23,3,23,489,8,23,1,23,1,
23,1,24,1,24,5,24,495,8,24,10,24,12,24,498,9,24,1,24,3,24,501,8,24,1,
24,3,24,504,8,24,1,25,1,25,1,25,3,25,509,8,25,1,25,1,25,3,25,513,8,25,
1,25,1,25,3,25,517,8,25,1,25,1,25,1,25,3,25,522,8,25,1,25,1,25,3,25,526,
8,25,1,25,1,25,1,25,1,25,1,25,3,25,533,8,25,1,26,3,26,536,8,26,1,26,1,
26,3,26,540,8,26,1,26,3,26,543,8,26,1,26,1,26,3,26,547,8,26,1,26,3,26,
550,8,26,1,26,3,26,553,8,26,1,26,3,26,556,8,26,1,26,3,26,559,8,26,1,26,
3,26,562,8,26,1,26,3,26,565,8,26,1,26,1,26,3,26,569,8,26,1,26,1,26,3,
26,573,8,26,1,26,3,26,576,8,26,1,26,3,26,579,8,26,1,26,1,26,3,26,583,
8,26,1,26,3,26,586,8,26,1,26,3,26,589,8,26,1,26,3,26,592,8,26,1,26,1,
26,3,26,596,8,26,1,26,3,26,599,8,26,1,27,1,27,3,27,603,8,27,1,27,1,27,
1,28,1,28,1,28,1,28,3,28,611,8,28,1,29,1,29,1,29,1,30,3,30,617,8,30,1,
30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,
31,1,31,1,31,5,31,636,8,31,10,31,12,31,639,9,31,1,32,1,32,1,32,1,33,1,
33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,
34,1,34,1,34,3,34,662,8,34,1,35,1,35,1,35,5,35,667,8,35,10,35,12,35,670,
9,35,1,36,1,36,3,36,674,8,36,1,36,1,36,1,37,1,37,1,37,1,38,1,38,1,38,
1,39,1,39,1,39,1,39,3,39,688,8,39,1,40,1,40,1,40,1,40,1,40,5,40,695,8,
40,10,40,12,40,698,9,40,1,40,1,40,3,40,702,8,40,1,41,1,41,1,41,1,41,1,
42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,3,43,716,8,43,1,43,1,43,3,43,720,
8,43,1,43,1,43,3,43,724,8,43,1,43,1,43,1,43,3,43,729,8,43,1,43,1,43,3,
43,733,8,43,1,43,1,43,1,43,3,43,738,8,43,1,44,1,44,1,44,1,45,1,45,1,45,
1,46,1,46,1,46,1,46,5,46,750,8,46,10,46,12,46,753,9,46,1,47,1,47,1,47,
1,47,5,47,759,8,47,10,47,12,47,762,9,47,1,47,1,47,1,48,1,48,1,48,3,48,
769,8,48,1,48,3,48,772,8,48,1,48,1,48,1,48,1,48,3,48,778,8,48,1,48,1,
48,1,48,1,48,1,48,1,48,3,48,786,8,48,1,48,3,48,789,8,48,1,48,1,48,1,48,
3,48,794,8,48,1,48,1,48,1,48,1,48,1,48,3,48,801,8,48,1,48,1,48,1,48,1,
48,1,48,1,48,1,48,1,48,3,48,811,8,48,1,48,1,48,1,48,1,48,1,48,1,48,3,
48,819,8,48,1,48,1,48,1,48,1,48,5,48,825,8,48,10,48,12,48,828,9,48,1,
49,3,49,831,8,49,1,49,1,49,1,49,3,49,836,8,49,1,49,1,49,1,49,1,49,1,49,
3,49,843,8,49,1,49,3,49,846,8,49,1,49,1,49,3,49,850,8,49,1,49,1,49,3,
49,854,8,49,1,49,3,49,857,8,49,1,49,1,49,1,49,1,49,3,49,863,8,49,3,49,
865,8,49,1,49,3,49,868,8,49,1,49,1,49,3,49,872,8,49,1,49,1,49,3,49,876,
8,49,1,49,3,49,879,8,49,3,49,881,8,49,3,49,883,8,49,1,50,1,50,1,50,3,
50,888,8,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,3,51,899,8,51,
1,52,1,52,1,52,3,52,904,8,52,1,52,1,52,3,52,908,8,52,1,52,1,52,1,52,1,
52,3,52,914,8,52,1,53,1,53,1,53,3,53,919,8,53,1,54,1,54,1,54,5,54,924,
8,54,10,54,12,54,927,9,54,1,55,1,55,3,55,931,8,55,1,55,1,55,3,55,935,
8,55,1,55,1,55,3,55,939,8,55,1,55,3,55,942,8,55,1,56,1,56,1,56,1,56,3,
56,948,8,56,1,56,1,56,3,56,952,8,56,1,56,1,56,3,56,956,8,56,1,57,1,57,
1,57,3,57,961,8,57,1,58,1,58,1,58,1,58,3,58,967,8,58,3,58,969,8,58,1,
59,1,59,1,59,5,59,974,8,59,10,59,12,59,977,9,59,1,60,1,60,1,60,1,60,1,
61,3,61,984,8,61,1,61,3,61,987,8,61,1,61,3,61,990,8,61,1,62,1,62,1,62,
1,62,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,
1,66,1,66,1,66,1,66,1,66,1,66,3,66,1015,8,66,1,67,1,67,1,67,1,67,1,67,
1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1029,8,67,1,68,1,68,1,68,1,69,
1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,5,69,1043,8,69,10,69,12,69,1046,
9,69,1,69,3,69,1049,8,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,5,69,1058,
8,69,10,69,12,69,1061,9,69,1,69,3,69,1064,8,69,1,69,1,69,1,69,1,69,1,
69,1,69,1,69,5,69,1073,8,69,10,69,12,69,1076,9,69,1,69,3,69,1079,8,69,
1,69,1,69,1,69,1,69,1,69,3,69,1086,8,69,1,69,1,69,1,69,1,69,4,69,1092,
8,69,11,69,12,69,1093,1,69,3,69,1097,8,69,1,69,1,69,1,69,3,69,1102,8,
69,1,69,5,69,1105,8,69,10,69,12,69,1108,9,69,1,70,1,70,1,70,3,70,1113,
8,70,1,70,1,70,1,70,1,70,3,70,1119,8,70,1,71,1,71,1,71,1,71,3,71,1125,
8,71,1,72,1,72,1,73,1,73,1,73,5,73,1132,8,73,10,73,12,73,1135,9,73,1,
73,3,73,1138,8,73,1,74,1,74,1,74,5,74,1143,8,74,10,74,12,74,1146,9,74,
1,74,1,74,1,74,3,74,1151,8,74,1,75,1,75,1,75,5,75,1156,8,75,10,75,12,
75,1159,9,75,1,75,3,75,1162,8,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,
76,1,76,1,76,3,76,1174,8,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,
77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,3,77,1195,8,77,5,
77,1197,8,77,10,77,12,77,1200,9,77,1,78,1,78,1,78,3,78,1205,8,78,1,78,
1,78,1,78,1,78,1,78,4,78,1212,8,78,11,78,12,78,1213,1,78,1,78,3,78,1218,
8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,3,78,1251,8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1299,8,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1327,
8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1391,8,78,1,78,1,78,1,78,1,78,
1,78,1,78,3,78,1399,8,78,1,78,1,78,1,78,1,78,3,78,1405,8,78,1,78,3,78,
1408,8,78,1,78,3,78,1411,8,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1419,
8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1429,8,78,1,78,1,78,
1,78,1,78,3,78,1435,8,78,1,78,3,78,1438,8,78,1,78,3,78,1441,8,78,1,78,
1,78,1,78,1,78,1,78,1,78,3,78,1449,8,78,1,78,1,78,1,78,1,78,1,78,1,78,
3,78,1457,8,78,1,78,3,78,1460,8,78,1,78,1,78,3,78,1464,8,78,1,78,3,78,
1467,8,78,1,78,1,78,1,78,3,78,1472,8,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,3,78,1481,8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
3,78,1493,8,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1501,8,78,1,78,1,78,
1,78,1,78,5,78,1507,8,78,10,78,12,78,1510,9,78,1,78,3,78,1513,8,78,1,
78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,
78,1,78,3,78,1531,8,78,1,78,1,78,3,78,1535,8,78,1,78,1,78,1,78,3,78,1540,
8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1551,8,78,1,78,
1,78,1,78,1,78,3,78,1557,8,78,1,78,1,78,1,78,1,78,1,78,3,78,1564,8,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1576,8,78,1,78,
1,78,3,78,1580,8,78,1,78,3,78,1583,8,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,3,78,1592,8,78,1,78,1,78,1,78,1,78,3,78,1598,8,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1611,8,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1626,8,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1637,8,78,1,78,1,78,3,78,
1641,8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
1,78,1,78,3,78,1671,8,78,1,78,5,78,1674,8,78,10,78,12,78,1677,9,78,1,
79,1,79,1,79,1,79,5,79,1683,8,79,10,79,12,79,1686,9,79,1,79,3,79,1689,
8,79,1,79,1,79,1,79,1,79,1,79,5,79,1696,8,79,10,79,12,79,1699,9,79,1,
79,3,79,1702,8,79,1,79,1,79,3,79,1706,8,79,1,79,1,79,1,79,3,79,1711,8,
79,1,79,1,79,1,79,1,79,5,79,1717,8,79,10,79,12,79,1720,9,79,1,79,3,79,
1723,8,79,1,79,1,79,1,79,3,79,1728,8,79,1,80,1,80,1,80,5,80,1733,8,80,
10,80,12,80,1736,9,80,1,81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,
82,3,82,1748,8,82,1,83,1,83,1,84,1,84,1,84,5,84,1755,8,84,10,84,12,84,
1758,9,84,1,84,1,84,1,84,1,84,1,84,5,84,1765,8,84,10,84,12,84,1768,9,
84,1,84,1,84,5,84,1772,8,84,10,84,12,84,1775,9,84,1,84,1,84,1,84,1,84,
3,84,1781,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,
3,85,1794,8,85,1,86,1,86,1,86,5,86,1799,8,86,10,86,12,86,1802,9,86,1,
86,3,86,1805,8,86,1,87,1,87,3,87,1809,8,87,1,87,1,87,1,87,3,87,1814,8,
87,1,87,1,87,3,87,1818,8,87,1,87,3,87,1821,8,87,1,87,1,87,1,87,1,87,1,
87,1,87,1,87,1,87,3,87,1831,8,87,1,88,1,88,1,88,1,88,5,88,1837,8,88,10,
88,12,88,1840,9,88,1,88,1,88,1,89,1,89,1,89,1,89,3,89,1848,8,89,1,89,
3,89,1851,8,89,1,90,1,90,1,90,5,90,1856,8,90,10,90,12,90,1859,9,90,1,
91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1874,
8,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1884,8,91,1,91,1,91,
1,91,1,91,1,91,1,91,3,91,1892,8,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,
1,91,3,91,1902,8,91,1,91,3,91,1905,8,91,5,91,1907,8,91,10,91,12,91,1910,
9,91,1,92,1,92,4,92,1914,8,92,11,92,12,92,1915,1,93,1,93,1,93,1,93,1,
93,1,93,1,94,1,94,1,94,5,94,1927,8,94,10,94,12,94,1930,9,94,1,94,3,94,
1933,8,94,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,
1,95,5,95,1948,8,95,10,95,12,95,1951,9,95,1,96,1,96,1,96,1,96,1,96,3,
96,1958,8,96,1,97,1,97,1,97,1,97,5,97,1964,8,97,10,97,12,97,1967,9,97,
1,97,1,97,1,98,1,98,1,98,3,98,1974,8,98,1,98,1,98,1,99,1,99,1,99,3,99,
1981,8,99,1,99,1,99,1,100,1,100,1,100,5,100,1988,8,100,10,100,12,100,
1991,9,100,1,100,3,100,1994,8,100,1,101,1,101,1,102,1,102,1,102,1,102,
1,102,1,102,3,102,2004,8,102,3,102,2006,8,102,1,103,3,103,2009,8,103,
1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,3,103,2019,8,103,1,104,
1,104,1,104,3,104,2024,8,104,1,105,1,105,1,106,1,106,1,107,1,107,1,108,
1,108,1,109,1,109,1,109,3,109,2037,8,109,1,110,1,110,1,110,3,110,2042,
8,110,1,111,1,111,1,111,1,111,3,111,2048,8,111,1,112,1,112,1,112,1,112,
1,113,1,113,1,113,1,113,1,114,1,114,3,114,2060,8,114,1,115,1,115,5,115,
2064,8,115,10,115,12,115,2067,9,115,1,115,1,115,1,116,1,116,1,116,1,116,
1,116,3,116,2076,8,116,1,117,1,117,5,117,2080,8,117,10,117,12,117,2083,
9,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118,3,118,2092,8,118,1,118,
0,5,96,138,154,156,182,119,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,
32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,
78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,
118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,
154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,
190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,
226,228,230,232,234,236,0,20,2,0,36,36,41,41,2,0,19,19,94,94,2,0,53,53,
63,63,3,0,1,1,4,4,8,8,2,0,3,3,100,100,4,0,1,1,3,4,8,8,100,100,2,0,63,
63,93,93,2,0,76,76,151,151,2,0,7,7,23,24,2,0,35,35,61,61,2,0,89,89,96,
96,3,0,21,21,56,56,108,109,3,0,10,10,62,62,115,115,2,0,48,48,65,65,1,
0,138,139,2,0,153,153,176,176,7,0,22,22,45,45,68,69,88,88,98,98,125,125,
132,132,20,0,1,13,15,21,23,27,29,33,35,35,37,40,42,44,46,51,53,53,55,
63,65,66,70,71,73,73,75,87,89,97,99,105,107,117,119,124,126,127,129,130,
4,0,21,21,35,35,46,46,59,59,8,0,7,7,15,15,21,21,24,24,31,31,46,46,92,
92,113,114,2375,0,241,1,0,0,0,2,248,1,0,0,0,4,250,1,0,0,0,6,252,1,0,0,
0,8,258,1,0,0,0,10,280,1,0,0,0,12,282,1,0,0,0,14,289,1,0,0,0,16,294,1,
0,0,0,18,307,1,0,0,0,20,319,1,0,0,0,22,328,1,0,0,0,24,336,1,0,0,0,26,
358,1,0,0,0,28,373,1,0,0,0,30,382,1,0,0,0,32,386,1,0,0,0,34,394,1,0,0,
0,36,396,1,0,0,0,38,405,1,0,0,0,40,409,1,0,0,0,42,423,1,0,0,0,44,441,
1,0,0,0,46,488,1,0,0,0,48,492,1,0,0,0,50,532,1,0,0,0,52,535,1,0,0,0,54,
600,1,0,0,0,56,606,1,0,0,0,58,612,1,0,0,0,60,616,1,0,0,0,62,622,1,0,0,
0,64,640,1,0,0,0,66,643,1,0,0,0,68,646,1,0,0,0,70,663,1,0,0,0,72,671,
1,0,0,0,74,677,1,0,0,0,76,680,1,0,0,0,78,683,1,0,0,0,80,689,1,0,0,0,82,
703,1,0,0,0,84,707,1,0,0,0,86,737,1,0,0,0,88,739,1,0,0,0,90,742,1,0,0,
0,92,745,1,0,0,0,94,754,1,0,0,0,96,777,1,0,0,0,98,882,1,0,0,0,100,887,
1,0,0,0,102,898,1,0,0,0,104,900,1,0,0,0,106,915,1,0,0,0,108,920,1,0,0,
0,110,928,1,0,0,0,112,943,1,0,0,0,114,957,1,0,0,0,116,968,1,0,0,0,118,
970,1,0,0,0,120,978,1,0,0,0,122,983,1,0,0,0,124,991,1,0,0,0,126,995,1,
0,0,0,128,999,1,0,0,0,130,1005,1,0,0,0,132,1014,1,0,0,0,134,1028,1,0,
0,0,136,1030,1,0,0,0,138,1096,1,0,0,0,140,1118,1,0,0,0,142,1124,1,0,0,
0,144,1126,1,0,0,0,146,1128,1,0,0,0,148,1150,1,0,0,0,150,1152,1,0,0,0,
152,1173,1,0,0,0,154,1175,1,0,0,0,156,1550,1,0,0,0,158,1727,1,0,0,0,160,
1729,1,0,0,0,162,1737,1,0,0,0,164,1747,1,0,0,0,166,1749,1,0,0,0,168,1780,
1,0,0,0,170,1793,1,0,0,0,172,1795,1,0,0,0,174,1830,1,0,0,0,176,1832,1,
0,0,0,178,1850,1,0,0,0,180,1852,1,0,0,0,182,1873,1,0,0,0,184,1911,1,0,
0,0,186,1917,1,0,0,0,188,1923,1,0,0,0,190,1934,1,0,0,0,192,1957,1,0,0,
0,194,1959,1,0,0,0,196,1970,1,0,0,0,198,1980,1,0,0,0,200,1984,1,0,0,0,
202,1995,1,0,0,0,204,2005,1,0,0,0,206,2008,1,0,0,0,208,2023,1,0,0,0,210,
2025,1,0,0,0,212,2027,1,0,0,0,214,2029,1,0,0,0,216,2031,1,0,0,0,218,2036,
1,0,0,0,220,2041,1,0,0,0,222,2047,1,0,0,0,224,2049,1,0,0,0,226,2053,1,
0,0,0,228,2059,1,0,0,0,230,2061,1,0,0,0,232,2075,1,0,0,0,234,2077,1,0,
0,0,236,2091,1,0,0,0,238,240,3,2,1,0,239,238,1,0,0,0,240,243,1,0,0,0,
241,239,1,0,0,0,241,242,1,0,0,0,242,244,1,0,0,0,243,241,1,0,0,0,244,245,
5,0,0,1,245,1,1,0,0,0,246,249,3,6,3,0,247,249,3,10,5,0,248,246,1,0,0,
0,248,247,1,0,0,0,249,3,1,0,0,0,250,251,3,154,77,0,251,5,1,0,0,0,252,
253,5,64,0,0,253,256,3,222,111,0,254,255,5,149,0,0,255,257,3,4,2,0,256,
254,1,0,0,0,256,257,1,0,0,0,257,7,1,0,0,0,258,263,3,180,90,0,259,260,
5,151,0,0,260,262,3,180,90,0,261,259,1,0,0,0,262,265,1,0,0,0,263,261,
1,0,0,0,263,264,1,0,0,0,264,267,1,0,0,0,265,263,1,0,0,0,266,268,5,151,
0,0,267,266,1,0,0,0,267,268,1,0,0,0,268,9,1,0,0,0,269,281,3,12,6,0,270,
281,3,14,7,0,271,281,3,18,9,0,272,281,3,20,10,0,273,281,3,22,11,0,274,
281,3,26,13,0,275,281,3,24,12,0,276,281,3,28,14,0,277,281,3,36,18,0,278,
281,3,32,16,0,279,281,3,34,17,0,280,269,1,0,0,0,280,270,1,0,0,0,280,271,
1,0,0,0,280,272,1,0,0,0,280,273,1,0,0,0,280,274,1,0,0,0,280,275,1,0,0,
0,280,276,1,0,0,0,280,277,1,0,0,0,280,278,1,0,0,0,280,279,1,0,0,0,281,
11,1,0,0,0,282,284,5,92,0,0,283,285,3,4,2,0,284,283,1,0,0,0,284,285,1,
0,0,0,285,287,1,0,0,0,286,288,5,187,0,0,287,286,1,0,0,0,287,288,1,0,0,
0,288,13,1,0,0,0,289,290,5,106,0,0,290,292,3,4,2,0,291,293,5,187,0,0,
292,291,1,0,0,0,292,293,1,0,0,0,293,15,1,0,0,0,294,303,5,14,0,0,295,296,
5,165,0,0,296,299,3,222,111,0,297,298,5,150,0,0,298,300,3,222,111,0,299,
297,1,0,0,0,299,300,1,0,0,0,300,301,1,0,0,0,301,302,5,186,0,0,302,304,
1,0,0,0,303,295,1,0,0,0,303,304,1,0,0,0,304,305,1,0,0,0,305,306,3,36,
18,0,306,17,1,0,0,0,307,308,5,118,0,0,308,312,3,36,18,0,309,311,3,16,
8,0,310,309,1,0,0,0,311,314,1,0,0,0,312,310,1,0,0,0,312,313,1,0,0,0,313,
317,1,0,0,0,314,312,1,0,0,0,315,316,5,34,0,0,316,318,3,36,18,0,317,315,
1,0,0,0,317,318,1,0,0,0,318,19,1,0,0,0,319,320,5,47,0,0,320,321,5,165,
0,0,321,322,3,4,2,0,322,323,5,186,0,0,323,326,3,10,5,0,324,325,5,26,0,
0,325,327,3,10,5,0,326,324,1,0,0,0,326,327,1,0,0,0,327,21,1,0,0,0,328,
329,5,128,0,0,329,330,5,165,0,0,330,331,3,4,2,0,331,332,5,186,0,0,332,
334,3,10,5,0,333,335,5,187,0,0,334,333,1,0,0,0,334,335,1,0,0,0,335,23,
1,0,0,0,336,337,5,38,0,0,337,341,5,165,0,0,338,342,3,6,3,0,339,342,3,
30,15,0,340,342,3,4,2,0,341,338,1,0,0,0,341,339,1,0,0,0,341,340,1,0,0,
0,341,342,1,0,0,0,342,343,1,0,0,0,343,345,5,187,0,0,344,346,3,4,2,0,345,
344,1,0,0,0,345,346,1,0,0,0,346,347,1,0,0,0,347,351,5,187,0,0,348,352,
3,6,3,0,349,352,3,30,15,0,350,352,3,4,2,0,351,348,1,0,0,0,351,349,1,0,
0,0,351,350,1,0,0,0,351,352,1,0,0,0,352,353,1,0,0,0,353,354,5,186,0,0,
354,356,3,10,5,0,355,357,5,187,0,0,356,355,1,0,0,0,356,357,1,0,0,0,357,
25,1,0,0,0,358,359,5,38,0,0,359,360,5,165,0,0,360,361,5,64,0,0,361,364,
3,222,111,0,362,363,5,151,0,0,363,365,3,222,111,0,364,362,1,0,0,0,364,
365,1,0,0,0,365,366,1,0,0,0,366,367,5,51,0,0,367,368,3,4,2,0,368,369,
5,186,0,0,369,371,3,10,5,0,370,372,5,187,0,0,371,370,1,0,0,0,371,372,
1,0,0,0,372,27,1,0,0,0,373,374,7,0,0,0,374,375,3,222,111,0,375,377,5,
165,0,0,376,378,3,8,4,0,377,376,1,0,0,0,377,378,1,0,0,0,378,379,1,0,0,
0,379,380,5,186,0,0,380,381,3,36,18,0,381,29,1,0,0,0,382,383,3,4,2,0,
383,384,5,149,0,0,384,385,3,4,2,0,385,31,1,0,0,0,386,389,3,4,2,0,387,
388,5,149,0,0,388,390,3,4,2,0,389,387,1,0,0,0,389,390,1,0,0,0,390,392,
1,0,0,0,391,393,5,187,0,0,392,391,1,0,0,0,392,393,1,0,0,0,393,33,1,0,
0,0,394,395,5,187,0,0,395,35,1,0,0,0,396,400,5,163,0,0,397,399,3,2,1,
0,398,397,1,0,0,0,399,402,1,0,0,0,400,398,1,0,0,0,400,401,1,0,0,0,401,
403,1,0,0,0,402,400,1,0,0,0,403,404,5,184,0,0,404,37,1,0,0,0,405,406,
3,4,2,0,406,407,5,150,0,0,407,408,3,4,2,0,408,39,1,0,0,0,409,414,3,38,
19,0,410,411,5,151,0,0,411,413,3,38,19,0,412,410,1,0,0,0,413,416,1,0,
0,0,414,412,1,0,0,0,414,415,1,0,0,0,415,418,1,0,0,0,416,414,1,0,0,0,417,
419,5,151,0,0,418,417,1,0,0,0,418,419,1,0,0,0,419,41,1,0,0,0,420,424,
3,48,24,0,421,424,3,52,26,0,422,424,3,168,84,0,423,420,1,0,0,0,423,421,
1,0,0,0,423,422,1,0,0,0,424,426,1,0,0,0,425,427,5,187,0,0,426,425,1,0,
0,0,426,427,1,0,0,0,427,428,1,0,0,0,428,429,5,0,0,1,429,43,1,0,0,0,430,
442,3,52,26,0,431,432,3,54,27,0,432,433,5,165,0,0,433,434,3,48,24,0,434,
435,5,186,0,0,435,442,1,0,0,0,436,437,5,165,0,0,437,438,3,48,24,0,438,
439,5,186,0,0,439,442,1,0,0,0,440,442,3,226,113,0,441,430,1,0,0,0,441,
431,1,0,0,0,441,436,1,0,0,0,441,440,1,0,0,0,442,45,1,0,0,0,443,444,5,
28,0,0,444,447,5,1,0,0,445,446,5,11,0,0,446,448,5,70,0,0,447,445,1,0,
0,0,447,448,1,0,0,0,448,489,1,0,0,0,449,452,5,28,0,0,450,451,5,11,0,0,
451,453,5,70,0,0,452,450,1,0,0,0,452,453,1,0,0,0,453,489,1,0,0,0,454,
455,5,121,0,0,455,458,5,1,0,0,456,457,5,11,0,0,457,459,5,70,0,0,458,456,
1,0,0,0,458,459,1,0,0,0,459,489,1,0,0,0,460,461,5,121,0,0,461,464,5,25,
0,0,462,463,5,11,0,0,463,465,5,70,0,0,464,462,1,0,0,0,464,465,1,0,0,0,
465,489,1,0,0,0,466,469,5,121,0,0,467,468,5,11,0,0,468,470,5,70,0,0,469,
467,1,0,0,0,469,470,1,0,0,0,470,489,1,0,0,0,471,472,5,54,0,0,472,475,
5,1,0,0,473,474,5,11,0,0,474,476,5,70,0,0,475,473,1,0,0,0,475,476,1,0,
0,0,476,489,1,0,0,0,477,478,5,54,0,0,478,481,5,25,0,0,479,480,5,11,0,
0,480,482,5,70,0,0,481,479,1,0,0,0,481,482,1,0,0,0,482,489,1,0,0,0,483,
486,5,54,0,0,484,485,5,11,0,0,485,487,5,70,0,0,486,484,1,0,0,0,486,487,
1,0,0,0,487,489,1,0,0,0,488,443,1,0,0,0,488,449,1,0,0,0,488,454,1,0,0,
0,488,460,1,0,0,0,488,466,1,0,0,0,488,471,1,0,0,0,488,477,1,0,0,0,488,
483,1,0,0,0,489,490,1,0,0,0,490,491,3,44,22,0,491,47,1,0,0,0,492,496,
3,44,22,0,493,495,3,46,23,0,494,493,1,0,0,0,495,498,1,0,0,0,496,494,1,
0,0,0,496,497,1,0,0,0,497,500,1,0,0,0,498,496,1,0,0,0,499,501,3,78,39,
0,500,499,1,0,0,0,500,501,1,0,0,0,501,503,1,0,0,0,502,504,3,50,25,0,503,
502,1,0,0,0,503,504,1,0,0,0,504,49,1,0,0,0,505,506,5,66,0,0,506,508,3,
154,77,0,507,509,5,175,0,0,508,507,1,0,0,0,508,509,1,0,0,0,509,512,1,
0,0,0,510,511,5,151,0,0,511,513,3,154,77,0,512,510,1,0,0,0,512,513,1,
0,0,0,513,516,1,0,0,0,514,515,5,130,0,0,515,517,5,107,0,0,516,514,1,0,
0,0,516,517,1,0,0,0,517,533,1,0,0,0,518,519,5,66,0,0,519,521,3,154,77,
0,520,522,5,175,0,0,521,520,1,0,0,0,521,522,1,0,0,0,522,525,1,0,0,0,523,
524,5,130,0,0,524,526,5,107,0,0,525,523,1,0,0,0,525,526,1,0,0,0,526,527,
1,0,0,0,527,528,5,76,0,0,528,529,3,154,77,0,529,533,1,0,0,0,530,531,5,
76,0,0,531,533,3,154,77,0,532,505,1,0,0,0,532,518,1,0,0,0,532,530,1,0,
0,0,533,51,1,0,0,0,534,536,3,54,27,0,535,534,1,0,0,0,535,536,1,0,0,0,
536,537,1,0,0,0,537,539,5,99,0,0,538,540,5,25,0,0,539,538,1,0,0,0,539,
540,1,0,0,0,540,542,1,0,0,0,541,543,3,56,28,0,542,541,1,0,0,0,542,543,
1,0,0,0,543,544,1,0,0,0,544,546,3,148,74,0,545,547,3,58,29,0,546,545,
1,0,0,0,546,547,1,0,0,0,547,549,1,0,0,0,548,550,3,60,30,0,549,548,1,0,
0,0,549,550,1,0,0,0,550,552,1,0,0,0,551,553,3,64,32,0,552,551,1,0,0,0,
552,553,1,0,0,0,553,555,1,0,0,0,554,556,3,66,33,0,555,554,1,0,0,0,555,
556,1,0,0,0,556,561,1,0,0,0,557,559,5,123,0,0,558,557,1,0,0,0,558,559,
1,0,0,0,559,560,1,0,0,0,560,562,3,104,52,0,561,558,1,0,0,0,561,562,1,
0,0,0,562,564,1,0,0,0,563,565,3,68,34,0,564,563,1,0,0,0,564,565,1,0,0,
0,565,568,1,0,0,0,566,567,5,130,0,0,567,569,7,1,0,0,568,566,1,0,0,0,568,
569,1,0,0,0,569,572,1,0,0,0,570,571,5,130,0,0,571,573,5,114,0,0,572,570,
1,0,0,0,572,573,1,0,0,0,573,575,1,0,0,0,574,576,3,74,37,0,575,574,1,0,
0,0,575,576,1,0,0,0,576,578,1,0,0,0,577,579,3,76,38,0,578,577,1,0,0,0,
578,579,1,0,0,0,579,582,1,0,0,0,580,581,5,123,0,0,581,583,3,104,52,0,
582,580,1,0,0,0,582,583,1,0,0,0,583,585,1,0,0,0,584,586,3,62,31,0,585,
584,1,0,0,0,585,586,1,0,0,0,586,588,1,0,0,0,587,589,3,78,39,0,588,587,
1,0,0,0,588,589,1,0,0,0,589,591,1,0,0,0,590,592,3,84,42,0,591,590,1,0,
0,0,591,592,1,0,0,0,592,595,1,0,0,0,593,596,3,86,43,0,594,596,3,88,44,
0,595,593,1,0,0,0,595,594,1,0,0,0,595,596,1,0,0,0,596,598,1,0,0,0,597,
599,3,90,45,0,598,597,1,0,0,0,598,599,1,0,0,0,599,53,1,0,0,0,600,602,
5,130,0,0,601,603,5,90,0,0,602,601,1,0,0,0,602,603,1,0,0,0,603,604,1,
0,0,0,604,605,3,172,86,0,605,55,1,0,0,0,606,607,5,113,0,0,607,610,5,139,
0,0,608,609,5,130,0,0,609,611,5,107,0,0,610,608,1,0,0,0,610,611,1,0,0,
0,611,57,1,0,0,0,612,613,5,39,0,0,613,614,3,96,48,0,614,59,1,0,0,0,615,
617,7,2,0,0,616,615,1,0,0,0,616,617,1,0,0,0,617,618,1,0,0,0,618,619,5,
5,0,0,619,620,5,58,0,0,620,621,3,146,73,0,621,61,1,0,0,0,622,623,5,129,
0,0,623,624,3,222,111,0,624,625,5,6,0,0,625,626,5,165,0,0,626,627,3,122,
61,0,627,637,5,186,0,0,628,629,5,151,0,0,629,630,3,222,111,0,630,631,
5,6,0,0,631,632,5,165,0,0,632,633,3,122,61,0,633,634,5,186,0,0,634,636,
1,0,0,0,635,628,1,0,0,0,636,639,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,
0,638,63,1,0,0,0,639,637,1,0,0,0,640,641,5,86,0,0,641,642,3,154,77,0,
642,65,1,0,0,0,643,644,5,127,0,0,644,645,3,154,77,0,645,67,1,0,0,0,646,
647,5,42,0,0,647,661,5,11,0,0,648,662,5,1,0,0,649,650,7,1,0,0,650,651,
5,165,0,0,651,652,3,146,73,0,652,653,5,186,0,0,653,662,1,0,0,0,654,655,
5,43,0,0,655,656,5,101,0,0,656,657,5,165,0,0,657,658,3,70,35,0,658,659,
5,186,0,0,659,662,1,0,0,0,660,662,3,146,73,0,661,648,1,0,0,0,661,649,
1,0,0,0,661,654,1,0,0,0,661,660,1,0,0,0,662,69,1,0,0,0,663,668,3,72,36,
0,664,665,5,151,0,0,665,667,3,72,36,0,666,664,1,0,0,0,667,670,1,0,0,0,
668,666,1,0,0,0,668,669,1,0,0,0,669,71,1,0,0,0,670,668,1,0,0,0,671,673,
5,165,0,0,672,674,3,146,73,0,673,672,1,0,0,0,673,674,1,0,0,0,674,675,
1,0,0,0,675,676,5,186,0,0,676,73,1,0,0,0,677,678,5,44,0,0,678,679,3,154,
77,0,679,75,1,0,0,0,680,681,5,87,0,0,681,682,3,154,77,0,682,77,1,0,0,
0,683,684,5,79,0,0,684,685,5,11,0,0,685,687,3,108,54,0,686,688,3,80,40,
0,687,686,1,0,0,0,687,688,1,0,0,0,688,79,1,0,0,0,689,701,5,55,0,0,690,
691,5,165,0,0,691,696,3,114,57,0,692,693,5,151,0,0,693,695,3,114,57,0,
694,692,1,0,0,0,695,698,1,0,0,0,696,694,1,0,0,0,696,697,1,0,0,0,697,699,
1,0,0,0,698,696,1,0,0,0,699,700,5,186,0,0,700,702,1,0,0,0,701,690,1,0,
0,0,701,702,1,0,0,0,702,81,1,0,0,0,703,704,5,79,0,0,704,705,5,11,0,0,
705,706,3,146,73,0,706,83,1,0,0,0,707,708,5,66,0,0,708,709,3,106,53,0,
709,710,5,11,0,0,710,711,3,146,73,0,711,85,1,0,0,0,712,713,5,66,0,0,713,
715,3,154,77,0,714,716,5,175,0,0,715,714,1,0,0,0,715,716,1,0,0,0,716,
719,1,0,0,0,717,718,5,151,0,0,718,720,3,154,77,0,719,717,1,0,0,0,719,
720,1,0,0,0,720,723,1,0,0,0,721,722,5,130,0,0,722,724,5,107,0,0,723,721,
1,0,0,0,723,724,1,0,0,0,724,738,1,0,0,0,725,726,5,66,0,0,726,728,3,154,
77,0,727,729,5,175,0,0,728,727,1,0,0,0,728,729,1,0,0,0,729,732,1,0,0,
0,730,731,5,130,0,0,731,733,5,107,0,0,732,730,1,0,0,0,732,733,1,0,0,0,
733,734,1,0,0,0,734,735,5,76,0,0,735,736,3,154,77,0,736,738,1,0,0,0,737,
712,1,0,0,0,737,725,1,0,0,0,738,87,1,0,0,0,739,740,5,76,0,0,740,741,3,
154,77,0,741,89,1,0,0,0,742,743,5,102,0,0,743,744,3,118,59,0,744,91,1,
0,0,0,745,746,5,124,0,0,746,751,3,94,47,0,747,748,5,151,0,0,748,750,3,
94,47,0,749,747,1,0,0,0,750,753,1,0,0,0,751,749,1,0,0,0,751,752,1,0,0,
0,752,93,1,0,0,0,753,751,1,0,0,0,754,755,5,165,0,0,755,760,3,154,77,0,
756,757,5,151,0,0,757,759,3,154,77,0,758,756,1,0,0,0,759,762,1,0,0,0,
760,758,1,0,0,0,760,761,1,0,0,0,761,763,1,0,0,0,762,760,1,0,0,0,763,764,
5,186,0,0,764,95,1,0,0,0,765,766,6,48,-1,0,766,768,3,182,91,0,767,769,
5,31,0,0,768,767,1,0,0,0,768,769,1,0,0,0,769,771,1,0,0,0,770,772,3,104,
52,0,771,770,1,0,0,0,771,772,1,0,0,0,772,778,1,0,0,0,773,774,5,165,0,
0,774,775,3,96,48,0,775,776,5,186,0,0,776,778,1,0,0,0,777,765,1,0,0,0,
777,773,1,0,0,0,778,826,1,0,0,0,779,780,10,5,0,0,780,781,3,100,50,0,781,
782,3,96,48,6,782,825,1,0,0,0,783,785,10,7,0,0,784,786,5,71,0,0,785,784,
1,0,0,0,785,786,1,0,0,0,786,788,1,0,0,0,787,789,3,98,49,0,788,787,1,0,
0,0,788,789,1,0,0,0,789,790,1,0,0,0,790,791,5,58,0,0,791,793,3,96,48,
0,792,794,3,102,51,0,793,792,1,0,0,0,793,794,1,0,0,0,794,825,1,0,0,0,
795,796,10,6,0,0,796,797,5,84,0,0,797,798,5,58,0,0,798,800,3,96,48,0,
799,801,3,102,51,0,800,799,1,0,0,0,800,801,1,0,0,0,801,825,1,0,0,0,802,
803,10,4,0,0,803,804,5,83,0,0,804,805,5,165,0,0,805,806,3,146,73,0,806,
810,3,184,92,0,807,808,5,42,0,0,808,809,5,11,0,0,809,811,3,146,73,0,810,
807,1,0,0,0,810,811,1,0,0,0,811,812,1,0,0,0,812,813,5,186,0,0,813,825,
1,0,0,0,814,815,10,3,0,0,815,818,5,122,0,0,816,817,5,50,0,0,817,819,5,
75,0,0,818,816,1,0,0,0,818,819,1,0,0,0,819,820,1,0,0,0,820,821,5,165,
0,0,821,822,3,188,94,0,822,823,5,186,0,0,823,825,1,0,0,0,824,779,1,0,
0,0,824,783,1,0,0,0,824,795,1,0,0,0,824,802,1,0,0,0,824,814,1,0,0,0,825,
828,1,0,0,0,826,824,1,0,0,0,826,827,1,0,0,0,827,97,1,0,0,0,828,826,1,
0,0,0,829,831,7,3,0,0,830,829,1,0,0,0,830,831,1,0,0,0,831,832,1,0,0,0,
832,843,5,53,0,0,833,835,5,53,0,0,834,836,7,3,0,0,835,834,1,0,0,0,835,
836,1,0,0,0,836,843,1,0,0,0,837,843,7,3,0,0,838,843,5,3,0,0,839,843,5,
100,0,0,840,841,5,8,0,0,841,843,7,4,0,0,842,830,1,0,0,0,842,833,1,0,0,
0,842,837,1,0,0,0,842,838,1,0,0,0,842,839,1,0,0,0,842,840,1,0,0,0,843,
883,1,0,0,0,844,846,7,5,0,0,845,844,1,0,0,0,845,846,1,0,0,0,846,847,1,
0,0,0,847,849,7,6,0,0,848,850,5,80,0,0,849,848,1,0,0,0,849,850,1,0,0,
0,850,865,1,0,0,0,851,853,7,6,0,0,852,854,5,80,0,0,853,852,1,0,0,0,853,
854,1,0,0,0,854,856,1,0,0,0,855,857,7,5,0,0,856,855,1,0,0,0,856,857,1,
0,0,0,857,865,1,0,0,0,858,859,5,8,0,0,859,860,7,4,0,0,860,862,7,6,0,0,
861,863,5,80,0,0,862,861,1,0,0,0,862,863,1,0,0,0,863,865,1,0,0,0,864,
845,1,0,0,0,864,851,1,0,0,0,864,858,1,0,0,0,865,883,1,0,0,0,866,868,7,
3,0,0,867,866,1,0,0,0,867,868,1,0,0,0,868,869,1,0,0,0,869,871,5,40,0,
0,870,872,5,80,0,0,871,870,1,0,0,0,871,872,1,0,0,0,872,881,1,0,0,0,873,
875,5,40,0,0,874,876,5,80,0,0,875,874,1,0,0,0,875,876,1,0,0,0,876,878,
1,0,0,0,877,879,7,3,0,0,878,877,1,0,0,0,878,879,1,0,0,0,879,881,1,0,0,
0,880,867,1,0,0,0,880,873,1,0,0,0,881,883,1,0,0,0,882,842,1,0,0,0,882,
864,1,0,0,0,882,880,1,0,0,0,883,99,1,0,0,0,884,885,5,18,0,0,885,888,5,
58,0,0,886,888,5,151,0,0,887,884,1,0,0,0,887,886,1,0,0,0,888,101,1,0,
0,0,889,890,5,77,0,0,890,899,3,146,73,0,891,892,5,123,0,0,892,893,5,165,
0,0,893,894,3,146,73,0,894,895,5,186,0,0,895,899,1,0,0,0,896,897,5,123,
0,0,897,899,3,146,73,0,898,889,1,0,0,0,898,891,1,0,0,0,898,896,1,0,0,
0,899,103,1,0,0,0,900,901,5,97,0,0,901,903,3,116,58,0,902,904,5,175,0,
0,903,902,1,0,0,0,903,904,1,0,0,0,904,907,1,0,0,0,905,906,5,76,0,0,906,
908,3,116,58,0,907,905,1,0,0,0,907,908,1,0,0,0,908,913,1,0,0,0,909,910,
5,165,0,0,910,911,3,222,111,0,911,912,5,186,0,0,912,914,1,0,0,0,913,909,
1,0,0,0,913,914,1,0,0,0,914,105,1,0,0,0,915,918,3,154,77,0,916,917,7,
7,0,0,917,919,3,154,77,0,918,916,1,0,0,0,918,919,1,0,0,0,919,107,1,0,
0,0,920,925,3,110,55,0,921,922,5,151,0,0,922,924,3,110,55,0,923,921,1,
0,0,0,924,927,1,0,0,0,925,923,1,0,0,0,925,926,1,0,0,0,926,109,1,0,0,0,
927,925,1,0,0,0,928,930,3,154,77,0,929,931,7,8,0,0,930,929,1,0,0,0,930,
931,1,0,0,0,931,934,1,0,0,0,932,933,5,75,0,0,933,935,7,9,0,0,934,932,
1,0,0,0,934,935,1,0,0,0,935,938,1,0,0,0,936,937,5,16,0,0,937,939,5,143,
0,0,938,936,1,0,0,0,938,939,1,0,0,0,939,941,1,0,0,0,940,942,3,112,56,
0,941,940,1,0,0,0,941,942,1,0,0,0,942,111,1,0,0,0,943,944,5,130,0,0,944,
947,5,32,0,0,945,946,5,39,0,0,946,948,3,154,77,0,947,945,1,0,0,0,947,
948,1,0,0,0,948,951,1,0,0,0,949,950,5,112,0,0,950,952,3,154,77,0,951,
949,1,0,0,0,951,952,1,0,0,0,952,955,1,0,0,0,953,954,5,103,0,0,954,956,
3,154,77,0,955,953,1,0,0,0,955,956,1,0,0,0,956,113,1,0,0,0,957,960,3,
154,77,0,958,959,5,6,0,0,959,961,3,154,77,0,960,958,1,0,0,0,960,961,1,
0,0,0,961,115,1,0,0,0,962,969,3,226,113,0,963,966,3,206,103,0,964,965,
5,188,0,0,965,967,3,206,103,0,966,964,1,0,0,0,966,967,1,0,0,0,967,969,
1,0,0,0,968,962,1,0,0,0,968,963,1,0,0,0,969,117,1,0,0,0,970,975,3,120,
60,0,971,972,5,151,0,0,972,974,3,120,60,0,973,971,1,0,0,0,974,977,1,0,
0,0,975,973,1,0,0,0,975,976,1,0,0,0,976,119,1,0,0,0,977,975,1,0,0,0,978,
979,3,222,111,0,979,980,5,157,0,0,980,981,3,208,104,0,981,121,1,0,0,0,
982,984,3,124,62,0,983,982,1,0,0,0,983,984,1,0,0,0,984,986,1,0,0,0,985,
987,3,126,63,0,986,985,1,0,0,0,986,987,1,0,0,0,987,989,1,0,0,0,988,990,
3,130,65,0,989,988,1,0,0,0,989,990,1,0,0,0,990,123,1,0,0,0,991,992,5,
82,0,0,992,993,5,11,0,0,993,994,3,146,73,0,994,125,1,0,0,0,995,996,5,
79,0,0,996,997,5,11,0,0,997,998,3,108,54,0,998,127,1,0,0,0,999,1000,5,
131,0,0,1000,1001,5,42,0,0,1001,1002,5,165,0,0,1002,1003,3,78,39,0,1003,
1004,5,186,0,0,1004,129,1,0,0,0,1005,1006,7,10,0,0,1006,1007,3,132,66,
0,1007,131,1,0,0,0,1008,1015,3,134,67,0,1009,1010,5,9,0,0,1010,1011,3,
134,67,0,1011,1012,5,2,0,0,1012,1013,3,134,67,0,1013,1015,1,0,0,0,1014,
1008,1,0,0,0,1014,1009,1,0,0,0,1015,133,1,0,0,0,1016,1017,5,20,0,0,1017,
1029,5,95,0,0,1018,1019,5,120,0,0,1019,1029,5,85,0,0,1020,1021,5,120,
0,0,1021,1029,5,37,0,0,1022,1023,3,154,77,0,1023,1024,5,85,0,0,1024,1029,
1,0,0,0,1025,1026,3,154,77,0,1026,1027,5,37,0,0,1027,1029,1,0,0,0,1028,
1016,1,0,0,0,1028,1018,1,0,0,0,1028,1020,1,0,0,0,1028,1022,1,0,0,0,1028,
1025,1,0,0,0,1029,135,1,0,0,0,1030,1031,3,154,77,0,1031,1032,5,0,0,1,
1032,137,1,0,0,0,1033,1034,6,69,-1,0,1034,1035,3,222,111,0,1035,1036,
5,165,0,0,1036,1037,3,222,111,0,1037,1044,3,138,69,0,1038,1039,5,151,
0,0,1039,1040,3,222,111,0,1040,1041,3,138,69,0,1041,1043,1,0,0,0,1042,
1038,1,0,0,0,1043,1046,1,0,0,0,1044,1042,1,0,0,0,1044,1045,1,0,0,0,1045,
1048,1,0,0,0,1046,1044,1,0,0,0,1047,1049,5,151,0,0,1048,1047,1,0,0,0,
1048,1049,1,0,0,0,1049,1050,1,0,0,0,1050,1051,5,186,0,0,1051,1097,1,0,
0,0,1052,1053,3,222,111,0,1053,1054,5,165,0,0,1054,1059,3,224,112,0,1055,
1056,5,151,0,0,1056,1058,3,224,112,0,1057,1055,1,0,0,0,1058,1061,1,0,
0,0,1059,1057,1,0,0,0,1059,1060,1,0,0,0,1060,1063,1,0,0,0,1061,1059,1,
0,0,0,1062,1064,5,151,0,0,1063,1062,1,0,0,0,1063,1064,1,0,0,0,1064,1065,
1,0,0,0,1065,1066,5,186,0,0,1066,1097,1,0,0,0,1067,1068,3,222,111,0,1068,
1069,5,165,0,0,1069,1074,3,138,69,0,1070,1071,5,151,0,0,1071,1073,3,138,
69,0,1072,1070,1,0,0,0,1073,1076,1,0,0,0,1074,1072,1,0,0,0,1074,1075,
1,0,0,0,1075,1078,1,0,0,0,1076,1074,1,0,0,0,1077,1079,5,151,0,0,1078,
1077,1,0,0,0,1078,1079,1,0,0,0,1079,1080,1,0,0,0,1080,1081,5,186,0,0,
1081,1097,1,0,0,0,1082,1083,3,222,111,0,1083,1085,5,165,0,0,1084,1086,
3,146,73,0,1085,1084,1,0,0,0,1085,1086,1,0,0,0,1086,1087,1,0,0,0,1087,
1088,5,186,0,0,1088,1097,1,0,0,0,1089,1091,3,222,111,0,1090,1092,3,222,
111,0,1091,1090,1,0,0,0,1092,1093,1,0,0,0,1093,1091,1,0,0,0,1093,1094,
1,0,0,0,1094,1097,1,0,0,0,1095,1097,3,222,111,0,1096,1033,1,0,0,0,1096,
1052,1,0,0,0,1096,1067,1,0,0,0,1096,1082,1,0,0,0,1096,1089,1,0,0,0,1096,
1095,1,0,0,0,1097,1106,1,0,0,0,1098,1099,10,7,0,0,1099,1101,5,164,0,0,
1100,1102,5,139,0,0,1101,1100,1,0,0,0,1101,1102,1,0,0,0,1102,1103,1,0,
0,0,1103,1105,5,185,0,0,1104,1098,1,0,0,0,1105,1108,1,0,0,0,1106,1104,
1,0,0,0,1106,1107,1,0,0,0,1107,139,1,0,0,0,1108,1106,1,0,0,0,1109,1110,
3,142,71,0,1110,1112,5,130,0,0,1111,1113,5,110,0,0,1112,1111,1,0,0,0,
1112,1113,1,0,0,0,1113,1114,1,0,0,0,1114,1115,5,109,0,0,1115,1116,5,111,
0,0,1116,1119,1,0,0,0,1117,1119,3,142,71,0,1118,1109,1,0,0,0,1118,1117,
1,0,0,0,1119,141,1,0,0,0,1120,1125,5,134,0,0,1121,1125,5,135,0,0,1122,
1125,3,210,105,0,1123,1125,3,144,72,0,1124,1120,1,0,0,0,1124,1121,1,0,
0,0,1124,1122,1,0,0,0,1124,1123,1,0,0,0,1125,143,1,0,0,0,1126,1127,7,
11,0,0,1127,145,1,0,0,0,1128,1133,3,154,77,0,1129,1130,5,151,0,0,1130,
1132,3,154,77,0,1131,1129,1,0,0,0,1132,1135,1,0,0,0,1133,1131,1,0,0,0,
1133,1134,1,0,0,0,1134,1137,1,0,0,0,1135,1133,1,0,0,0,1136,1138,5,151,
0,0,1137,1136,1,0,0,0,1137,1138,1,0,0,0,1138,147,1,0,0,0,1139,1144,3,
152,76,0,1140,1141,5,151,0,0,1141,1143,3,152,76,0,1142,1140,1,0,0,0,1143,
1146,1,0,0,0,1144,1142,1,0,0,0,1144,1145,1,0,0,0,1145,1147,1,0,0,0,1146,
1144,1,0,0,0,1147,1148,5,151,0,0,1148,1151,1,0,0,0,1149,1151,3,150,75,
0,1150,1139,1,0,0,0,1150,1149,1,0,0,0,1151,149,1,0,0,0,1152,1157,3,152,
76,0,1153,1154,5,151,0,0,1154,1156,3,152,76,0,1155,1153,1,0,0,0,1156,
1159,1,0,0,0,1157,1155,1,0,0,0,1157,1158,1,0,0,0,1158,1161,1,0,0,0,1159,
1157,1,0,0,0,1160,1162,5,151,0,0,1161,1160,1,0,0,0,1161,1162,1,0,0,0,
1162,151,1,0,0,0,1163,1164,3,222,111,0,1164,1165,5,150,0,0,1165,1166,
3,154,77,0,1166,1174,1,0,0,0,1167,1168,5,39,0,0,1168,1174,3,220,110,0,
1169,1174,3,154,77,0,1170,1171,3,154,77,0,1171,1172,3,220,110,0,1172,
1174,1,0,0,0,1173,1163,1,0,0,0,1173,1167,1,0,0,0,1173,1169,1,0,0,0,1173,
1170,1,0,0,0,1174,153,1,0,0,0,1175,1176,6,77,-1,0,1176,1177,3,156,78,
0,1177,1198,1,0,0,0,1178,1179,10,5,0,0,1179,1180,5,2,0,0,1180,1197,3,
154,77,6,1181,1182,10,4,0,0,1182,1183,5,78,0,0,1183,1197,3,154,77,5,1184,
1185,10,3,0,0,1185,1186,5,177,0,0,1186,1187,3,154,77,0,1187,1188,5,150,
0,0,1188,1189,3,154,77,3,1189,1197,1,0,0,0,1190,1191,10,2,0,0,1191,1194,
5,6,0,0,1192,1195,3,222,111,0,1193,1195,5,143,0,0,1194,1192,1,0,0,0,1194,
1193,1,0,0,0,1195,1197,1,0,0,0,1196,1178,1,0,0,0,1196,1181,1,0,0,0,1196,
1184,1,0,0,0,1196,1190,1,0,0,0,1197,1200,1,0,0,0,1198,1196,1,0,0,0,1198,
1199,1,0,0,0,1199,155,1,0,0,0,1200,1198,1,0,0,0,1201,1202,6,78,-1,0,1202,
1204,5,12,0,0,1203,1205,3,154,77,0,1204,1203,1,0,0,0,1204,1205,1,0,0,
0,1205,1211,1,0,0,0,1206,1207,5,126,0,0,1207,1208,3,154,77,0,1208,1209,
5,105,0,0,1209,1210,3,154,77,0,1210,1212,1,0,0,0,1211,1206,1,0,0,0,1212,
1213,1,0,0,0,1213,1211,1,0,0,0,1213,1214,1,0,0,0,1214,1217,1,0,0,0,1215,
1216,5,26,0,0,1216,1218,3,154,77,0,1217,1215,1,0,0,0,1217,1218,1,0,0,
0,1218,1219,1,0,0,0,1219,1220,5,27,0,0,1220,1551,1,0,0,0,1221,1222,5,
13,0,0,1222,1223,5,165,0,0,1223,1224,3,154,77,0,1224,1225,5,6,0,0,1225,
1226,3,138,69,0,1226,1227,5,186,0,0,1227,1551,1,0,0,0,1228,1229,5,119,
0,0,1229,1230,5,165,0,0,1230,1231,3,154,77,0,1231,1232,5,6,0,0,1232,1233,
3,138,69,0,1233,1234,5,186,0,0,1234,1551,1,0,0,0,1235,1236,5,21,0,0,1236,
1551,5,143,0,0,1237,1238,5,56,0,0,1238,1239,3,154,77,0,1239,1240,3,210,
105,0,1240,1551,1,0,0,0,1241,1242,5,56,0,0,1242,1551,5,143,0,0,1243,1244,
5,104,0,0,1244,1245,5,165,0,0,1245,1246,3,154,77,0,1246,1247,5,39,0,0,
1247,1250,3,154,77,0,1248,1249,5,38,0,0,1249,1251,3,154,77,0,1250,1248,
1,0,0,0,1250,1251,1,0,0,0,1251,1252,1,0,0,0,1252,1253,5,186,0,0,1253,
1551,1,0,0,0,1254,1255,5,108,0,0,1255,1551,5,143,0,0,1256,1257,5,116,
0,0,1257,1258,5,165,0,0,1258,1259,7,12,0,0,1259,1260,3,228,114,0,1260,
1261,5,39,0,0,1261,1262,3,154,77,0,1262,1263,5,186,0,0,1263,1551,1,0,
0,0,1264,1265,5,17,0,0,1265,1266,5,165,0,0,1266,1267,5,143,0,0,1267,1551,
5,186,0,0,1268,1269,5,17,0,0,1269,1270,5,165,0,0,1270,1271,3,146,73,0,
1271,1272,5,186,0,0,1272,1551,1,0,0,0,1273,1274,5,17,0,0,1274,1275,5,
165,0,0,1275,1276,5,145,0,0,1276,1277,5,29,0,0,1277,1278,5,165,0,0,1278,
1279,3,8,4,0,1279,1280,5,186,0,0,1280,1281,5,91,0,0,1281,1282,5,165,0,
0,1282,1283,3,160,80,0,1283,1284,5,186,0,0,1284,1285,5,186,0,0,1285,1299,
1,0,0,0,1286,1287,5,165,0,0,1287,1288,5,145,0,0,1288,1289,5,29,0,0,1289,
1290,5,165,0,0,1290,1291,3,8,4,0,1291,1292,5,186,0,0,1292,1293,5,91,0,
0,1293,1294,5,165,0,0,1294,1295,3,160,80,0,1295,1296,5,186,0,0,1296,1297,
5,186,0,0,1297,1299,1,0,0,0,1298,1273,1,0,0,0,1298,1286,1,0,0,0,1299,
1551,1,0,0,0,1300,1301,5,17,0,0,1301,1302,5,165,0,0,1302,1303,5,145,0,
0,1303,1304,5,29,0,0,1304,1305,5,165,0,0,1305,1306,3,8,4,0,1306,1307,
5,186,0,0,1307,1308,5,186,0,0,1308,1551,1,0,0,0,1309,1310,5,17,0,0,1310,
1311,5,165,0,0,1311,1312,5,145,0,0,1312,1313,5,91,0,0,1313,1314,5,165,
0,0,1314,1315,3,160,80,0,1315,1316,5,186,0,0,1316,1317,5,186,0,0,1317,
1327,1,0,0,0,1318,1319,5,165,0,0,1319,1320,5,145,0,0,1320,1321,5,91,0,
0,1321,1322,5,165,0,0,1322,1323,3,160,80,0,1323,1324,5,186,0,0,1324,1325,
5,186,0,0,1325,1327,1,0,0,0,1326,1309,1,0,0,0,1326,1318,1,0,0,0,1327,
1551,1,0,0,0,1328,1329,5,17,0,0,1329,1330,5,165,0,0,1330,1331,5,145,0,
0,1331,1551,5,186,0,0,1332,1333,5,17,0,0,1333,1334,5,165,0,0,1334,1335,
3,222,111,0,1335,1336,5,155,0,0,1336,1337,5,145,0,0,1337,1338,5,29,0,
0,1338,1339,5,165,0,0,1339,1340,3,8,4,0,1340,1341,5,186,0,0,1341,1342,
5,91,0,0,1342,1343,5,165,0,0,1343,1344,3,160,80,0,1344,1345,5,186,0,0,
1345,1346,5,186,0,0,1346,1551,1,0,0,0,1347,1348,5,17,0,0,1348,1349,5,
165,0,0,1349,1350,3,222,111,0,1350,1351,5,155,0,0,1351,1352,5,145,0,0,
1352,1353,5,29,0,0,1353,1354,5,165,0,0,1354,1355,3,8,4,0,1355,1356,5,
186,0,0,1356,1357,5,186,0,0,1357,1551,1,0,0,0,1358,1359,5,17,0,0,1359,
1360,5,165,0,0,1360,1361,3,222,111,0,1361,1362,5,155,0,0,1362,1363,5,
145,0,0,1363,1364,5,91,0,0,1364,1365,5,165,0,0,1365,1366,3,160,80,0,1366,
1367,5,186,0,0,1367,1368,5,186,0,0,1368,1551,1,0,0,0,1369,1370,5,17,0,
0,1370,1371,5,165,0,0,1371,1372,3,222,111,0,1372,1373,5,155,0,0,1373,
1374,5,145,0,0,1374,1375,5,186,0,0,1375,1551,1,0,0,0,1376,1377,5,145,
0,0,1377,1378,5,17,0,0,1378,1379,5,165,0,0,1379,1380,5,143,0,0,1380,1551,
5,186,0,0,1381,1382,5,145,0,0,1382,1383,5,17,0,0,1383,1384,5,165,0,0,
1384,1385,3,146,73,0,1385,1386,5,186,0,0,1386,1551,1,0,0,0,1387,1388,
3,222,111,0,1388,1390,5,165,0,0,1389,1391,3,146,73,0,1390,1389,1,0,0,
0,1390,1391,1,0,0,0,1391,1392,1,0,0,0,1392,1393,5,186,0,0,1393,1394,3,
128,64,0,1394,1551,1,0,0,0,1395,1396,3,222,111,0,1396,1398,5,165,0,0,
1397,1399,3,146,73,0,1398,1397,1,0,0,0,1398,1399,1,0,0,0,1399,1400,1,
0,0,0,1400,1401,5,186,0,0,1401,1410,1,0,0,0,1402,1404,5,165,0,0,1403,
1405,5,25,0,0,1404,1403,1,0,0,0,1404,1405,1,0,0,0,1405,1407,1,0,0,0,1406,
1408,3,146,73,0,1407,1406,1,0,0,0,1407,1408,1,0,0,0,1408,1409,1,0,0,0,
1409,1411,5,186,0,0,1410,1402,1,0,0,0,1410,1411,1,0,0,0,1411,1418,1,0,
0,0,1412,1413,5,33,0,0,1413,1414,5,165,0,0,1414,1415,5,127,0,0,1415,1416,
3,154,77,0,1416,1417,5,186,0,0,1417,1419,1,0,0,0,1418,1412,1,0,0,0,1418,
1419,1,0,0,0,1419,1420,1,0,0,0,1420,1421,5,81,0,0,1421,1422,5,165,0,0,
1422,1423,3,122,61,0,1423,1424,5,186,0,0,1424,1551,1,0,0,0,1425,1426,
3,222,111,0,1426,1428,5,165,0,0,1427,1429,3,146,73,0,1428,1427,1,0,0,
0,1428,1429,1,0,0,0,1429,1430,1,0,0,0,1430,1431,5,186,0,0,1431,1440,1,
0,0,0,1432,1434,5,165,0,0,1433,1435,5,25,0,0,1434,1433,1,0,0,0,1434,1435,
1,0,0,0,1435,1437,1,0,0,0,1436,1438,3,146,73,0,1437,1436,1,0,0,0,1437,
1438,1,0,0,0,1438,1439,1,0,0,0,1439,1441,5,186,0,0,1440,1432,1,0,0,0,
1440,1441,1,0,0,0,1441,1448,1,0,0,0,1442,1443,5,33,0,0,1443,1444,5,165,
0,0,1444,1445,5,127,0,0,1445,1446,3,154,77,0,1446,1447,5,186,0,0,1447,
1449,1,0,0,0,1448,1442,1,0,0,0,1448,1449,1,0,0,0,1449,1450,1,0,0,0,1450,
1451,5,81,0,0,1451,1452,3,222,111,0,1452,1551,1,0,0,0,1453,1459,3,222,
111,0,1454,1456,5,165,0,0,1455,1457,3,146,73,0,1456,1455,1,0,0,0,1456,
1457,1,0,0,0,1457,1458,1,0,0,0,1458,1460,5,186,0,0,1459,1454,1,0,0,0,
1459,1460,1,0,0,0,1460,1461,1,0,0,0,1461,1463,5,165,0,0,1462,1464,5,25,
0,0,1463,1462,1,0,0,0,1463,1464,1,0,0,0,1464,1466,1,0,0,0,1465,1467,3,
146,73,0,1466,1465,1,0,0,0,1466,1467,1,0,0,0,1467,1471,1,0,0,0,1468,1469,
5,79,0,0,1469,1470,5,11,0,0,1470,1472,3,108,54,0,1471,1468,1,0,0,0,1471,
1472,1,0,0,0,1472,1473,1,0,0,0,1473,1480,5,186,0,0,1474,1475,5,33,0,0,
1475,1476,5,165,0,0,1476,1477,5,127,0,0,1477,1478,3,154,77,0,1478,1479,
5,186,0,0,1479,1481,1,0,0,0,1480,1474,1,0,0,0,1480,1481,1,0,0,0,1481,
1551,1,0,0,0,1482,1551,3,168,84,0,1483,1551,3,230,115,0,1484,1551,3,208,
104,0,1485,1486,5,153,0,0,1486,1551,3,156,78,22,1487,1488,5,73,0,0,1488,
1551,3,156,78,12,1489,1490,3,198,99,0,1490,1491,5,155,0,0,1491,1493,1,
0,0,0,1492,1489,1,0,0,0,1492,1493,1,0,0,0,1493,1494,1,0,0,0,1494,1500,
5,145,0,0,1495,1496,5,29,0,0,1496,1497,5,165,0,0,1497,1498,3,8,4,0,1498,
1499,5,186,0,0,1499,1501,1,0,0,0,1500,1495,1,0,0,0,1500,1501,1,0,0,0,
1501,1551,1,0,0,0,1502,1503,5,60,0,0,1503,1508,3,222,111,0,1504,1505,
5,151,0,0,1505,1507,3,222,111,0,1506,1504,1,0,0,0,1507,1510,1,0,0,0,1508,
1506,1,0,0,0,1508,1509,1,0,0,0,1509,1512,1,0,0,0,1510,1508,1,0,0,0,1511,
1513,5,151,0,0,1512,1511,1,0,0,0,1512,1513,1,0,0,0,1513,1514,1,0,0,0,
1514,1515,5,150,0,0,1515,1516,3,154,77,0,1516,1551,1,0,0,0,1517,1518,
5,165,0,0,1518,1519,3,48,24,0,1519,1520,5,186,0,0,1520,1551,1,0,0,0,1521,
1522,5,165,0,0,1522,1523,3,154,77,0,1523,1524,5,186,0,0,1524,1551,1,0,
0,0,1525,1526,5,165,0,0,1526,1527,3,146,73,0,1527,1528,5,186,0,0,1528,
1551,1,0,0,0,1529,1531,5,5,0,0,1530,1529,1,0,0,0,1530,1531,1,0,0,0,1531,
1532,1,0,0,0,1532,1534,5,164,0,0,1533,1535,3,146,73,0,1534,1533,1,0,0,
0,1534,1535,1,0,0,0,1535,1536,1,0,0,0,1536,1551,5,185,0,0,1537,1539,5,
163,0,0,1538,1540,3,40,20,0,1539,1538,1,0,0,0,1539,1540,1,0,0,0,1540,
1541,1,0,0,0,1541,1551,5,184,0,0,1542,1551,3,158,79,0,1543,1544,3,222,
111,0,1544,1545,5,149,0,0,1545,1546,3,154,77,0,1546,1551,1,0,0,0,1547,
1548,5,160,0,0,1548,1551,5,139,0,0,1549,1551,3,178,89,0,1550,1201,1,0,
0,0,1550,1221,1,0,0,0,1550,1228,1,0,0,0,1550,1235,1,0,0,0,1550,1237,1,
0,0,0,1550,1241,1,0,0,0,1550,1243,1,0,0,0,1550,1254,1,0,0,0,1550,1256,
1,0,0,0,1550,1264,1,0,0,0,1550,1268,1,0,0,0,1550,1298,1,0,0,0,1550,1300,
1,0,0,0,1550,1326,1,0,0,0,1550,1328,1,0,0,0,1550,1332,1,0,0,0,1550,1347,
1,0,0,0,1550,1358,1,0,0,0,1550,1369,1,0,0,0,1550,1376,1,0,0,0,1550,1381,
1,0,0,0,1550,1387,1,0,0,0,1550,1395,1,0,0,0,1550,1425,1,0,0,0,1550,1453,
1,0,0,0,1550,1482,1,0,0,0,1550,1483,1,0,0,0,1550,1484,1,0,0,0,1550,1485,
1,0,0,0,1550,1487,1,0,0,0,1550,1492,1,0,0,0,1550,1502,1,0,0,0,1550,1517,
1,0,0,0,1550,1521,1,0,0,0,1550,1525,1,0,0,0,1550,1530,1,0,0,0,1550,1537,
1,0,0,0,1550,1542,1,0,0,0,1550,1543,1,0,0,0,1550,1547,1,0,0,0,1550,1549,
1,0,0,0,1551,1675,1,0,0,0,1552,1556,10,21,0,0,1553,1557,5,145,0,0,1554,
1557,5,188,0,0,1555,1557,5,175,0,0,1556,1553,1,0,0,0,1556,1554,1,0,0,
0,1556,1555,1,0,0,0,1557,1558,1,0,0,0,1558,1674,3,156,78,22,1559,1563,
10,20,0,0,1560,1564,5,176,0,0,1561,1564,5,153,0,0,1562,1564,5,152,0,0,
1563,1560,1,0,0,0,1563,1561,1,0,0,0,1563,1562,1,0,0,0,1564,1565,1,0,0,
0,1565,1674,3,156,78,21,1566,1591,10,19,0,0,1567,1592,5,156,0,0,1568,
1592,5,157,0,0,1569,1592,5,170,0,0,1570,1592,5,167,0,0,1571,1592,5,168,
0,0,1572,1592,5,158,0,0,1573,1592,5,159,0,0,1574,1576,5,73,0,0,1575,1574,
1,0,0,0,1575,1576,1,0,0,0,1576,1577,1,0,0,0,1577,1579,5,51,0,0,1578,1580,
5,15,0,0,1579,1578,1,0,0,0,1579,1580,1,0,0,0,1580,1592,1,0,0,0,1581,1583,
5,73,0,0,1582,1581,1,0,0,0,1582,1583,1,0,0,0,1583,1584,1,0,0,0,1584,1592,
7,13,0,0,1585,1592,5,182,0,0,1586,1592,5,183,0,0,1587,1592,5,172,0,0,
1588,1592,5,161,0,0,1589,1592,5,162,0,0,1590,1592,5,171,0,0,1591,1567,
1,0,0,0,1591,1568,1,0,0,0,1591,1569,1,0,0,0,1591,1570,1,0,0,0,1591,1571,
1,0,0,0,1591,1572,1,0,0,0,1591,1573,1,0,0,0,1591,1575,1,0,0,0,1591,1582,
1,0,0,0,1591,1585,1,0,0,0,1591,1586,1,0,0,0,1591,1587,1,0,0,0,1591,1588,
1,0,0,0,1591,1589,1,0,0,0,1591,1590,1,0,0,0,1592,1593,1,0,0,0,1593,1674,
3,156,78,20,1594,1595,10,16,0,0,1595,1597,5,57,0,0,1596,1598,5,73,0,0,
1597,1596,1,0,0,0,1597,1598,1,0,0,0,1598,1599,1,0,0,0,1599,1600,5,25,
0,0,1600,1601,5,39,0,0,1601,1674,3,156,78,17,1602,1603,10,15,0,0,1603,
1604,5,166,0,0,1604,1674,3,156,78,16,1605,1606,10,14,0,0,1606,1607,5,
174,0,0,1607,1674,3,156,78,15,1608,1610,10,13,0,0,1609,1611,5,73,0,0,
1610,1609,1,0,0,0,1610,1611,1,0,0,0,1611,1612,1,0,0,0,1612,1613,5,9,0,
0,1613,1614,3,156,78,0,1614,1615,5,2,0,0,1615,1616,3,156,78,14,1616,1674,
1,0,0,0,1617,1618,10,35,0,0,1618,1619,5,165,0,0,1619,1620,3,48,24,0,1620,
1621,5,186,0,0,1621,1674,1,0,0,0,1622,1623,10,34,0,0,1623,1625,5,165,
0,0,1624,1626,3,146,73,0,1625,1624,1,0,0,0,1625,1626,1,0,0,0,1626,1627,
1,0,0,0,1627,1674,5,186,0,0,1628,1629,10,30,0,0,1629,1630,5,164,0,0,1630,
1631,3,154,77,0,1631,1632,5,185,0,0,1632,1674,1,0,0,0,1633,1634,10,29,
0,0,1634,1636,5,164,0,0,1635,1637,3,154,77,0,1636,1635,1,0,0,0,1636,1637,
1,0,0,0,1637,1638,1,0,0,0,1638,1640,5,150,0,0,1639,1641,3,154,77,0,1640,
1639,1,0,0,0,1640,1641,1,0,0,0,1641,1642,1,0,0,0,1642,1674,5,185,0,0,
1643,1644,10,28,0,0,1644,1645,5,155,0,0,1645,1674,5,139,0,0,1646,1647,
10,27,0,0,1647,1648,5,155,0,0,1648,1674,3,222,111,0,1649,1650,10,26,0,
0,1650,1651,5,173,0,0,1651,1652,5,164,0,0,1652,1653,3,154,77,0,1653,1654,
5,185,0,0,1654,1674,1,0,0,0,1655,1656,10,25,0,0,1656,1657,5,173,0,0,1657,
1674,5,139,0,0,1658,1659,10,24,0,0,1659,1660,5,173,0,0,1660,1674,3,222,
111,0,1661,1662,10,23,0,0,1662,1663,5,148,0,0,1663,1674,3,140,70,0,1664,
1665,10,18,0,0,1665,1666,5,49,0,0,1666,1674,5,75,0,0,1667,1668,10,17,
0,0,1668,1670,5,57,0,0,1669,1671,5,73,0,0,1670,1669,1,0,0,0,1670,1671,
1,0,0,0,1671,1672,1,0,0,0,1672,1674,5,74,0,0,1673,1552,1,0,0,0,1673,1559,
1,0,0,0,1673,1566,1,0,0,0,1673,1594,1,0,0,0,1673,1602,1,0,0,0,1673,1605,
1,0,0,0,1673,1608,1,0,0,0,1673,1617,1,0,0,0,1673,1622,1,0,0,0,1673,1628,
1,0,0,0,1673,1633,1,0,0,0,1673,1643,1,0,0,0,1673,1646,1,0,0,0,1673,1649,
1,0,0,0,1673,1655,1,0,0,0,1673,1658,1,0,0,0,1673,1661,1,0,0,0,1673,1664,
1,0,0,0,1673,1667,1,0,0,0,1674,1677,1,0,0,0,1675,1673,1,0,0,0,1675,1676,
1,0,0,0,1676,157,1,0,0,0,1677,1675,1,0,0,0,1678,1679,5,165,0,0,1679,1684,
3,222,111,0,1680,1681,5,151,0,0,1681,1683,3,222,111,0,1682,1680,1,0,0,
0,1683,1686,1,0,0,0,1684,1682,1,0,0,0,1684,1685,1,0,0,0,1685,1688,1,0,
0,0,1686,1684,1,0,0,0,1687,1689,5,151,0,0,1688,1687,1,0,0,0,1688,1689,
1,0,0,0,1689,1690,1,0,0,0,1690,1691,5,186,0,0,1691,1706,1,0,0,0,1692,
1697,3,222,111,0,1693,1694,5,151,0,0,1694,1696,3,222,111,0,1695,1693,
1,0,0,0,1696,1699,1,0,0,0,1697,1695,1,0,0,0,1697,1698,1,0,0,0,1698,1701,
1,0,0,0,1699,1697,1,0,0,0,1700,1702,5,151,0,0,1701,1700,1,0,0,0,1701,
1702,1,0,0,0,1702,1706,1,0,0,0,1703,1704,5,165,0,0,1704,1706,5,186,0,
0,1705,1678,1,0,0,0,1705,1692,1,0,0,0,1705,1703,1,0,0,0,1706,1707,1,0,
0,0,1707,1710,5,144,0,0,1708,1711,3,154,77,0,1709,1711,3,36,18,0,1710,
1708,1,0,0,0,1710,1709,1,0,0,0,1711,1728,1,0,0,0,1712,1713,5,60,0,0,1713,
1718,3,222,111,0,1714,1715,5,151,0,0,1715,1717,3,222,111,0,1716,1714,
1,0,0,0,1717,1720,1,0,0,0,1718,1716,1,0,0,0,1718,1719,1,0,0,0,1719,1722,
1,0,0,0,1720,1718,1,0,0,0,1721,1723,5,151,0,0,1722,1721,1,0,0,0,1722,
1723,1,0,0,0,1723,1724,1,0,0,0,1724,1725,5,150,0,0,1725,1726,3,154,77,
0,1726,1728,1,0,0,0,1727,1705,1,0,0,0,1727,1712,1,0,0,0,1728,159,1,0,
0,0,1729,1734,3,162,81,0,1730,1731,5,151,0,0,1731,1733,3,162,81,0,1732,
1730,1,0,0,0,1733,1736,1,0,0,0,1734,1732,1,0,0,0,1734,1735,1,0,0,0,1735,
161,1,0,0,0,1736,1734,1,0,0,0,1737,1738,3,154,77,0,1738,1739,5,6,0,0,
1739,1740,3,222,111,0,1740,163,1,0,0,0,1741,1748,3,168,84,0,1742,1748,
3,166,83,0,1743,1744,5,163,0,0,1744,1745,3,154,77,0,1745,1746,5,184,0,
0,1746,1748,1,0,0,0,1747,1741,1,0,0,0,1747,1742,1,0,0,0,1747,1743,1,0,
0,0,1748,165,1,0,0,0,1749,1750,5,206,0,0,1750,167,1,0,0,0,1751,1752,5,
168,0,0,1752,1756,3,222,111,0,1753,1755,3,170,85,0,1754,1753,1,0,0,0,
1755,1758,1,0,0,0,1756,1754,1,0,0,0,1756,1757,1,0,0,0,1757,1759,1,0,0,
0,1758,1756,1,0,0,0,1759,1760,5,189,0,0,1760,1781,1,0,0,0,1761,1762,5,
168,0,0,1762,1766,3,222,111,0,1763,1765,3,170,85,0,1764,1763,1,0,0,0,
1765,1768,1,0,0,0,1766,1764,1,0,0,0,1766,1767,1,0,0,0,1767,1769,1,0,0,
0,1768,1766,1,0,0,0,1769,1773,5,159,0,0,1770,1772,3,164,82,0,1771,1770,
1,0,0,0,1772,1775,1,0,0,0,1773,1771,1,0,0,0,1773,1774,1,0,0,0,1774,1776,
1,0,0,0,1775,1773,1,0,0,0,1776,1777,5,169,0,0,1777,1778,3,222,111,0,1778,
1779,5,159,0,0,1779,1781,1,0,0,0,1780,1751,1,0,0,0,1780,1761,1,0,0,0,
1781,169,1,0,0,0,1782,1783,3,222,111,0,1783,1784,5,157,0,0,1784,1785,
3,228,114,0,1785,1794,1,0,0,0,1786,1787,3,222,111,0,1787,1788,5,157,0,
0,1788,1789,5,163,0,0,1789,1790,3,154,77,0,1790,1791,5,184,0,0,1791,1794,
1,0,0,0,1792,1794,3,222,111,0,1793,1782,1,0,0,0,1793,1786,1,0,0,0,1793,
1792,1,0,0,0,1794,171,1,0,0,0,1795,1800,3,174,87,0,1796,1797,5,151,0,
0,1797,1799,3,174,87,0,1798,1796,1,0,0,0,1799,1802,1,0,0,0,1800,1798,
1,0,0,0,1800,1801,1,0,0,0,1801,1804,1,0,0,0,1802,1800,1,0,0,0,1803,1805,
5,151,0,0,1804,1803,1,0,0,0,1804,1805,1,0,0,0,1805,173,1,0,0,0,1806,1808,
3,222,111,0,1807,1809,3,176,88,0,1808,1807,1,0,0,0,1808,1809,1,0,0,0,
1809,1813,1,0,0,0,1810,1811,5,123,0,0,1811,1812,5,59,0,0,1812,1814,3,
176,88,0,1813,1810,1,0,0,0,1813,1814,1,0,0,0,1814,1815,1,0,0,0,1815,1820,
5,6,0,0,1816,1818,5,73,0,0,1817,1816,1,0,0,0,1817,1818,1,0,0,0,1818,1819,
1,0,0,0,1819,1821,5,67,0,0,1820,1817,1,0,0,0,1820,1821,1,0,0,0,1821,1822,
1,0,0,0,1822,1823,5,165,0,0,1823,1824,3,48,24,0,1824,1825,5,186,0,0,1825,
1831,1,0,0,0,1826,1827,3,154,77,0,1827,1828,5,6,0,0,1828,1829,3,222,111,
0,1829,1831,1,0,0,0,1830,1806,1,0,0,0,1830,1826,1,0,0,0,1831,175,1,0,
0,0,1832,1833,5,165,0,0,1833,1838,3,222,111,0,1834,1835,5,151,0,0,1835,
1837,3,222,111,0,1836,1834,1,0,0,0,1837,1840,1,0,0,0,1838,1836,1,0,0,
0,1838,1839,1,0,0,0,1839,1841,1,0,0,0,1840,1838,1,0,0,0,1841,1842,5,186,
0,0,1842,177,1,0,0,0,1843,1851,3,226,113,0,1844,1845,3,198,99,0,1845,
1846,5,155,0,0,1846,1848,1,0,0,0,1847,1844,1,0,0,0,1847,1848,1,0,0,0,
1848,1849,1,0,0,0,1849,1851,3,180,90,0,1850,1843,1,0,0,0,1850,1847,1,
0,0,0,1851,179,1,0,0,0,1852,1857,3,222,111,0,1853,1854,5,155,0,0,1854,
1856,3,222,111,0,1855,1853,1,0,0,0,1856,1859,1,0,0,0,1857,1855,1,0,0,
0,1857,1858,1,0,0,0,1858,181,1,0,0,0,1859,1857,1,0,0,0,1860,1861,6,91,
-1,0,1861,1874,3,198,99,0,1862,1874,3,196,98,0,1863,1864,5,165,0,0,1864,
1865,3,48,24,0,1865,1866,5,186,0,0,1866,1874,1,0,0,0,1867,1868,5,165,
0,0,1868,1869,3,92,46,0,1869,1870,5,186,0,0,1870,1874,1,0,0,0,1871,1874,
3,168,84,0,1872,1874,3,226,113,0,1873,1860,1,0,0,0,1873,1862,1,0,0,0,
1873,1863,1,0,0,0,1873,1867,1,0,0,0,1873,1871,1,0,0,0,1873,1872,1,0,0,
0,1874,1908,1,0,0,0,1875,1876,10,5,0,0,1876,1877,5,83,0,0,1877,1878,5,
165,0,0,1878,1879,3,146,73,0,1879,1883,3,184,92,0,1880,1881,5,42,0,0,
1881,1882,5,11,0,0,1882,1884,3,146,73,0,1883,1880,1,0,0,0,1883,1884,1,
0,0,0,1884,1885,1,0,0,0,1885,1886,5,186,0,0,1886,1907,1,0,0,0,1887,1888,
10,4,0,0,1888,1891,5,122,0,0,1889,1890,5,50,0,0,1890,1892,5,75,0,0,1891,
1889,1,0,0,0,1891,1892,1,0,0,0,1892,1893,1,0,0,0,1893,1894,5,165,0,0,
1894,1895,3,188,94,0,1895,1896,5,186,0,0,1896,1907,1,0,0,0,1897,1901,
10,3,0,0,1898,1902,3,218,109,0,1899,1900,5,6,0,0,1900,1902,3,222,111,
0,1901,1898,1,0,0,0,1901,1899,1,0,0,0,1902,1904,1,0,0,0,1903,1905,3,194,
97,0,1904,1903,1,0,0,0,1904,1905,1,0,0,0,1905,1907,1,0,0,0,1906,1875,
1,0,0,0,1906,1887,1,0,0,0,1906,1897,1,0,0,0,1907,1910,1,0,0,0,1908,1906,
1,0,0,0,1908,1909,1,0,0,0,1909,183,1,0,0,0,1910,1908,1,0,0,0,1911,1913,
5,38,0,0,1912,1914,3,186,93,0,1913,1912,1,0,0,0,1914,1915,1,0,0,0,1915,
1913,1,0,0,0,1915,1916,1,0,0,0,1916,185,1,0,0,0,1917,1918,3,192,96,0,
1918,1919,5,51,0,0,1919,1920,5,165,0,0,1920,1921,3,146,73,0,1921,1922,
5,186,0,0,1922,187,1,0,0,0,1923,1928,3,190,95,0,1924,1925,5,151,0,0,1925,
1927,3,190,95,0,1926,1924,1,0,0,0,1927,1930,1,0,0,0,1928,1926,1,0,0,0,
1928,1929,1,0,0,0,1929,1932,1,0,0,0,1930,1928,1,0,0,0,1931,1933,5,151,
0,0,1932,1931,1,0,0,0,1932,1933,1,0,0,0,1933,189,1,0,0,0,1934,1935,3,
192,96,0,1935,1936,5,38,0,0,1936,1937,3,192,96,0,1937,1938,5,51,0,0,1938,
1939,5,165,0,0,1939,1940,3,146,73,0,1940,1949,5,186,0,0,1941,1942,3,192,
96,0,1942,1943,5,51,0,0,1943,1944,5,165,0,0,1944,1945,3,146,73,0,1945,
1946,5,186,0,0,1946,1948,1,0,0,0,1947,1941,1,0,0,0,1948,1951,1,0,0,0,
1949,1947,1,0,0,0,1949,1950,1,0,0,0,1950,191,1,0,0,0,1951,1949,1,0,0,
0,1952,1953,5,165,0,0,1953,1954,3,146,73,0,1954,1955,5,186,0,0,1955,1958,
1,0,0,0,1956,1958,3,154,77,0,1957,1952,1,0,0,0,1957,1956,1,0,0,0,1958,
193,1,0,0,0,1959,1960,5,165,0,0,1960,1965,3,222,111,0,1961,1962,5,151,
0,0,1962,1964,3,222,111,0,1963,1961,1,0,0,0,1964,1967,1,0,0,0,1965,1963,
1,0,0,0,1965,1966,1,0,0,0,1966,1968,1,0,0,0,1967,1965,1,0,0,0,1968,1969,
5,186,0,0,1969,195,1,0,0,0,1970,1971,3,222,111,0,1971,1973,5,165,0,0,
1972,1974,3,200,100,0,1973,1972,1,0,0,0,1973,1974,1,0,0,0,1974,1975,1,
0,0,0,1975,1976,5,186,0,0,1976,197,1,0,0,0,1977,1978,3,202,101,0,1978,
1979,5,155,0,0,1979,1981,1,0,0,0,1980,1977,1,0,0,0,1980,1981,1,0,0,0,
1981,1982,1,0,0,0,1982,1983,3,180,90,0,1983,199,1,0,0,0,1984,1989,3,154,
77,0,1985,1986,5,151,0,0,1986,1988,3,154,77,0,1987,1985,1,0,0,0,1988,
1991,1,0,0,0,1989,1987,1,0,0,0,1989,1990,1,0,0,0,1990,1993,1,0,0,0,1991,
1989,1,0,0,0,1992,1994,5,151,0,0,1993,1992,1,0,0,0,1993,1994,1,0,0,0,
1994,201,1,0,0,0,1995,1996,3,222,111,0,1996,203,1,0,0,0,1997,2006,5,136,
0,0,1998,1999,5,155,0,0,1999,2006,7,14,0,0,2000,2001,5,139,0,0,2001,2003,
5,155,0,0,2002,2004,7,14,0,0,2003,2002,1,0,0,0,2003,2004,1,0,0,0,2004,
2006,1,0,0,0,2005,1997,1,0,0,0,2005,1998,1,0,0,0,2005,2000,1,0,0,0,2006,
205,1,0,0,0,2007,2009,7,15,0,0,2008,2007,1,0,0,0,2008,2009,1,0,0,0,2009,
2018,1,0,0,0,2010,2019,3,204,102,0,2011,2019,5,137,0,0,2012,2019,5,138,
0,0,2013,2019,5,141,0,0,2014,2019,5,139,0,0,2015,2019,5,140,0,0,2016,
2019,5,52,0,0,2017,2019,5,72,0,0,2018,2010,1,0,0,0,2018,2011,1,0,0,0,
2018,2012,1,0,0,0,2018,2013,1,0,0,0,2018,2014,1,0,0,0,2018,2015,1,0,0,
0,2018,2016,1,0,0,0,2018,2017,1,0,0,0,2019,207,1,0,0,0,2020,2024,3,206,
103,0,2021,2024,5,143,0,0,2022,2024,5,74,0,0,2023,2020,1,0,0,0,2023,2021,
1,0,0,0,2023,2022,1,0,0,0,2024,209,1,0,0,0,2025,2026,7,16,0,0,2026,211,
1,0,0,0,2027,2028,7,17,0,0,2028,213,1,0,0,0,2029,2030,7,18,0,0,2030,215,
1,0,0,0,2031,2032,7,19,0,0,2032,217,1,0,0,0,2033,2037,5,134,0,0,2034,
2037,5,135,0,0,2035,2037,3,214,107,0,2036,2033,1,0,0,0,2036,2034,1,0,
0,0,2036,2035,1,0,0,0,2037,219,1,0,0,0,2038,2042,5,134,0,0,2039,2042,
5,135,0,0,2040,2042,3,216,108,0,2041,2038,1,0,0,0,2041,2039,1,0,0,0,2041,
2040,1,0,0,0,2042,221,1,0,0,0,2043,2048,5,134,0,0,2044,2048,5,135,0,0,
2045,2048,3,210,105,0,2046,2048,3,212,106,0,2047,2043,1,0,0,0,2047,2044,
1,0,0,0,2047,2045,1,0,0,0,2047,2046,1,0,0,0,2048,223,1,0,0,0,2049,2050,
3,228,114,0,2050,2051,5,157,0,0,2051,2052,3,206,103,0,2052,225,1,0,0,
0,2053,2054,5,163,0,0,2054,2055,3,154,77,0,2055,2056,5,184,0,0,2056,227,
1,0,0,0,2057,2060,5,143,0,0,2058,2060,3,230,115,0,2059,2057,1,0,0,0,2059,
2058,1,0,0,0,2060,229,1,0,0,0,2061,2065,5,179,0,0,2062,2064,3,232,116,
0,2063,2062,1,0,0,0,2064,2067,1,0,0,0,2065,2063,1,0,0,0,2065,2066,1,0,
0,0,2066,2068,1,0,0,0,2067,2065,1,0,0,0,2068,2069,5,181,0,0,2069,231,
1,0,0,0,2070,2071,5,197,0,0,2071,2072,3,154,77,0,2072,2073,5,184,0,0,
2073,2076,1,0,0,0,2074,2076,5,196,0,0,2075,2070,1,0,0,0,2075,2074,1,0,
0,0,2076,233,1,0,0,0,2077,2081,5,180,0,0,2078,2080,3,236,118,0,2079,2078,
1,0,0,0,2080,2083,1,0,0,0,2081,2079,1,0,0,0,2081,2082,1,0,0,0,2082,2084,
1,0,0,0,2083,2081,1,0,0,0,2084,2085,5,0,0,1,2085,235,1,0,0,0,2086,2087,
5,199,0,0,2087,2088,3,154,77,0,2088,2089,5,184,0,0,2089,2092,1,0,0,0,
2090,2092,5,198,0,0,2091,2086,1,0,0,0,2091,2090,1,0,0,0,2092,237,1,0,
0,0,261,241,248,256,263,267,280,284,287,292,299,303,312,317,326,334,341,
345,351,356,364,371,377,389,392,400,414,418,423,426,441,447,452,458,464,
469,475,481,486,488,496,500,503,508,512,516,521,525,532,535,539,542,546,
549,552,555,558,561,564,568,572,575,578,582,585,588,591,595,598,602,610,
616,637,661,668,673,687,696,701,715,719,723,728,732,737,751,760,768,771,
777,785,788,793,800,810,818,824,826,830,835,842,845,849,853,856,862,864,
867,871,875,878,880,882,887,898,903,907,913,918,925,930,934,938,941,947,
951,955,960,966,968,975,983,986,989,1014,1028,1044,1048,1059,1063,1074,
1078,1085,1093,1096,1101,1106,1112,1118,1124,1133,1137,1144,1150,1157,
1161,1173,1194,1196,1198,1204,1213,1217,1250,1298,1326,1390,1398,1404,
1407,1410,1418,1428,1434,1437,1440,1448,1456,1459,1463,1466,1471,1480,
1492,1500,1508,1512,1530,1534,1539,1550,1556,1563,1575,1579,1582,1591,
1597,1610,1625,1636,1640,1670,1673,1675,1684,1688,1697,1701,1705,1710,
1718,1722,1727,1734,1747,1756,1766,1773,1780,1793,1800,1804,1808,1813,
1817,1820,1830,1838,1847,1850,1857,1873,1883,1891,1901,1904,1906,1908,
1915,1928,1932,1949,1957,1965,1973,1980,1989,1993,2003,2005,2008,2018,
2023,2036,2041,2047,2059,2065,2075,2081,2091
};
staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
antlr4::atn::ATNDeserializer deserializer;
staticData->atn = deserializer.deserialize(staticData->serializedATN);
const size_t count = staticData->atn->getNumberOfDecisions();
staticData->decisionToDFA.reserve(count);
for (size_t i = 0; i < count; i++) {
staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
}
insightsqlparserParserStaticData = std::move(staticData);
}
}
InsightsQLParser::InsightsQLParser(TokenStream *input) : InsightsQLParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
InsightsQLParser::InsightsQLParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
InsightsQLParser::initialize();
_interpreter = new atn::ParserATNSimulator(this, *insightsqlparserParserStaticData->atn, insightsqlparserParserStaticData->decisionToDFA, insightsqlparserParserStaticData->sharedContextCache, options);
}
InsightsQLParser::~InsightsQLParser() {
delete _interpreter;
}
const atn::ATN& InsightsQLParser::getATN() const {
return *insightsqlparserParserStaticData->atn;
}
std::string InsightsQLParser::getGrammarFileName() const {
return "InsightsQLParser.g4";
}
const std::vector<std::string>& InsightsQLParser::getRuleNames() const {
return insightsqlparserParserStaticData->ruleNames;
}
const dfa::Vocabulary& InsightsQLParser::getVocabulary() const {
return insightsqlparserParserStaticData->vocabulary;
}
antlr4::atn::SerializedATNView InsightsQLParser::getSerializedATN() const {
return insightsqlparserParserStaticData->serializedATN;
}
//----------------- ProgramContext ------------------------------------------------------------------
InsightsQLParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ProgramContext::EOF() {
return getToken(InsightsQLParser::EOF, 0);
}
std::vector<InsightsQLParser::DeclarationContext *> InsightsQLParser::ProgramContext::declaration() {
return getRuleContexts<InsightsQLParser::DeclarationContext>();
}
InsightsQLParser::DeclarationContext* InsightsQLParser::ProgramContext::declaration(size_t i) {
return getRuleContext<InsightsQLParser::DeclarationContext>(i);
}
size_t InsightsQLParser::ProgramContext::getRuleIndex() const {
return InsightsQLParser::RuleProgram;
}
std::any InsightsQLParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitProgram(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ProgramContext* InsightsQLParser::program() {
ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
enterRule(_localctx, 0, InsightsQLParser::RuleProgram);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(241);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18014415957803010) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 64)) & -9) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 128)) & 578995371586535383) != 0)) {
setState(238);
declaration();
setState(243);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(244);
match(InsightsQLParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- DeclarationContext ------------------------------------------------------------------
InsightsQLParser::DeclarationContext::DeclarationContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::VarDeclContext* InsightsQLParser::DeclarationContext::varDecl() {
return getRuleContext<InsightsQLParser::VarDeclContext>(0);
}
InsightsQLParser::StatementContext* InsightsQLParser::DeclarationContext::statement() {
return getRuleContext<InsightsQLParser::StatementContext>(0);
}
size_t InsightsQLParser::DeclarationContext::getRuleIndex() const {
return InsightsQLParser::RuleDeclaration;
}
std::any InsightsQLParser::DeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitDeclaration(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::DeclarationContext* InsightsQLParser::declaration() {
DeclarationContext *_localctx = _tracker.createInstance<DeclarationContext>(_ctx, getState());
enterRule(_localctx, 2, InsightsQLParser::RuleDeclaration);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(248);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::LET: {
enterOuterAlt(_localctx, 1);
setState(246);
varDecl();
break;
}
case InsightsQLParser::ALL:
case InsightsQLParser::AND:
case InsightsQLParser::ANTI:
case InsightsQLParser::ANY:
case InsightsQLParser::ARRAY:
case InsightsQLParser::AS:
case InsightsQLParser::ASCENDING:
case InsightsQLParser::ASOF:
case InsightsQLParser::BETWEEN:
case InsightsQLParser::BOTH:
case InsightsQLParser::BY:
case InsightsQLParser::CASE:
case InsightsQLParser::CAST:
case InsightsQLParser::COHORT:
case InsightsQLParser::COLLATE:
case InsightsQLParser::COLUMNS:
case InsightsQLParser::CROSS:
case InsightsQLParser::CUBE:
case InsightsQLParser::CURRENT:
case InsightsQLParser::DATE:
case InsightsQLParser::DAY:
case InsightsQLParser::DESC:
case InsightsQLParser::DESCENDING:
case InsightsQLParser::DISTINCT:
case InsightsQLParser::ELSE:
case InsightsQLParser::END:
case InsightsQLParser::EXCLUDE:
case InsightsQLParser::EXTRACT:
case InsightsQLParser::FINAL:
case InsightsQLParser::FILL:
case InsightsQLParser::FILTER:
case InsightsQLParser::FIRST:
case InsightsQLParser::FN:
case InsightsQLParser::FOLLOWING:
case InsightsQLParser::FOR:
case InsightsQLParser::FROM:
case InsightsQLParser::FULL:
case InsightsQLParser::FUN:
case InsightsQLParser::GROUP:
case InsightsQLParser::GROUPING:
case InsightsQLParser::HAVING:
case InsightsQLParser::HOUR:
case InsightsQLParser::ID:
case InsightsQLParser::IF:
case InsightsQLParser::ILIKE:
case InsightsQLParser::IGNORE:
case InsightsQLParser::INCLUDE:
case InsightsQLParser::IN:
case InsightsQLParser::INF:
case InsightsQLParser::INNER:
case InsightsQLParser::INTERPOLATE:
case InsightsQLParser::INTERVAL:
case InsightsQLParser::IS:
case InsightsQLParser::JOIN:
case InsightsQLParser::KEY:
case InsightsQLParser::LAMBDA:
case InsightsQLParser::LAST:
case InsightsQLParser::LEADING:
case InsightsQLParser::LEFT:
case InsightsQLParser::LIKE:
case InsightsQLParser::LIMIT:
case InsightsQLParser::MINUTE:
case InsightsQLParser::MONTH:
case InsightsQLParser::NAME:
case InsightsQLParser::NATURAL:
case InsightsQLParser::NAN_SQL:
case InsightsQLParser::NOT:
case InsightsQLParser::NULL_SQL:
case InsightsQLParser::NULLS:
case InsightsQLParser::OFFSET:
case InsightsQLParser::ON:
case InsightsQLParser::OR:
case InsightsQLParser::ORDER:
case InsightsQLParser::OUTER:
case InsightsQLParser::OVER:
case InsightsQLParser::PARTITION:
case InsightsQLParser::PIVOT:
case InsightsQLParser::POSITIONAL:
case InsightsQLParser::PRECEDING:
case InsightsQLParser::PREWHERE:
case InsightsQLParser::QUALIFY:
case InsightsQLParser::QUARTER:
case InsightsQLParser::RANGE:
case InsightsQLParser::RECURSIVE:
case InsightsQLParser::REPLACE:
case InsightsQLParser::RETURN:
case InsightsQLParser::RIGHT:
case InsightsQLParser::ROLLUP:
case InsightsQLParser::ROW:
case InsightsQLParser::ROWS:
case InsightsQLParser::SAMPLE:
case InsightsQLParser::SECOND:
case InsightsQLParser::SELECT:
case InsightsQLParser::SEMI:
case InsightsQLParser::SETS:
case InsightsQLParser::SETTINGS:
case InsightsQLParser::STEP:
case InsightsQLParser::SUBSTRING:
case InsightsQLParser::THEN:
case InsightsQLParser::THROW:
case InsightsQLParser::TIES:
case InsightsQLParser::TIMESTAMP:
case InsightsQLParser::TIME:
case InsightsQLParser::LOCAL:
case InsightsQLParser::ZONE:
case InsightsQLParser::TO:
case InsightsQLParser::TOP:
case InsightsQLParser::TOTALS:
case InsightsQLParser::TRAILING:
case InsightsQLParser::TRIM:
case InsightsQLParser::TRUNCATE:
case InsightsQLParser::TRY:
case InsightsQLParser::TRY_CAST:
case InsightsQLParser::UNBOUNDED:
case InsightsQLParser::UNION:
case InsightsQLParser::UNPIVOT:
case InsightsQLParser::USING:
case InsightsQLParser::VALUES:
case InsightsQLParser::WEEK:
case InsightsQLParser::WHEN:
case InsightsQLParser::WHERE:
case InsightsQLParser::WHILE:
case InsightsQLParser::WINDOW:
case InsightsQLParser::WITH:
case InsightsQLParser::YEAR:
case InsightsQLParser::IDENTIFIER:
case InsightsQLParser::QUOTED_IDENTIFIER:
case InsightsQLParser::FLOATING_LITERAL:
case InsightsQLParser::BINARY_LITERAL:
case InsightsQLParser::OCTAL_LITERAL:
case InsightsQLParser::DECIMAL_LITERAL:
case InsightsQLParser::HEXADECIMAL_LITERAL:
case InsightsQLParser::OCTAL_PREFIX_LITERAL:
case InsightsQLParser::STRING_LITERAL:
case InsightsQLParser::ASTERISK:
case InsightsQLParser::DASH:
case InsightsQLParser::DOT:
case InsightsQLParser::HASH:
case InsightsQLParser::LBRACE:
case InsightsQLParser::LBRACKET:
case InsightsQLParser::LPAREN:
case InsightsQLParser::LT:
case InsightsQLParser::PLUS:
case InsightsQLParser::QUOTE_SINGLE_TEMPLATE:
case InsightsQLParser::SEMICOLON: {
enterOuterAlt(_localctx, 2);
setState(247);
statement();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ExpressionContext ------------------------------------------------------------------
InsightsQLParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ExpressionContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::ExpressionContext::getRuleIndex() const {
return InsightsQLParser::RuleExpression;
}
std::any InsightsQLParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitExpression(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::expression() {
ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
enterRule(_localctx, 4, InsightsQLParser::RuleExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(250);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- VarDeclContext ------------------------------------------------------------------
InsightsQLParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::VarDeclContext::LET() {
return getToken(InsightsQLParser::LET, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::VarDeclContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::VarDeclContext::COLONEQUALS() {
return getToken(InsightsQLParser::COLONEQUALS, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::VarDeclContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
size_t InsightsQLParser::VarDeclContext::getRuleIndex() const {
return InsightsQLParser::RuleVarDecl;
}
std::any InsightsQLParser::VarDeclContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitVarDecl(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::VarDeclContext* InsightsQLParser::varDecl() {
VarDeclContext *_localctx = _tracker.createInstance<VarDeclContext>(_ctx, getState());
enterRule(_localctx, 6, InsightsQLParser::RuleVarDecl);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(252);
match(InsightsQLParser::LET);
setState(253);
identifier();
setState(256);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COLONEQUALS) {
setState(254);
match(InsightsQLParser::COLONEQUALS);
setState(255);
expression();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- IdentifierListContext ------------------------------------------------------------------
InsightsQLParser::IdentifierListContext::IdentifierListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::NestedIdentifierContext *> InsightsQLParser::IdentifierListContext::nestedIdentifier() {
return getRuleContexts<InsightsQLParser::NestedIdentifierContext>();
}
InsightsQLParser::NestedIdentifierContext* InsightsQLParser::IdentifierListContext::nestedIdentifier(size_t i) {
return getRuleContext<InsightsQLParser::NestedIdentifierContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::IdentifierListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::IdentifierListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::IdentifierListContext::getRuleIndex() const {
return InsightsQLParser::RuleIdentifierList;
}
std::any InsightsQLParser::IdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitIdentifierList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::identifierList() {
IdentifierListContext *_localctx = _tracker.createInstance<IdentifierListContext>(_ctx, getState());
enterRule(_localctx, 8, InsightsQLParser::RuleIdentifierList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(258);
nestedIdentifier();
setState(263);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(259);
match(InsightsQLParser::COMMA);
setState(260);
nestedIdentifier();
}
setState(265);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);
}
setState(267);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(266);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- StatementContext ------------------------------------------------------------------
InsightsQLParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ReturnStmtContext* InsightsQLParser::StatementContext::returnStmt() {
return getRuleContext<InsightsQLParser::ReturnStmtContext>(0);
}
InsightsQLParser::ThrowStmtContext* InsightsQLParser::StatementContext::throwStmt() {
return getRuleContext<InsightsQLParser::ThrowStmtContext>(0);
}
InsightsQLParser::TryCatchStmtContext* InsightsQLParser::StatementContext::tryCatchStmt() {
return getRuleContext<InsightsQLParser::TryCatchStmtContext>(0);
}
InsightsQLParser::IfStmtContext* InsightsQLParser::StatementContext::ifStmt() {
return getRuleContext<InsightsQLParser::IfStmtContext>(0);
}
InsightsQLParser::WhileStmtContext* InsightsQLParser::StatementContext::whileStmt() {
return getRuleContext<InsightsQLParser::WhileStmtContext>(0);
}
InsightsQLParser::ForInStmtContext* InsightsQLParser::StatementContext::forInStmt() {
return getRuleContext<InsightsQLParser::ForInStmtContext>(0);
}
InsightsQLParser::ForStmtContext* InsightsQLParser::StatementContext::forStmt() {
return getRuleContext<InsightsQLParser::ForStmtContext>(0);
}
InsightsQLParser::FuncStmtContext* InsightsQLParser::StatementContext::funcStmt() {
return getRuleContext<InsightsQLParser::FuncStmtContext>(0);
}
InsightsQLParser::BlockContext* InsightsQLParser::StatementContext::block() {
return getRuleContext<InsightsQLParser::BlockContext>(0);
}
InsightsQLParser::ExprStmtContext* InsightsQLParser::StatementContext::exprStmt() {
return getRuleContext<InsightsQLParser::ExprStmtContext>(0);
}
InsightsQLParser::EmptyStmtContext* InsightsQLParser::StatementContext::emptyStmt() {
return getRuleContext<InsightsQLParser::EmptyStmtContext>(0);
}
size_t InsightsQLParser::StatementContext::getRuleIndex() const {
return InsightsQLParser::RuleStatement;
}
std::any InsightsQLParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitStatement(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::StatementContext* InsightsQLParser::statement() {
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
enterRule(_localctx, 10, InsightsQLParser::RuleStatement);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(280);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(269);
returnStmt();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(270);
throwStmt();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(271);
tryCatchStmt();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(272);
ifStmt();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(273);
whileStmt();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(274);
forInStmt();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(275);
forStmt();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(276);
funcStmt();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(277);
block();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(278);
exprStmt();
break;
}
case 11: {
enterOuterAlt(_localctx, 11);
setState(279);
emptyStmt();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ReturnStmtContext ------------------------------------------------------------------
InsightsQLParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ReturnStmtContext::RETURN() {
return getToken(InsightsQLParser::RETURN, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::ReturnStmtContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
tree::TerminalNode* InsightsQLParser::ReturnStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::ReturnStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleReturnStmt;
}
std::any InsightsQLParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitReturnStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ReturnStmtContext* InsightsQLParser::returnStmt() {
ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());
enterRule(_localctx, 12, InsightsQLParser::RuleReturnStmt);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(282);
match(InsightsQLParser::RETURN);
setState(284);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
case 1: {
setState(283);
expression();
break;
}
default:
break;
}
setState(287);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
case 1: {
setState(286);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ThrowStmtContext ------------------------------------------------------------------
InsightsQLParser::ThrowStmtContext::ThrowStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ThrowStmtContext::THROW() {
return getToken(InsightsQLParser::THROW, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::ThrowStmtContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
tree::TerminalNode* InsightsQLParser::ThrowStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::ThrowStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleThrowStmt;
}
std::any InsightsQLParser::ThrowStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitThrowStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ThrowStmtContext* InsightsQLParser::throwStmt() {
ThrowStmtContext *_localctx = _tracker.createInstance<ThrowStmtContext>(_ctx, getState());
enterRule(_localctx, 14, InsightsQLParser::RuleThrowStmt);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(289);
match(InsightsQLParser::THROW);
setState(290);
expression();
setState(292);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
case 1: {
setState(291);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- CatchBlockContext ------------------------------------------------------------------
InsightsQLParser::CatchBlockContext::CatchBlockContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::CatchBlockContext::CATCH() {
return getToken(InsightsQLParser::CATCH, 0);
}
InsightsQLParser::BlockContext* InsightsQLParser::CatchBlockContext::block() {
return getRuleContext<InsightsQLParser::BlockContext>(0);
}
tree::TerminalNode* InsightsQLParser::CatchBlockContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::CatchBlockContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::CatchBlockContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::CatchBlockContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::CatchBlockContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
size_t InsightsQLParser::CatchBlockContext::getRuleIndex() const {
return InsightsQLParser::RuleCatchBlock;
}
std::any InsightsQLParser::CatchBlockContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitCatchBlock(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::CatchBlockContext* InsightsQLParser::catchBlock() {
CatchBlockContext *_localctx = _tracker.createInstance<CatchBlockContext>(_ctx, getState());
enterRule(_localctx, 16, InsightsQLParser::RuleCatchBlock);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(294);
match(InsightsQLParser::CATCH);
setState(303);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LPAREN) {
setState(295);
match(InsightsQLParser::LPAREN);
setState(296);
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchVar = identifier();
setState(299);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COLON) {
setState(297);
match(InsightsQLParser::COLON);
setState(298);
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchType = identifier();
}
setState(301);
match(InsightsQLParser::RPAREN);
}
setState(305);
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchStmt = block();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TryCatchStmtContext ------------------------------------------------------------------
InsightsQLParser::TryCatchStmtContext::TryCatchStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::TryCatchStmtContext::TRY() {
return getToken(InsightsQLParser::TRY, 0);
}
std::vector<InsightsQLParser::BlockContext *> InsightsQLParser::TryCatchStmtContext::block() {
return getRuleContexts<InsightsQLParser::BlockContext>();
}
InsightsQLParser::BlockContext* InsightsQLParser::TryCatchStmtContext::block(size_t i) {
return getRuleContext<InsightsQLParser::BlockContext>(i);
}
std::vector<InsightsQLParser::CatchBlockContext *> InsightsQLParser::TryCatchStmtContext::catchBlock() {
return getRuleContexts<InsightsQLParser::CatchBlockContext>();
}
InsightsQLParser::CatchBlockContext* InsightsQLParser::TryCatchStmtContext::catchBlock(size_t i) {
return getRuleContext<InsightsQLParser::CatchBlockContext>(i);
}
tree::TerminalNode* InsightsQLParser::TryCatchStmtContext::FINALLY() {
return getToken(InsightsQLParser::FINALLY, 0);
}
size_t InsightsQLParser::TryCatchStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleTryCatchStmt;
}
std::any InsightsQLParser::TryCatchStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTryCatchStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TryCatchStmtContext* InsightsQLParser::tryCatchStmt() {
TryCatchStmtContext *_localctx = _tracker.createInstance<TryCatchStmtContext>(_ctx, getState());
enterRule(_localctx, 18, InsightsQLParser::RuleTryCatchStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(307);
match(InsightsQLParser::TRY);
setState(308);
antlrcpp::downCast<TryCatchStmtContext *>(_localctx)->tryStmt = block();
setState(312);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::CATCH) {
setState(309);
catchBlock();
setState(314);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(317);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FINALLY) {
setState(315);
match(InsightsQLParser::FINALLY);
setState(316);
antlrcpp::downCast<TryCatchStmtContext *>(_localctx)->finallyStmt = block();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- IfStmtContext ------------------------------------------------------------------
InsightsQLParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::IfStmtContext::IF() {
return getToken(InsightsQLParser::IF, 0);
}
tree::TerminalNode* InsightsQLParser::IfStmtContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::IfStmtContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
tree::TerminalNode* InsightsQLParser::IfStmtContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<InsightsQLParser::StatementContext *> InsightsQLParser::IfStmtContext::statement() {
return getRuleContexts<InsightsQLParser::StatementContext>();
}
InsightsQLParser::StatementContext* InsightsQLParser::IfStmtContext::statement(size_t i) {
return getRuleContext<InsightsQLParser::StatementContext>(i);
}
tree::TerminalNode* InsightsQLParser::IfStmtContext::ELSE() {
return getToken(InsightsQLParser::ELSE, 0);
}
size_t InsightsQLParser::IfStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleIfStmt;
}
std::any InsightsQLParser::IfStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitIfStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::IfStmtContext* InsightsQLParser::ifStmt() {
IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());
enterRule(_localctx, 20, InsightsQLParser::RuleIfStmt);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(319);
match(InsightsQLParser::IF);
setState(320);
match(InsightsQLParser::LPAREN);
setState(321);
expression();
setState(322);
match(InsightsQLParser::RPAREN);
setState(323);
statement();
setState(326);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx)) {
case 1: {
setState(324);
match(InsightsQLParser::ELSE);
setState(325);
statement();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WhileStmtContext ------------------------------------------------------------------
InsightsQLParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WhileStmtContext::WHILE() {
return getToken(InsightsQLParser::WHILE, 0);
}
tree::TerminalNode* InsightsQLParser::WhileStmtContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::WhileStmtContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
tree::TerminalNode* InsightsQLParser::WhileStmtContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::StatementContext* InsightsQLParser::WhileStmtContext::statement() {
return getRuleContext<InsightsQLParser::StatementContext>(0);
}
tree::TerminalNode* InsightsQLParser::WhileStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::WhileStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleWhileStmt;
}
std::any InsightsQLParser::WhileStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWhileStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WhileStmtContext* InsightsQLParser::whileStmt() {
WhileStmtContext *_localctx = _tracker.createInstance<WhileStmtContext>(_ctx, getState());
enterRule(_localctx, 22, InsightsQLParser::RuleWhileStmt);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(328);
match(InsightsQLParser::WHILE);
setState(329);
match(InsightsQLParser::LPAREN);
setState(330);
expression();
setState(331);
match(InsightsQLParser::RPAREN);
setState(332);
statement();
setState(334);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx)) {
case 1: {
setState(333);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ForStmtContext ------------------------------------------------------------------
InsightsQLParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ForStmtContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
tree::TerminalNode* InsightsQLParser::ForStmtContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ForStmtContext::SEMICOLON() {
return getTokens(InsightsQLParser::SEMICOLON);
}
tree::TerminalNode* InsightsQLParser::ForStmtContext::SEMICOLON(size_t i) {
return getToken(InsightsQLParser::SEMICOLON, i);
}
tree::TerminalNode* InsightsQLParser::ForStmtContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::StatementContext* InsightsQLParser::ForStmtContext::statement() {
return getRuleContext<InsightsQLParser::StatementContext>(0);
}
std::vector<InsightsQLParser::VarDeclContext *> InsightsQLParser::ForStmtContext::varDecl() {
return getRuleContexts<InsightsQLParser::VarDeclContext>();
}
InsightsQLParser::VarDeclContext* InsightsQLParser::ForStmtContext::varDecl(size_t i) {
return getRuleContext<InsightsQLParser::VarDeclContext>(i);
}
std::vector<InsightsQLParser::VarAssignmentContext *> InsightsQLParser::ForStmtContext::varAssignment() {
return getRuleContexts<InsightsQLParser::VarAssignmentContext>();
}
InsightsQLParser::VarAssignmentContext* InsightsQLParser::ForStmtContext::varAssignment(size_t i) {
return getRuleContext<InsightsQLParser::VarAssignmentContext>(i);
}
std::vector<InsightsQLParser::ExpressionContext *> InsightsQLParser::ForStmtContext::expression() {
return getRuleContexts<InsightsQLParser::ExpressionContext>();
}
InsightsQLParser::ExpressionContext* InsightsQLParser::ForStmtContext::expression(size_t i) {
return getRuleContext<InsightsQLParser::ExpressionContext>(i);
}
size_t InsightsQLParser::ForStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleForStmt;
}
std::any InsightsQLParser::ForStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitForStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ForStmtContext* InsightsQLParser::forStmt() {
ForStmtContext *_localctx = _tracker.createInstance<ForStmtContext>(_ctx, getState());
enterRule(_localctx, 24, InsightsQLParser::RuleForStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(336);
match(InsightsQLParser::FOR);
setState(337);
match(InsightsQLParser::LPAREN);
setState(341);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
case 1: {
setState(338);
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerVarDeclr = varDecl();
break;
}
case 2: {
setState(339);
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerVarAssignment = varAssignment();
break;
}
case 3: {
setState(340);
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerExpression = expression();
break;
}
default:
break;
}
setState(343);
match(InsightsQLParser::SEMICOLON);
setState(345);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(344);
antlrcpp::downCast<ForStmtContext *>(_localctx)->condition = expression();
}
setState(347);
match(InsightsQLParser::SEMICOLON);
setState(351);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
case 1: {
setState(348);
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementVarDeclr = varDecl();
break;
}
case 2: {
setState(349);
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementVarAssignment = varAssignment();
break;
}
case 3: {
setState(350);
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementExpression = expression();
break;
}
default:
break;
}
setState(353);
match(InsightsQLParser::RPAREN);
setState(354);
statement();
setState(356);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
case 1: {
setState(355);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ForInStmtContext ------------------------------------------------------------------
InsightsQLParser::ForInStmtContext::ForInStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::LET() {
return getToken(InsightsQLParser::LET, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ForInStmtContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ForInStmtContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::IN() {
return getToken(InsightsQLParser::IN, 0);
}
InsightsQLParser::ExpressionContext* InsightsQLParser::ForInStmtContext::expression() {
return getRuleContext<InsightsQLParser::ExpressionContext>(0);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::StatementContext* InsightsQLParser::ForInStmtContext::statement() {
return getRuleContext<InsightsQLParser::StatementContext>(0);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::COMMA() {
return getToken(InsightsQLParser::COMMA, 0);
}
tree::TerminalNode* InsightsQLParser::ForInStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::ForInStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleForInStmt;
}
std::any InsightsQLParser::ForInStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitForInStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ForInStmtContext* InsightsQLParser::forInStmt() {
ForInStmtContext *_localctx = _tracker.createInstance<ForInStmtContext>(_ctx, getState());
enterRule(_localctx, 26, InsightsQLParser::RuleForInStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(358);
match(InsightsQLParser::FOR);
setState(359);
match(InsightsQLParser::LPAREN);
setState(360);
match(InsightsQLParser::LET);
setState(361);
identifier();
setState(364);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(362);
match(InsightsQLParser::COMMA);
setState(363);
identifier();
}
setState(366);
match(InsightsQLParser::IN);
setState(367);
expression();
setState(368);
match(InsightsQLParser::RPAREN);
setState(369);
statement();
setState(371);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx)) {
case 1: {
setState(370);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- FuncStmtContext ------------------------------------------------------------------
InsightsQLParser::FuncStmtContext::FuncStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::IdentifierContext* InsightsQLParser::FuncStmtContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::FuncStmtContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::FuncStmtContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::BlockContext* InsightsQLParser::FuncStmtContext::block() {
return getRuleContext<InsightsQLParser::BlockContext>(0);
}
tree::TerminalNode* InsightsQLParser::FuncStmtContext::FN() {
return getToken(InsightsQLParser::FN, 0);
}
tree::TerminalNode* InsightsQLParser::FuncStmtContext::FUN() {
return getToken(InsightsQLParser::FUN, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::FuncStmtContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
size_t InsightsQLParser::FuncStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleFuncStmt;
}
std::any InsightsQLParser::FuncStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFuncStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::FuncStmtContext* InsightsQLParser::funcStmt() {
FuncStmtContext *_localctx = _tracker.createInstance<FuncStmtContext>(_ctx, getState());
enterRule(_localctx, 28, InsightsQLParser::RuleFuncStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(373);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::FN
|| _la == InsightsQLParser::FUN)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(374);
identifier();
setState(375);
match(InsightsQLParser::LPAREN);
setState(377);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -22520283327905794) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576778619) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 107) != 0)) {
setState(376);
identifierList();
}
setState(379);
match(InsightsQLParser::RPAREN);
setState(380);
block();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- VarAssignmentContext ------------------------------------------------------------------
InsightsQLParser::VarAssignmentContext::VarAssignmentContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ExpressionContext *> InsightsQLParser::VarAssignmentContext::expression() {
return getRuleContexts<InsightsQLParser::ExpressionContext>();
}
InsightsQLParser::ExpressionContext* InsightsQLParser::VarAssignmentContext::expression(size_t i) {
return getRuleContext<InsightsQLParser::ExpressionContext>(i);
}
tree::TerminalNode* InsightsQLParser::VarAssignmentContext::COLONEQUALS() {
return getToken(InsightsQLParser::COLONEQUALS, 0);
}
size_t InsightsQLParser::VarAssignmentContext::getRuleIndex() const {
return InsightsQLParser::RuleVarAssignment;
}
std::any InsightsQLParser::VarAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitVarAssignment(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::VarAssignmentContext* InsightsQLParser::varAssignment() {
VarAssignmentContext *_localctx = _tracker.createInstance<VarAssignmentContext>(_ctx, getState());
enterRule(_localctx, 30, InsightsQLParser::RuleVarAssignment);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(382);
expression();
setState(383);
match(InsightsQLParser::COLONEQUALS);
setState(384);
expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ExprStmtContext ------------------------------------------------------------------
InsightsQLParser::ExprStmtContext::ExprStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ExpressionContext *> InsightsQLParser::ExprStmtContext::expression() {
return getRuleContexts<InsightsQLParser::ExpressionContext>();
}
InsightsQLParser::ExpressionContext* InsightsQLParser::ExprStmtContext::expression(size_t i) {
return getRuleContext<InsightsQLParser::ExpressionContext>(i);
}
tree::TerminalNode* InsightsQLParser::ExprStmtContext::COLONEQUALS() {
return getToken(InsightsQLParser::COLONEQUALS, 0);
}
tree::TerminalNode* InsightsQLParser::ExprStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::ExprStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleExprStmt;
}
std::any InsightsQLParser::ExprStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitExprStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ExprStmtContext* InsightsQLParser::exprStmt() {
ExprStmtContext *_localctx = _tracker.createInstance<ExprStmtContext>(_ctx, getState());
enterRule(_localctx, 32, InsightsQLParser::RuleExprStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(386);
expression();
setState(389);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COLONEQUALS) {
setState(387);
match(InsightsQLParser::COLONEQUALS);
setState(388);
expression();
}
setState(392);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
case 1: {
setState(391);
match(InsightsQLParser::SEMICOLON);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- EmptyStmtContext ------------------------------------------------------------------
InsightsQLParser::EmptyStmtContext::EmptyStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::EmptyStmtContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::EmptyStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleEmptyStmt;
}
std::any InsightsQLParser::EmptyStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitEmptyStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::EmptyStmtContext* InsightsQLParser::emptyStmt() {
EmptyStmtContext *_localctx = _tracker.createInstance<EmptyStmtContext>(_ctx, getState());
enterRule(_localctx, 34, InsightsQLParser::RuleEmptyStmt);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(394);
match(InsightsQLParser::SEMICOLON);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- BlockContext ------------------------------------------------------------------
InsightsQLParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::BlockContext::LBRACE() {
return getToken(InsightsQLParser::LBRACE, 0);
}
tree::TerminalNode* InsightsQLParser::BlockContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
std::vector<InsightsQLParser::DeclarationContext *> InsightsQLParser::BlockContext::declaration() {
return getRuleContexts<InsightsQLParser::DeclarationContext>();
}
InsightsQLParser::DeclarationContext* InsightsQLParser::BlockContext::declaration(size_t i) {
return getRuleContext<InsightsQLParser::DeclarationContext>(i);
}
size_t InsightsQLParser::BlockContext::getRuleIndex() const {
return InsightsQLParser::RuleBlock;
}
std::any InsightsQLParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitBlock(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::BlockContext* InsightsQLParser::block() {
BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
enterRule(_localctx, 36, InsightsQLParser::RuleBlock);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(396);
match(InsightsQLParser::LBRACE);
setState(400);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18014415957803010) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 64)) & -9) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 128)) & 578995371586535383) != 0)) {
setState(397);
declaration();
setState(402);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(403);
match(InsightsQLParser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KvPairContext ------------------------------------------------------------------
InsightsQLParser::KvPairContext::KvPairContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ExpressionContext *> InsightsQLParser::KvPairContext::expression() {
return getRuleContexts<InsightsQLParser::ExpressionContext>();
}
InsightsQLParser::ExpressionContext* InsightsQLParser::KvPairContext::expression(size_t i) {
return getRuleContext<InsightsQLParser::ExpressionContext>(i);
}
tree::TerminalNode* InsightsQLParser::KvPairContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
size_t InsightsQLParser::KvPairContext::getRuleIndex() const {
return InsightsQLParser::RuleKvPair;
}
std::any InsightsQLParser::KvPairContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKvPair(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KvPairContext* InsightsQLParser::kvPair() {
KvPairContext *_localctx = _tracker.createInstance<KvPairContext>(_ctx, getState());
enterRule(_localctx, 38, InsightsQLParser::RuleKvPair);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(405);
expression();
setState(406);
match(InsightsQLParser::COLON);
setState(407);
expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KvPairListContext ------------------------------------------------------------------
InsightsQLParser::KvPairListContext::KvPairListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::KvPairContext *> InsightsQLParser::KvPairListContext::kvPair() {
return getRuleContexts<InsightsQLParser::KvPairContext>();
}
InsightsQLParser::KvPairContext* InsightsQLParser::KvPairListContext::kvPair(size_t i) {
return getRuleContext<InsightsQLParser::KvPairContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::KvPairListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::KvPairListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::KvPairListContext::getRuleIndex() const {
return InsightsQLParser::RuleKvPairList;
}
std::any InsightsQLParser::KvPairListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKvPairList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KvPairListContext* InsightsQLParser::kvPairList() {
KvPairListContext *_localctx = _tracker.createInstance<KvPairListContext>(_ctx, getState());
enterRule(_localctx, 40, InsightsQLParser::RuleKvPairList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(409);
kvPair();
setState(414);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(410);
match(InsightsQLParser::COMMA);
setState(411);
kvPair();
}
setState(416);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
}
setState(418);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(417);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectContext ------------------------------------------------------------------
InsightsQLParser::SelectContext::SelectContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::SelectContext::EOF() {
return getToken(InsightsQLParser::EOF, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::SelectContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
InsightsQLParser::SelectStmtContext* InsightsQLParser::SelectContext::selectStmt() {
return getRuleContext<InsightsQLParser::SelectStmtContext>(0);
}
InsightsQLParser::InsightsqlxTagElementContext* InsightsQLParser::SelectContext::insightsqlxTagElement() {
return getRuleContext<InsightsQLParser::InsightsqlxTagElementContext>(0);
}
tree::TerminalNode* InsightsQLParser::SelectContext::SEMICOLON() {
return getToken(InsightsQLParser::SEMICOLON, 0);
}
size_t InsightsQLParser::SelectContext::getRuleIndex() const {
return InsightsQLParser::RuleSelect;
}
std::any InsightsQLParser::SelectContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelect(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectContext* InsightsQLParser::select() {
SelectContext *_localctx = _tracker.createInstance<SelectContext>(_ctx, getState());
enterRule(_localctx, 42, InsightsQLParser::RuleSelect);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(423);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
case 1: {
setState(420);
selectSetStmt();
break;
}
case 2: {
setState(421);
selectStmt();
break;
}
case 3: {
setState(422);
insightsqlxTagElement();
break;
}
default:
break;
}
setState(426);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::SEMICOLON) {
setState(425);
match(InsightsQLParser::SEMICOLON);
}
setState(428);
match(InsightsQLParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectStmtWithParensContext ------------------------------------------------------------------
InsightsQLParser::SelectStmtWithParensContext::SelectStmtWithParensContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::SelectStmtContext* InsightsQLParser::SelectStmtWithParensContext::selectStmt() {
return getRuleContext<InsightsQLParser::SelectStmtContext>(0);
}
InsightsQLParser::WithClauseContext* InsightsQLParser::SelectStmtWithParensContext::withClause() {
return getRuleContext<InsightsQLParser::WithClauseContext>(0);
}
tree::TerminalNode* InsightsQLParser::SelectStmtWithParensContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::SelectStmtWithParensContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
tree::TerminalNode* InsightsQLParser::SelectStmtWithParensContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::PlaceholderContext* InsightsQLParser::SelectStmtWithParensContext::placeholder() {
return getRuleContext<InsightsQLParser::PlaceholderContext>(0);
}
size_t InsightsQLParser::SelectStmtWithParensContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectStmtWithParens;
}
std::any InsightsQLParser::SelectStmtWithParensContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectStmtWithParens(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectStmtWithParensContext* InsightsQLParser::selectStmtWithParens() {
SelectStmtWithParensContext *_localctx = _tracker.createInstance<SelectStmtWithParensContext>(_ctx, getState());
enterRule(_localctx, 44, InsightsQLParser::RuleSelectStmtWithParens);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(441);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(430);
selectStmt();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(431);
withClause();
setState(432);
match(InsightsQLParser::LPAREN);
setState(433);
selectSetStmt();
setState(434);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(436);
match(InsightsQLParser::LPAREN);
setState(437);
selectSetStmt();
setState(438);
match(InsightsQLParser::RPAREN);
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(440);
placeholder();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SubsequentSelectSetClauseContext ------------------------------------------------------------------
InsightsQLParser::SubsequentSelectSetClauseContext::SubsequentSelectSetClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::SelectStmtWithParensContext* InsightsQLParser::SubsequentSelectSetClauseContext::selectStmtWithParens() {
return getRuleContext<InsightsQLParser::SelectStmtWithParensContext>(0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::EXCEPT() {
return getToken(InsightsQLParser::EXCEPT, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::UNION() {
return getToken(InsightsQLParser::UNION, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::INTERSECT() {
return getToken(InsightsQLParser::INTERSECT, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
tree::TerminalNode* InsightsQLParser::SubsequentSelectSetClauseContext::NAME() {
return getToken(InsightsQLParser::NAME, 0);
}
size_t InsightsQLParser::SubsequentSelectSetClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleSubsequentSelectSetClause;
}
std::any InsightsQLParser::SubsequentSelectSetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSubsequentSelectSetClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SubsequentSelectSetClauseContext* InsightsQLParser::subsequentSelectSetClause() {
SubsequentSelectSetClauseContext *_localctx = _tracker.createInstance<SubsequentSelectSetClauseContext>(_ctx, getState());
enterRule(_localctx, 46, InsightsQLParser::RuleSubsequentSelectSetClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(488);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
case 1: {
setState(443);
match(InsightsQLParser::EXCEPT);
setState(444);
match(InsightsQLParser::ALL);
setState(447);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(445);
match(InsightsQLParser::BY);
setState(446);
match(InsightsQLParser::NAME);
}
break;
}
case 2: {
setState(449);
match(InsightsQLParser::EXCEPT);
setState(452);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(450);
match(InsightsQLParser::BY);
setState(451);
match(InsightsQLParser::NAME);
}
break;
}
case 3: {
setState(454);
match(InsightsQLParser::UNION);
setState(455);
match(InsightsQLParser::ALL);
setState(458);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(456);
match(InsightsQLParser::BY);
setState(457);
match(InsightsQLParser::NAME);
}
break;
}
case 4: {
setState(460);
match(InsightsQLParser::UNION);
setState(461);
match(InsightsQLParser::DISTINCT);
setState(464);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(462);
match(InsightsQLParser::BY);
setState(463);
match(InsightsQLParser::NAME);
}
break;
}
case 5: {
setState(466);
match(InsightsQLParser::UNION);
setState(469);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(467);
match(InsightsQLParser::BY);
setState(468);
match(InsightsQLParser::NAME);
}
break;
}
case 6: {
setState(471);
match(InsightsQLParser::INTERSECT);
setState(472);
match(InsightsQLParser::ALL);
setState(475);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(473);
match(InsightsQLParser::BY);
setState(474);
match(InsightsQLParser::NAME);
}
break;
}
case 7: {
setState(477);
match(InsightsQLParser::INTERSECT);
setState(478);
match(InsightsQLParser::DISTINCT);
setState(481);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(479);
match(InsightsQLParser::BY);
setState(480);
match(InsightsQLParser::NAME);
}
break;
}
case 8: {
setState(483);
match(InsightsQLParser::INTERSECT);
setState(486);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::BY) {
setState(484);
match(InsightsQLParser::BY);
setState(485);
match(InsightsQLParser::NAME);
}
break;
}
default:
break;
}
setState(490);
selectStmtWithParens();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectSetStmtContext ------------------------------------------------------------------
InsightsQLParser::SelectSetStmtContext::SelectSetStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::SelectStmtWithParensContext* InsightsQLParser::SelectSetStmtContext::selectStmtWithParens() {
return getRuleContext<InsightsQLParser::SelectStmtWithParensContext>(0);
}
std::vector<InsightsQLParser::SubsequentSelectSetClauseContext *> InsightsQLParser::SelectSetStmtContext::subsequentSelectSetClause() {
return getRuleContexts<InsightsQLParser::SubsequentSelectSetClauseContext>();
}
InsightsQLParser::SubsequentSelectSetClauseContext* InsightsQLParser::SelectSetStmtContext::subsequentSelectSetClause(size_t i) {
return getRuleContext<InsightsQLParser::SubsequentSelectSetClauseContext>(i);
}
InsightsQLParser::OrderByClauseContext* InsightsQLParser::SelectSetStmtContext::orderByClause() {
return getRuleContext<InsightsQLParser::OrderByClauseContext>(0);
}
InsightsQLParser::LimitAndOffsetClauseOptionalContext* InsightsQLParser::SelectSetStmtContext::limitAndOffsetClauseOptional() {
return getRuleContext<InsightsQLParser::LimitAndOffsetClauseOptionalContext>(0);
}
size_t InsightsQLParser::SelectSetStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectSetStmt;
}
std::any InsightsQLParser::SelectSetStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectSetStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::selectSetStmt() {
SelectSetStmtContext *_localctx = _tracker.createInstance<SelectSetStmtContext>(_ctx, getState());
enterRule(_localctx, 48, InsightsQLParser::RuleSelectSetStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(492);
selectStmtWithParens();
setState(496);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::EXCEPT
|| _la == InsightsQLParser::INTERSECT || _la == InsightsQLParser::UNION) {
setState(493);
subsequentSelectSetClause();
setState(498);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(500);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::ORDER) {
setState(499);
orderByClause();
}
setState(503);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LIMIT
|| _la == InsightsQLParser::OFFSET) {
setState(502);
limitAndOffsetClauseOptional();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- LimitAndOffsetClauseOptionalContext ------------------------------------------------------------------
InsightsQLParser::LimitAndOffsetClauseOptionalContext::LimitAndOffsetClauseOptionalContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::LIMIT() {
return getToken(InsightsQLParser::LIMIT, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::LimitAndOffsetClauseOptionalContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::LimitAndOffsetClauseOptionalContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::PERCENT() {
return getToken(InsightsQLParser::PERCENT, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::COMMA() {
return getToken(InsightsQLParser::COMMA, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::TIES() {
return getToken(InsightsQLParser::TIES, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseOptionalContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
size_t InsightsQLParser::LimitAndOffsetClauseOptionalContext::getRuleIndex() const {
return InsightsQLParser::RuleLimitAndOffsetClauseOptional;
}
std::any InsightsQLParser::LimitAndOffsetClauseOptionalContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitLimitAndOffsetClauseOptional(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::LimitAndOffsetClauseOptionalContext* InsightsQLParser::limitAndOffsetClauseOptional() {
LimitAndOffsetClauseOptionalContext *_localctx = _tracker.createInstance<LimitAndOffsetClauseOptionalContext>(_ctx, getState());
enterRule(_localctx, 50, InsightsQLParser::RuleLimitAndOffsetClauseOptional);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(532);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(505);
match(InsightsQLParser::LIMIT);
setState(506);
columnExpr(0);
setState(508);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PERCENT) {
setState(507);
match(InsightsQLParser::PERCENT);
}
setState(512);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(510);
match(InsightsQLParser::COMMA);
setState(511);
columnExpr(0);
}
setState(516);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(514);
match(InsightsQLParser::WITH);
setState(515);
match(InsightsQLParser::TIES);
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(518);
match(InsightsQLParser::LIMIT);
setState(519);
columnExpr(0);
setState(521);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PERCENT) {
setState(520);
match(InsightsQLParser::PERCENT);
}
setState(525);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(523);
match(InsightsQLParser::WITH);
setState(524);
match(InsightsQLParser::TIES);
}
setState(527);
match(InsightsQLParser::OFFSET);
setState(528);
columnExpr(0);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(530);
match(InsightsQLParser::OFFSET);
setState(531);
columnExpr(0);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectStmtContext ------------------------------------------------------------------
InsightsQLParser::SelectStmtContext::SelectStmtContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::SELECT() {
return getToken(InsightsQLParser::SELECT, 0);
}
InsightsQLParser::SelectColumnExprListBeforeFromContext* InsightsQLParser::SelectStmtContext::selectColumnExprListBeforeFrom() {
return getRuleContext<InsightsQLParser::SelectColumnExprListBeforeFromContext>(0);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
InsightsQLParser::TopClauseContext* InsightsQLParser::SelectStmtContext::topClause() {
return getRuleContext<InsightsQLParser::TopClauseContext>(0);
}
InsightsQLParser::ArrayJoinClauseContext* InsightsQLParser::SelectStmtContext::arrayJoinClause() {
return getRuleContext<InsightsQLParser::ArrayJoinClauseContext>(0);
}
InsightsQLParser::PrewhereClauseContext* InsightsQLParser::SelectStmtContext::prewhereClause() {
return getRuleContext<InsightsQLParser::PrewhereClauseContext>(0);
}
std::vector<InsightsQLParser::SampleClauseContext *> InsightsQLParser::SelectStmtContext::sampleClause() {
return getRuleContexts<InsightsQLParser::SampleClauseContext>();
}
InsightsQLParser::SampleClauseContext* InsightsQLParser::SelectStmtContext::sampleClause(size_t i) {
return getRuleContext<InsightsQLParser::SampleClauseContext>(i);
}
InsightsQLParser::GroupByClauseContext* InsightsQLParser::SelectStmtContext::groupByClause() {
return getRuleContext<InsightsQLParser::GroupByClauseContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::SelectStmtContext::WITH() {
return getTokens(InsightsQLParser::WITH);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::WITH(size_t i) {
return getToken(InsightsQLParser::WITH, i);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::TOTALS() {
return getToken(InsightsQLParser::TOTALS, 0);
}
InsightsQLParser::HavingClauseContext* InsightsQLParser::SelectStmtContext::havingClause() {
return getRuleContext<InsightsQLParser::HavingClauseContext>(0);
}
InsightsQLParser::QualifyClauseContext* InsightsQLParser::SelectStmtContext::qualifyClause() {
return getRuleContext<InsightsQLParser::QualifyClauseContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::SelectStmtContext::USING() {
return getTokens(InsightsQLParser::USING);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::USING(size_t i) {
return getToken(InsightsQLParser::USING, i);
}
InsightsQLParser::WindowClauseContext* InsightsQLParser::SelectStmtContext::windowClause() {
return getRuleContext<InsightsQLParser::WindowClauseContext>(0);
}
InsightsQLParser::OrderByClauseContext* InsightsQLParser::SelectStmtContext::orderByClause() {
return getRuleContext<InsightsQLParser::OrderByClauseContext>(0);
}
InsightsQLParser::LimitByClauseContext* InsightsQLParser::SelectStmtContext::limitByClause() {
return getRuleContext<InsightsQLParser::LimitByClauseContext>(0);
}
InsightsQLParser::LimitAndOffsetClauseContext* InsightsQLParser::SelectStmtContext::limitAndOffsetClause() {
return getRuleContext<InsightsQLParser::LimitAndOffsetClauseContext>(0);
}
InsightsQLParser::OffsetOnlyClauseContext* InsightsQLParser::SelectStmtContext::offsetOnlyClause() {
return getRuleContext<InsightsQLParser::OffsetOnlyClauseContext>(0);
}
InsightsQLParser::SettingsClauseContext* InsightsQLParser::SelectStmtContext::settingsClause() {
return getRuleContext<InsightsQLParser::SettingsClauseContext>(0);
}
InsightsQLParser::WithClauseContext* InsightsQLParser::SelectStmtContext::withClause() {
return getRuleContext<InsightsQLParser::WithClauseContext>(0);
}
InsightsQLParser::FromClauseContext* InsightsQLParser::SelectStmtContext::fromClause() {
return getRuleContext<InsightsQLParser::FromClauseContext>(0);
}
InsightsQLParser::WhereClauseContext* InsightsQLParser::SelectStmtContext::whereClause() {
return getRuleContext<InsightsQLParser::WhereClauseContext>(0);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::CUBE() {
return getToken(InsightsQLParser::CUBE, 0);
}
tree::TerminalNode* InsightsQLParser::SelectStmtContext::ROLLUP() {
return getToken(InsightsQLParser::ROLLUP, 0);
}
size_t InsightsQLParser::SelectStmtContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectStmt;
}
std::any InsightsQLParser::SelectStmtContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectStmt(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectStmtContext* InsightsQLParser::selectStmt() {
SelectStmtContext *_localctx = _tracker.createInstance<SelectStmtContext>(_ctx, getState());
enterRule(_localctx, 52, InsightsQLParser::RuleSelectStmt);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(535);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(534);
antlrcpp::downCast<SelectStmtContext *>(_localctx)->with = withClause();
}
setState(537);
match(InsightsQLParser::SELECT);
setState(539);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
case 1: {
setState(538);
match(InsightsQLParser::DISTINCT);
break;
}
default:
break;
}
setState(542);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 50, _ctx)) {
case 1: {
setState(541);
topClause();
break;
}
default:
break;
}
setState(544);
antlrcpp::downCast<SelectStmtContext *>(_localctx)->columns = selectColumnExprListBeforeFrom();
setState(546);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FROM) {
setState(545);
antlrcpp::downCast<SelectStmtContext *>(_localctx)->from = fromClause();
}
setState(549);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -9214364837600034784) != 0)) {
setState(548);
arrayJoinClause();
}
setState(552);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PREWHERE) {
setState(551);
prewhereClause();
}
setState(555);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WHERE) {
setState(554);
antlrcpp::downCast<SelectStmtContext *>(_localctx)->where = whereClause();
}
setState(561);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
case 1: {
setState(558);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::USING) {
setState(557);
match(InsightsQLParser::USING);
}
setState(560);
sampleClause();
break;
}
default:
break;
}
setState(564);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::GROUP) {
setState(563);
groupByClause();
}
setState(568);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
case 1: {
setState(566);
match(InsightsQLParser::WITH);
setState(567);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::CUBE || _la == InsightsQLParser::ROLLUP)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
break;
}
setState(572);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(570);
match(InsightsQLParser::WITH);
setState(571);
match(InsightsQLParser::TOTALS);
}
setState(575);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::HAVING) {
setState(574);
havingClause();
}
setState(578);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::QUALIFY) {
setState(577);
qualifyClause();
}
setState(582);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::USING) {
setState(580);
match(InsightsQLParser::USING);
setState(581);
sampleClause();
}
setState(585);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WINDOW) {
setState(584);
windowClause();
}
setState(588);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx)) {
case 1: {
setState(587);
orderByClause();
break;
}
default:
break;
}
setState(591);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
case 1: {
setState(590);
limitByClause();
break;
}
default:
break;
}
setState(595);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
case 1: {
setState(593);
limitAndOffsetClause();
break;
}
case 2: {
setState(594);
offsetOnlyClause();
break;
}
default:
break;
}
setState(598);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::SETTINGS) {
setState(597);
settingsClause();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithClauseContext ------------------------------------------------------------------
InsightsQLParser::WithClauseContext::WithClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WithClauseContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
InsightsQLParser::WithExprListContext* InsightsQLParser::WithClauseContext::withExprList() {
return getRuleContext<InsightsQLParser::WithExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::WithClauseContext::RECURSIVE() {
return getToken(InsightsQLParser::RECURSIVE, 0);
}
size_t InsightsQLParser::WithClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWithClause;
}
std::any InsightsQLParser::WithClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithClauseContext* InsightsQLParser::withClause() {
WithClauseContext *_localctx = _tracker.createInstance<WithClauseContext>(_ctx, getState());
enterRule(_localctx, 54, InsightsQLParser::RuleWithClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(600);
match(InsightsQLParser::WITH);
setState(602);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
case 1: {
setState(601);
match(InsightsQLParser::RECURSIVE);
break;
}
default:
break;
}
setState(604);
withExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TopClauseContext ------------------------------------------------------------------
InsightsQLParser::TopClauseContext::TopClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::TopClauseContext::TOP() {
return getToken(InsightsQLParser::TOP, 0);
}
tree::TerminalNode* InsightsQLParser::TopClauseContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::TopClauseContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::TopClauseContext::TIES() {
return getToken(InsightsQLParser::TIES, 0);
}
size_t InsightsQLParser::TopClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleTopClause;
}
std::any InsightsQLParser::TopClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTopClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TopClauseContext* InsightsQLParser::topClause() {
TopClauseContext *_localctx = _tracker.createInstance<TopClauseContext>(_ctx, getState());
enterRule(_localctx, 56, InsightsQLParser::RuleTopClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(606);
match(InsightsQLParser::TOP);
setState(607);
match(InsightsQLParser::DECIMAL_LITERAL);
setState(610);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
case 1: {
setState(608);
match(InsightsQLParser::WITH);
setState(609);
match(InsightsQLParser::TIES);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- FromClauseContext ------------------------------------------------------------------
InsightsQLParser::FromClauseContext::FromClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::FromClauseContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
InsightsQLParser::JoinExprContext* InsightsQLParser::FromClauseContext::joinExpr() {
return getRuleContext<InsightsQLParser::JoinExprContext>(0);
}
size_t InsightsQLParser::FromClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleFromClause;
}
std::any InsightsQLParser::FromClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFromClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::FromClauseContext* InsightsQLParser::fromClause() {
FromClauseContext *_localctx = _tracker.createInstance<FromClauseContext>(_ctx, getState());
enterRule(_localctx, 58, InsightsQLParser::RuleFromClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(612);
match(InsightsQLParser::FROM);
setState(613);
joinExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ArrayJoinClauseContext ------------------------------------------------------------------
InsightsQLParser::ArrayJoinClauseContext::ArrayJoinClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ArrayJoinClauseContext::ARRAY() {
return getToken(InsightsQLParser::ARRAY, 0);
}
tree::TerminalNode* InsightsQLParser::ArrayJoinClauseContext::JOIN() {
return getToken(InsightsQLParser::JOIN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ArrayJoinClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ArrayJoinClauseContext::LEFT() {
return getToken(InsightsQLParser::LEFT, 0);
}
tree::TerminalNode* InsightsQLParser::ArrayJoinClauseContext::INNER() {
return getToken(InsightsQLParser::INNER, 0);
}
size_t InsightsQLParser::ArrayJoinClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleArrayJoinClause;
}
std::any InsightsQLParser::ArrayJoinClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitArrayJoinClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ArrayJoinClauseContext* InsightsQLParser::arrayJoinClause() {
ArrayJoinClauseContext *_localctx = _tracker.createInstance<ArrayJoinClauseContext>(_ctx, getState());
enterRule(_localctx, 60, InsightsQLParser::RuleArrayJoinClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(616);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::INNER
|| _la == InsightsQLParser::LEFT) {
setState(615);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::INNER
|| _la == InsightsQLParser::LEFT)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(618);
match(InsightsQLParser::ARRAY);
setState(619);
match(InsightsQLParser::JOIN);
setState(620);
columnExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WindowClauseContext ------------------------------------------------------------------
InsightsQLParser::WindowClauseContext::WindowClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WindowClauseContext::WINDOW() {
return getToken(InsightsQLParser::WINDOW, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::WindowClauseContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::WindowClauseContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WindowClauseContext::AS() {
return getTokens(InsightsQLParser::AS);
}
tree::TerminalNode* InsightsQLParser::WindowClauseContext::AS(size_t i) {
return getToken(InsightsQLParser::AS, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WindowClauseContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::WindowClauseContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
std::vector<InsightsQLParser::WindowExprContext *> InsightsQLParser::WindowClauseContext::windowExpr() {
return getRuleContexts<InsightsQLParser::WindowExprContext>();
}
InsightsQLParser::WindowExprContext* InsightsQLParser::WindowClauseContext::windowExpr(size_t i) {
return getRuleContext<InsightsQLParser::WindowExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WindowClauseContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::WindowClauseContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WindowClauseContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::WindowClauseContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::WindowClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWindowClause;
}
std::any InsightsQLParser::WindowClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWindowClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WindowClauseContext* InsightsQLParser::windowClause() {
WindowClauseContext *_localctx = _tracker.createInstance<WindowClauseContext>(_ctx, getState());
enterRule(_localctx, 62, InsightsQLParser::RuleWindowClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(622);
match(InsightsQLParser::WINDOW);
setState(623);
identifier();
setState(624);
match(InsightsQLParser::AS);
setState(625);
match(InsightsQLParser::LPAREN);
setState(626);
windowExpr();
setState(627);
match(InsightsQLParser::RPAREN);
setState(637);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(628);
match(InsightsQLParser::COMMA);
setState(629);
identifier();
setState(630);
match(InsightsQLParser::AS);
setState(631);
match(InsightsQLParser::LPAREN);
setState(632);
windowExpr();
setState(633);
match(InsightsQLParser::RPAREN);
setState(639);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- PrewhereClauseContext ------------------------------------------------------------------
InsightsQLParser::PrewhereClauseContext::PrewhereClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::PrewhereClauseContext::PREWHERE() {
return getToken(InsightsQLParser::PREWHERE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::PrewhereClauseContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::PrewhereClauseContext::getRuleIndex() const {
return InsightsQLParser::RulePrewhereClause;
}
std::any InsightsQLParser::PrewhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitPrewhereClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::PrewhereClauseContext* InsightsQLParser::prewhereClause() {
PrewhereClauseContext *_localctx = _tracker.createInstance<PrewhereClauseContext>(_ctx, getState());
enterRule(_localctx, 64, InsightsQLParser::RulePrewhereClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(640);
match(InsightsQLParser::PREWHERE);
setState(641);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WhereClauseContext ------------------------------------------------------------------
InsightsQLParser::WhereClauseContext::WhereClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WhereClauseContext::WHERE() {
return getToken(InsightsQLParser::WHERE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::WhereClauseContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::WhereClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWhereClause;
}
std::any InsightsQLParser::WhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWhereClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WhereClauseContext* InsightsQLParser::whereClause() {
WhereClauseContext *_localctx = _tracker.createInstance<WhereClauseContext>(_ctx, getState());
enterRule(_localctx, 66, InsightsQLParser::RuleWhereClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(643);
match(InsightsQLParser::WHERE);
setState(644);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- GroupByClauseContext ------------------------------------------------------------------
InsightsQLParser::GroupByClauseContext::GroupByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::GROUP() {
return getToken(InsightsQLParser::GROUP, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::GroupByClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::GROUPING() {
return getToken(InsightsQLParser::GROUPING, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::SETS() {
return getToken(InsightsQLParser::SETS, 0);
}
InsightsQLParser::GroupingSetListContext* InsightsQLParser::GroupByClauseContext::groupingSetList() {
return getRuleContext<InsightsQLParser::GroupingSetListContext>(0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::CUBE() {
return getToken(InsightsQLParser::CUBE, 0);
}
tree::TerminalNode* InsightsQLParser::GroupByClauseContext::ROLLUP() {
return getToken(InsightsQLParser::ROLLUP, 0);
}
size_t InsightsQLParser::GroupByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleGroupByClause;
}
std::any InsightsQLParser::GroupByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitGroupByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::GroupByClauseContext* InsightsQLParser::groupByClause() {
GroupByClauseContext *_localctx = _tracker.createInstance<GroupByClauseContext>(_ctx, getState());
enterRule(_localctx, 68, InsightsQLParser::RuleGroupByClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(646);
match(InsightsQLParser::GROUP);
setState(647);
match(InsightsQLParser::BY);
setState(661);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 72, _ctx)) {
case 1: {
setState(648);
match(InsightsQLParser::ALL);
break;
}
case 2: {
setState(649);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::CUBE || _la == InsightsQLParser::ROLLUP)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(650);
match(InsightsQLParser::LPAREN);
setState(651);
columnExprList();
setState(652);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
setState(654);
match(InsightsQLParser::GROUPING);
setState(655);
match(InsightsQLParser::SETS);
setState(656);
match(InsightsQLParser::LPAREN);
setState(657);
groupingSetList();
setState(658);
match(InsightsQLParser::RPAREN);
break;
}
case 4: {
setState(660);
columnExprList();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- GroupingSetListContext ------------------------------------------------------------------
InsightsQLParser::GroupingSetListContext::GroupingSetListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::GroupingSetContext *> InsightsQLParser::GroupingSetListContext::groupingSet() {
return getRuleContexts<InsightsQLParser::GroupingSetContext>();
}
InsightsQLParser::GroupingSetContext* InsightsQLParser::GroupingSetListContext::groupingSet(size_t i) {
return getRuleContext<InsightsQLParser::GroupingSetContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::GroupingSetListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::GroupingSetListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::GroupingSetListContext::getRuleIndex() const {
return InsightsQLParser::RuleGroupingSetList;
}
std::any InsightsQLParser::GroupingSetListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitGroupingSetList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::GroupingSetListContext* InsightsQLParser::groupingSetList() {
GroupingSetListContext *_localctx = _tracker.createInstance<GroupingSetListContext>(_ctx, getState());
enterRule(_localctx, 70, InsightsQLParser::RuleGroupingSetList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(663);
groupingSet();
setState(668);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(664);
match(InsightsQLParser::COMMA);
setState(665);
groupingSet();
setState(670);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- GroupingSetContext ------------------------------------------------------------------
InsightsQLParser::GroupingSetContext::GroupingSetContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::GroupingSetContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::GroupingSetContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::GroupingSetContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
size_t InsightsQLParser::GroupingSetContext::getRuleIndex() const {
return InsightsQLParser::RuleGroupingSet;
}
std::any InsightsQLParser::GroupingSetContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitGroupingSet(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::GroupingSetContext* InsightsQLParser::groupingSet() {
GroupingSetContext *_localctx = _tracker.createInstance<GroupingSetContext>(_ctx, getState());
enterRule(_localctx, 72, InsightsQLParser::RuleGroupingSet);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(671);
match(InsightsQLParser::LPAREN);
setState(673);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(672);
columnExprList();
}
setState(675);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- HavingClauseContext ------------------------------------------------------------------
InsightsQLParser::HavingClauseContext::HavingClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::HavingClauseContext::HAVING() {
return getToken(InsightsQLParser::HAVING, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::HavingClauseContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::HavingClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleHavingClause;
}
std::any InsightsQLParser::HavingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitHavingClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::HavingClauseContext* InsightsQLParser::havingClause() {
HavingClauseContext *_localctx = _tracker.createInstance<HavingClauseContext>(_ctx, getState());
enterRule(_localctx, 74, InsightsQLParser::RuleHavingClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(677);
match(InsightsQLParser::HAVING);
setState(678);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- QualifyClauseContext ------------------------------------------------------------------
InsightsQLParser::QualifyClauseContext::QualifyClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::QualifyClauseContext::QUALIFY() {
return getToken(InsightsQLParser::QUALIFY, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::QualifyClauseContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::QualifyClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleQualifyClause;
}
std::any InsightsQLParser::QualifyClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitQualifyClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::QualifyClauseContext* InsightsQLParser::qualifyClause() {
QualifyClauseContext *_localctx = _tracker.createInstance<QualifyClauseContext>(_ctx, getState());
enterRule(_localctx, 76, InsightsQLParser::RuleQualifyClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(680);
match(InsightsQLParser::QUALIFY);
setState(681);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- OrderByClauseContext ------------------------------------------------------------------
InsightsQLParser::OrderByClauseContext::OrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::OrderByClauseContext::ORDER() {
return getToken(InsightsQLParser::ORDER, 0);
}
tree::TerminalNode* InsightsQLParser::OrderByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::OrderExprListContext* InsightsQLParser::OrderByClauseContext::orderExprList() {
return getRuleContext<InsightsQLParser::OrderExprListContext>(0);
}
InsightsQLParser::InterpolateClauseContext* InsightsQLParser::OrderByClauseContext::interpolateClause() {
return getRuleContext<InsightsQLParser::InterpolateClauseContext>(0);
}
size_t InsightsQLParser::OrderByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleOrderByClause;
}
std::any InsightsQLParser::OrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitOrderByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::OrderByClauseContext* InsightsQLParser::orderByClause() {
OrderByClauseContext *_localctx = _tracker.createInstance<OrderByClauseContext>(_ctx, getState());
enterRule(_localctx, 78, InsightsQLParser::RuleOrderByClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(683);
match(InsightsQLParser::ORDER);
setState(684);
match(InsightsQLParser::BY);
setState(685);
orderExprList();
setState(687);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::INTERPOLATE) {
setState(686);
interpolateClause();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InterpolateClauseContext ------------------------------------------------------------------
InsightsQLParser::InterpolateClauseContext::InterpolateClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::InterpolateClauseContext::INTERPOLATE() {
return getToken(InsightsQLParser::INTERPOLATE, 0);
}
tree::TerminalNode* InsightsQLParser::InterpolateClauseContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::InterpolateExprContext *> InsightsQLParser::InterpolateClauseContext::interpolateExpr() {
return getRuleContexts<InsightsQLParser::InterpolateExprContext>();
}
InsightsQLParser::InterpolateExprContext* InsightsQLParser::InterpolateClauseContext::interpolateExpr(size_t i) {
return getRuleContext<InsightsQLParser::InterpolateExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::InterpolateClauseContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::InterpolateClauseContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::InterpolateClauseContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::InterpolateClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleInterpolateClause;
}
std::any InsightsQLParser::InterpolateClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInterpolateClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InterpolateClauseContext* InsightsQLParser::interpolateClause() {
InterpolateClauseContext *_localctx = _tracker.createInstance<InterpolateClauseContext>(_ctx, getState());
enterRule(_localctx, 80, InsightsQLParser::RuleInterpolateClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(689);
match(InsightsQLParser::INTERPOLATE);
setState(701);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LPAREN) {
setState(690);
match(InsightsQLParser::LPAREN);
setState(691);
interpolateExpr();
setState(696);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(692);
match(InsightsQLParser::COMMA);
setState(693);
interpolateExpr();
setState(698);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(699);
match(InsightsQLParser::RPAREN);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ProjectionOrderByClauseContext ------------------------------------------------------------------
InsightsQLParser::ProjectionOrderByClauseContext::ProjectionOrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ProjectionOrderByClauseContext::ORDER() {
return getToken(InsightsQLParser::ORDER, 0);
}
tree::TerminalNode* InsightsQLParser::ProjectionOrderByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ProjectionOrderByClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
size_t InsightsQLParser::ProjectionOrderByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleProjectionOrderByClause;
}
std::any InsightsQLParser::ProjectionOrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitProjectionOrderByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ProjectionOrderByClauseContext* InsightsQLParser::projectionOrderByClause() {
ProjectionOrderByClauseContext *_localctx = _tracker.createInstance<ProjectionOrderByClauseContext>(_ctx, getState());
enterRule(_localctx, 82, InsightsQLParser::RuleProjectionOrderByClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(703);
match(InsightsQLParser::ORDER);
setState(704);
match(InsightsQLParser::BY);
setState(705);
columnExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- LimitByClauseContext ------------------------------------------------------------------
InsightsQLParser::LimitByClauseContext::LimitByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::LimitByClauseContext::LIMIT() {
return getToken(InsightsQLParser::LIMIT, 0);
}
InsightsQLParser::LimitExprContext* InsightsQLParser::LimitByClauseContext::limitExpr() {
return getRuleContext<InsightsQLParser::LimitExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::LimitByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::LimitByClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
size_t InsightsQLParser::LimitByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleLimitByClause;
}
std::any InsightsQLParser::LimitByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitLimitByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::LimitByClauseContext* InsightsQLParser::limitByClause() {
LimitByClauseContext *_localctx = _tracker.createInstance<LimitByClauseContext>(_ctx, getState());
enterRule(_localctx, 84, InsightsQLParser::RuleLimitByClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(707);
match(InsightsQLParser::LIMIT);
setState(708);
limitExpr();
setState(709);
match(InsightsQLParser::BY);
setState(710);
columnExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- LimitAndOffsetClauseContext ------------------------------------------------------------------
InsightsQLParser::LimitAndOffsetClauseContext::LimitAndOffsetClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::LIMIT() {
return getToken(InsightsQLParser::LIMIT, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::LimitAndOffsetClauseContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::LimitAndOffsetClauseContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::PERCENT() {
return getToken(InsightsQLParser::PERCENT, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::COMMA() {
return getToken(InsightsQLParser::COMMA, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::TIES() {
return getToken(InsightsQLParser::TIES, 0);
}
tree::TerminalNode* InsightsQLParser::LimitAndOffsetClauseContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
size_t InsightsQLParser::LimitAndOffsetClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleLimitAndOffsetClause;
}
std::any InsightsQLParser::LimitAndOffsetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitLimitAndOffsetClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::LimitAndOffsetClauseContext* InsightsQLParser::limitAndOffsetClause() {
LimitAndOffsetClauseContext *_localctx = _tracker.createInstance<LimitAndOffsetClauseContext>(_ctx, getState());
enterRule(_localctx, 86, InsightsQLParser::RuleLimitAndOffsetClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(737);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(712);
match(InsightsQLParser::LIMIT);
setState(713);
columnExpr(0);
setState(715);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PERCENT) {
setState(714);
match(InsightsQLParser::PERCENT);
}
setState(719);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(717);
match(InsightsQLParser::COMMA);
setState(718);
columnExpr(0);
}
setState(723);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(721);
match(InsightsQLParser::WITH);
setState(722);
match(InsightsQLParser::TIES);
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(725);
match(InsightsQLParser::LIMIT);
setState(726);
columnExpr(0);
setState(728);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PERCENT) {
setState(727);
match(InsightsQLParser::PERCENT);
}
setState(732);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(730);
match(InsightsQLParser::WITH);
setState(731);
match(InsightsQLParser::TIES);
}
setState(734);
match(InsightsQLParser::OFFSET);
setState(735);
columnExpr(0);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- OffsetOnlyClauseContext ------------------------------------------------------------------
InsightsQLParser::OffsetOnlyClauseContext::OffsetOnlyClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::OffsetOnlyClauseContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::OffsetOnlyClauseContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::OffsetOnlyClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleOffsetOnlyClause;
}
std::any InsightsQLParser::OffsetOnlyClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitOffsetOnlyClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::OffsetOnlyClauseContext* InsightsQLParser::offsetOnlyClause() {
OffsetOnlyClauseContext *_localctx = _tracker.createInstance<OffsetOnlyClauseContext>(_ctx, getState());
enterRule(_localctx, 88, InsightsQLParser::RuleOffsetOnlyClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(739);
match(InsightsQLParser::OFFSET);
setState(740);
columnExpr(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SettingsClauseContext ------------------------------------------------------------------
InsightsQLParser::SettingsClauseContext::SettingsClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::SettingsClauseContext::SETTINGS() {
return getToken(InsightsQLParser::SETTINGS, 0);
}
InsightsQLParser::SettingExprListContext* InsightsQLParser::SettingsClauseContext::settingExprList() {
return getRuleContext<InsightsQLParser::SettingExprListContext>(0);
}
size_t InsightsQLParser::SettingsClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleSettingsClause;
}
std::any InsightsQLParser::SettingsClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSettingsClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SettingsClauseContext* InsightsQLParser::settingsClause() {
SettingsClauseContext *_localctx = _tracker.createInstance<SettingsClauseContext>(_ctx, getState());
enterRule(_localctx, 90, InsightsQLParser::RuleSettingsClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(742);
match(InsightsQLParser::SETTINGS);
setState(743);
settingExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ValuesClauseContext ------------------------------------------------------------------
InsightsQLParser::ValuesClauseContext::ValuesClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ValuesClauseContext::VALUES() {
return getToken(InsightsQLParser::VALUES, 0);
}
std::vector<InsightsQLParser::ValuesRowContext *> InsightsQLParser::ValuesClauseContext::valuesRow() {
return getRuleContexts<InsightsQLParser::ValuesRowContext>();
}
InsightsQLParser::ValuesRowContext* InsightsQLParser::ValuesClauseContext::valuesRow(size_t i) {
return getRuleContext<InsightsQLParser::ValuesRowContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ValuesClauseContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ValuesClauseContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::ValuesClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleValuesClause;
}
std::any InsightsQLParser::ValuesClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitValuesClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ValuesClauseContext* InsightsQLParser::valuesClause() {
ValuesClauseContext *_localctx = _tracker.createInstance<ValuesClauseContext>(_ctx, getState());
enterRule(_localctx, 92, InsightsQLParser::RuleValuesClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(745);
match(InsightsQLParser::VALUES);
setState(746);
valuesRow();
setState(751);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(747);
match(InsightsQLParser::COMMA);
setState(748);
valuesRow();
setState(753);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ValuesRowContext ------------------------------------------------------------------
InsightsQLParser::ValuesRowContext::ValuesRowContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ValuesRowContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ValuesRowContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ValuesRowContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ValuesRowContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ValuesRowContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ValuesRowContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::ValuesRowContext::getRuleIndex() const {
return InsightsQLParser::RuleValuesRow;
}
std::any InsightsQLParser::ValuesRowContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitValuesRow(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ValuesRowContext* InsightsQLParser::valuesRow() {
ValuesRowContext *_localctx = _tracker.createInstance<ValuesRowContext>(_ctx, getState());
enterRule(_localctx, 94, InsightsQLParser::RuleValuesRow);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(754);
match(InsightsQLParser::LPAREN);
setState(755);
columnExpr(0);
setState(760);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(756);
match(InsightsQLParser::COMMA);
setState(757);
columnExpr(0);
setState(762);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(763);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- JoinExprContext ------------------------------------------------------------------
InsightsQLParser::JoinExprContext::JoinExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::JoinExprContext::getRuleIndex() const {
return InsightsQLParser::RuleJoinExpr;
}
void InsightsQLParser::JoinExprContext::copyFrom(JoinExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- JoinExprPositionalContext ------------------------------------------------------------------
std::vector<InsightsQLParser::JoinExprContext *> InsightsQLParser::JoinExprPositionalContext::joinExpr() {
return getRuleContexts<InsightsQLParser::JoinExprContext>();
}
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprPositionalContext::joinExpr(size_t i) {
return getRuleContext<InsightsQLParser::JoinExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::JoinExprPositionalContext::POSITIONAL() {
return getToken(InsightsQLParser::POSITIONAL, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPositionalContext::JOIN() {
return getToken(InsightsQLParser::JOIN, 0);
}
InsightsQLParser::JoinConstraintClauseContext* InsightsQLParser::JoinExprPositionalContext::joinConstraintClause() {
return getRuleContext<InsightsQLParser::JoinConstraintClauseContext>(0);
}
InsightsQLParser::JoinExprPositionalContext::JoinExprPositionalContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprPositionalContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprPositional(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprOpContext ------------------------------------------------------------------
std::vector<InsightsQLParser::JoinExprContext *> InsightsQLParser::JoinExprOpContext::joinExpr() {
return getRuleContexts<InsightsQLParser::JoinExprContext>();
}
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprOpContext::joinExpr(size_t i) {
return getRuleContext<InsightsQLParser::JoinExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::JoinExprOpContext::JOIN() {
return getToken(InsightsQLParser::JOIN, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprOpContext::NATURAL() {
return getToken(InsightsQLParser::NATURAL, 0);
}
InsightsQLParser::JoinOpContext* InsightsQLParser::JoinExprOpContext::joinOp() {
return getRuleContext<InsightsQLParser::JoinOpContext>(0);
}
InsightsQLParser::JoinConstraintClauseContext* InsightsQLParser::JoinExprOpContext::joinConstraintClause() {
return getRuleContext<InsightsQLParser::JoinConstraintClauseContext>(0);
}
InsightsQLParser::JoinExprOpContext::JoinExprOpContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprOpContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprOp(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprTableContext ------------------------------------------------------------------
InsightsQLParser::TableExprContext* InsightsQLParser::JoinExprTableContext::tableExpr() {
return getRuleContext<InsightsQLParser::TableExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprTableContext::FINAL() {
return getToken(InsightsQLParser::FINAL, 0);
}
InsightsQLParser::SampleClauseContext* InsightsQLParser::JoinExprTableContext::sampleClause() {
return getRuleContext<InsightsQLParser::SampleClauseContext>(0);
}
InsightsQLParser::JoinExprTableContext::JoinExprTableContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprTableContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprTable(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprUnpivotContext ------------------------------------------------------------------
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprUnpivotContext::joinExpr() {
return getRuleContext<InsightsQLParser::JoinExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprUnpivotContext::UNPIVOT() {
return getToken(InsightsQLParser::UNPIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprUnpivotContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::UnpivotColumnListContext* InsightsQLParser::JoinExprUnpivotContext::unpivotColumnList() {
return getRuleContext<InsightsQLParser::UnpivotColumnListContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprUnpivotContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprUnpivotContext::INCLUDE() {
return getToken(InsightsQLParser::INCLUDE, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprUnpivotContext::NULLS() {
return getToken(InsightsQLParser::NULLS, 0);
}
InsightsQLParser::JoinExprUnpivotContext::JoinExprUnpivotContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprUnpivotContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprUnpivot(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprParensContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::JoinExprParensContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprParensContext::joinExpr() {
return getRuleContext<InsightsQLParser::JoinExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprParensContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::JoinExprParensContext::JoinExprParensContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprParensContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprParens(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprCrossOpContext ------------------------------------------------------------------
std::vector<InsightsQLParser::JoinExprContext *> InsightsQLParser::JoinExprCrossOpContext::joinExpr() {
return getRuleContexts<InsightsQLParser::JoinExprContext>();
}
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprCrossOpContext::joinExpr(size_t i) {
return getRuleContext<InsightsQLParser::JoinExprContext>(i);
}
InsightsQLParser::JoinOpCrossContext* InsightsQLParser::JoinExprCrossOpContext::joinOpCross() {
return getRuleContext<InsightsQLParser::JoinOpCrossContext>(0);
}
InsightsQLParser::JoinExprCrossOpContext::JoinExprCrossOpContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprCrossOpContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprCrossOp(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinExprPivotContext ------------------------------------------------------------------
InsightsQLParser::JoinExprContext* InsightsQLParser::JoinExprPivotContext::joinExpr() {
return getRuleContext<InsightsQLParser::JoinExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPivotContext::PIVOT() {
return getToken(InsightsQLParser::PIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPivotContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::JoinExprPivotContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::JoinExprPivotContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
InsightsQLParser::PivotColumnListContext* InsightsQLParser::JoinExprPivotContext::pivotColumnList() {
return getRuleContext<InsightsQLParser::PivotColumnListContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPivotContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPivotContext::GROUP() {
return getToken(InsightsQLParser::GROUP, 0);
}
tree::TerminalNode* InsightsQLParser::JoinExprPivotContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::JoinExprPivotContext::JoinExprPivotContext(JoinExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinExprPivotContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinExprPivot(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::JoinExprContext* InsightsQLParser::joinExpr() {
return joinExpr(0);
}
InsightsQLParser::JoinExprContext* InsightsQLParser::joinExpr(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
InsightsQLParser::JoinExprContext *_localctx = _tracker.createInstance<JoinExprContext>(_ctx, parentState);
InsightsQLParser::JoinExprContext *previousContext = _localctx;
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
size_t startState = 96;
enterRecursionRule(_localctx, 96, InsightsQLParser::RuleJoinExpr, precedence);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(777);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<JoinExprTableContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(766);
tableExpr(0);
setState(768);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
case 1: {
setState(767);
match(InsightsQLParser::FINAL);
break;
}
default:
break;
}
setState(771);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
case 1: {
setState(770);
sampleClause();
break;
}
default:
break;
}
break;
}
case 2: {
_localctx = _tracker.createInstance<JoinExprParensContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(773);
match(InsightsQLParser::LPAREN);
setState(774);
joinExpr(0);
setState(775);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
_ctx->stop = _input->LT(-1);
setState(826);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
setState(824);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) {
case 1: {
auto newContext = _tracker.createInstance<JoinExprCrossOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
setState(779);
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
setState(780);
joinOpCross();
setState(781);
joinExpr(6);
break;
}
case 2: {
auto newContext = _tracker.createInstance<JoinExprOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
setState(783);
if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
setState(785);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NATURAL) {
setState(784);
match(InsightsQLParser::NATURAL);
}
setState(788);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -9214363738088406758) != 0) || _la == InsightsQLParser::RIGHT
|| _la == InsightsQLParser::SEMI) {
setState(787);
joinOp();
}
setState(790);
match(InsightsQLParser::JOIN);
setState(791);
joinExpr(0);
setState(793);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
case 1: {
setState(792);
joinConstraintClause();
break;
}
default:
break;
}
break;
}
case 3: {
auto newContext = _tracker.createInstance<JoinExprPositionalContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
setState(795);
if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
setState(796);
match(InsightsQLParser::POSITIONAL);
setState(797);
match(InsightsQLParser::JOIN);
setState(798);
joinExpr(0);
setState(800);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
case 1: {
setState(799);
joinConstraintClause();
break;
}
default:
break;
}
break;
}
case 4: {
auto newContext = _tracker.createInstance<JoinExprPivotContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
setState(802);
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
setState(803);
match(InsightsQLParser::PIVOT);
setState(804);
match(InsightsQLParser::LPAREN);
setState(805);
columnExprList();
setState(806);
pivotColumnList();
setState(810);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::GROUP) {
setState(807);
match(InsightsQLParser::GROUP);
setState(808);
match(InsightsQLParser::BY);
setState(809);
columnExprList();
}
setState(812);
match(InsightsQLParser::RPAREN);
break;
}
case 5: {
auto newContext = _tracker.createInstance<JoinExprUnpivotContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
setState(814);
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
setState(815);
match(InsightsQLParser::UNPIVOT);
setState(818);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::INCLUDE) {
setState(816);
match(InsightsQLParser::INCLUDE);
setState(817);
match(InsightsQLParser::NULLS);
}
setState(820);
match(InsightsQLParser::LPAREN);
setState(821);
unpivotColumnList();
setState(822);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
}
setState(828);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- JoinOpContext ------------------------------------------------------------------
InsightsQLParser::JoinOpContext::JoinOpContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::JoinOpContext::getRuleIndex() const {
return InsightsQLParser::RuleJoinOp;
}
void InsightsQLParser::JoinOpContext::copyFrom(JoinOpContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- JoinOpFullContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::JoinOpFullContext::FULL() {
return getToken(InsightsQLParser::FULL, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpFullContext::OUTER() {
return getToken(InsightsQLParser::OUTER, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpFullContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpFullContext::ANY() {
return getToken(InsightsQLParser::ANY, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpFullContext::ASOF() {
return getToken(InsightsQLParser::ASOF, 0);
}
InsightsQLParser::JoinOpFullContext::JoinOpFullContext(JoinOpContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinOpFullContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinOpFull(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinOpInnerContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::INNER() {
return getToken(InsightsQLParser::INNER, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::ANTI() {
return getToken(InsightsQLParser::ANTI, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::SEMI() {
return getToken(InsightsQLParser::SEMI, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::ASOF() {
return getToken(InsightsQLParser::ASOF, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpInnerContext::ANY() {
return getToken(InsightsQLParser::ANY, 0);
}
InsightsQLParser::JoinOpInnerContext::JoinOpInnerContext(JoinOpContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinOpInnerContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinOpInner(this);
else
return visitor->visitChildren(this);
}
//----------------- JoinOpLeftRightContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::ASOF() {
return getToken(InsightsQLParser::ASOF, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::LEFT() {
return getToken(InsightsQLParser::LEFT, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::RIGHT() {
return getToken(InsightsQLParser::RIGHT, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::ANTI() {
return getToken(InsightsQLParser::ANTI, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::SEMI() {
return getToken(InsightsQLParser::SEMI, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::OUTER() {
return getToken(InsightsQLParser::OUTER, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpLeftRightContext::ANY() {
return getToken(InsightsQLParser::ANY, 0);
}
InsightsQLParser::JoinOpLeftRightContext::JoinOpLeftRightContext(JoinOpContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::JoinOpLeftRightContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinOpLeftRight(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::JoinOpContext* InsightsQLParser::joinOp() {
JoinOpContext *_localctx = _tracker.createInstance<JoinOpContext>(_ctx, getState());
enterRule(_localctx, 98, InsightsQLParser::RuleJoinOp);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(882);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::JoinOpInnerContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(842);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx)) {
case 1: {
setState(830);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0)) {
setState(829);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(832);
match(InsightsQLParser::INNER);
break;
}
case 2: {
setState(833);
match(InsightsQLParser::INNER);
setState(835);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0)) {
setState(834);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
break;
}
case 3: {
setState(837);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
case 4: {
setState(838);
match(InsightsQLParser::ANTI);
break;
}
case 5: {
setState(839);
match(InsightsQLParser::SEMI);
break;
}
case 6: {
setState(840);
match(InsightsQLParser::ASOF);
setState(841);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::ANTI || _la == InsightsQLParser::SEMI)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
break;
}
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::JoinOpLeftRightContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(864);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
case 1: {
setState(845);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 282) != 0) || _la == InsightsQLParser::SEMI) {
setState(844);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 282) != 0) || _la == InsightsQLParser::SEMI)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(847);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::LEFT
|| _la == InsightsQLParser::RIGHT)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(849);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OUTER) {
setState(848);
match(InsightsQLParser::OUTER);
}
break;
}
case 2: {
setState(851);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::LEFT
|| _la == InsightsQLParser::RIGHT)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(853);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OUTER) {
setState(852);
match(InsightsQLParser::OUTER);
}
setState(856);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 282) != 0) || _la == InsightsQLParser::SEMI) {
setState(855);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 282) != 0) || _la == InsightsQLParser::SEMI)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
break;
}
case 3: {
setState(858);
match(InsightsQLParser::ASOF);
setState(859);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::ANTI || _la == InsightsQLParser::SEMI)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(860);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::LEFT
|| _la == InsightsQLParser::RIGHT)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(862);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OUTER) {
setState(861);
match(InsightsQLParser::OUTER);
}
break;
}
default:
break;
}
break;
}
case 3: {
_localctx = _tracker.createInstance<InsightsQLParser::JoinOpFullContext>(_localctx);
enterOuterAlt(_localctx, 3);
setState(880);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
case 1: {
setState(867);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0)) {
setState(866);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(869);
match(InsightsQLParser::FULL);
setState(871);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OUTER) {
setState(870);
match(InsightsQLParser::OUTER);
}
break;
}
case 2: {
setState(873);
match(InsightsQLParser::FULL);
setState(875);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OUTER) {
setState(874);
match(InsightsQLParser::OUTER);
}
setState(878);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0)) {
setState(877);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 274) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
break;
}
default:
break;
}
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- JoinOpCrossContext ------------------------------------------------------------------
InsightsQLParser::JoinOpCrossContext::JoinOpCrossContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::JoinOpCrossContext::CROSS() {
return getToken(InsightsQLParser::CROSS, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpCrossContext::JOIN() {
return getToken(InsightsQLParser::JOIN, 0);
}
tree::TerminalNode* InsightsQLParser::JoinOpCrossContext::COMMA() {
return getToken(InsightsQLParser::COMMA, 0);
}
size_t InsightsQLParser::JoinOpCrossContext::getRuleIndex() const {
return InsightsQLParser::RuleJoinOpCross;
}
std::any InsightsQLParser::JoinOpCrossContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinOpCross(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::JoinOpCrossContext* InsightsQLParser::joinOpCross() {
JoinOpCrossContext *_localctx = _tracker.createInstance<JoinOpCrossContext>(_ctx, getState());
enterRule(_localctx, 100, InsightsQLParser::RuleJoinOpCross);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(887);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::CROSS: {
enterOuterAlt(_localctx, 1);
setState(884);
match(InsightsQLParser::CROSS);
setState(885);
match(InsightsQLParser::JOIN);
break;
}
case InsightsQLParser::COMMA: {
enterOuterAlt(_localctx, 2);
setState(886);
match(InsightsQLParser::COMMA);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- JoinConstraintClauseContext ------------------------------------------------------------------
InsightsQLParser::JoinConstraintClauseContext::JoinConstraintClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::JoinConstraintClauseContext::ON() {
return getToken(InsightsQLParser::ON, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::JoinConstraintClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::JoinConstraintClauseContext::USING() {
return getToken(InsightsQLParser::USING, 0);
}
tree::TerminalNode* InsightsQLParser::JoinConstraintClauseContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::JoinConstraintClauseContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
size_t InsightsQLParser::JoinConstraintClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleJoinConstraintClause;
}
std::any InsightsQLParser::JoinConstraintClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitJoinConstraintClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::JoinConstraintClauseContext* InsightsQLParser::joinConstraintClause() {
JoinConstraintClauseContext *_localctx = _tracker.createInstance<JoinConstraintClauseContext>(_ctx, getState());
enterRule(_localctx, 102, InsightsQLParser::RuleJoinConstraintClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(898);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(889);
match(InsightsQLParser::ON);
setState(890);
columnExprList();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(891);
match(InsightsQLParser::USING);
setState(892);
match(InsightsQLParser::LPAREN);
setState(893);
columnExprList();
setState(894);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(896);
match(InsightsQLParser::USING);
setState(897);
columnExprList();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SampleClauseContext ------------------------------------------------------------------
InsightsQLParser::SampleClauseContext::SampleClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::SampleClauseContext::SAMPLE() {
return getToken(InsightsQLParser::SAMPLE, 0);
}
std::vector<InsightsQLParser::RatioExprContext *> InsightsQLParser::SampleClauseContext::ratioExpr() {
return getRuleContexts<InsightsQLParser::RatioExprContext>();
}
InsightsQLParser::RatioExprContext* InsightsQLParser::SampleClauseContext::ratioExpr(size_t i) {
return getRuleContext<InsightsQLParser::RatioExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::SampleClauseContext::PERCENT() {
return getToken(InsightsQLParser::PERCENT, 0);
}
tree::TerminalNode* InsightsQLParser::SampleClauseContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
tree::TerminalNode* InsightsQLParser::SampleClauseContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::SampleClauseContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::SampleClauseContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
size_t InsightsQLParser::SampleClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleSampleClause;
}
std::any InsightsQLParser::SampleClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSampleClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SampleClauseContext* InsightsQLParser::sampleClause() {
SampleClauseContext *_localctx = _tracker.createInstance<SampleClauseContext>(_ctx, getState());
enterRule(_localctx, 104, InsightsQLParser::RuleSampleClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(900);
match(InsightsQLParser::SAMPLE);
setState(901);
ratioExpr();
setState(903);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
case 1: {
setState(902);
match(InsightsQLParser::PERCENT);
break;
}
default:
break;
}
setState(907);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx)) {
case 1: {
setState(905);
match(InsightsQLParser::OFFSET);
setState(906);
ratioExpr();
break;
}
default:
break;
}
setState(913);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) {
case 1: {
setState(909);
match(InsightsQLParser::LPAREN);
setState(910);
identifier();
setState(911);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- LimitExprContext ------------------------------------------------------------------
InsightsQLParser::LimitExprContext::LimitExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::LimitExprContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::LimitExprContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::LimitExprContext::COMMA() {
return getToken(InsightsQLParser::COMMA, 0);
}
tree::TerminalNode* InsightsQLParser::LimitExprContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
size_t InsightsQLParser::LimitExprContext::getRuleIndex() const {
return InsightsQLParser::RuleLimitExpr;
}
std::any InsightsQLParser::LimitExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitLimitExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::LimitExprContext* InsightsQLParser::limitExpr() {
LimitExprContext *_localctx = _tracker.createInstance<LimitExprContext>(_ctx, getState());
enterRule(_localctx, 106, InsightsQLParser::RuleLimitExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(915);
columnExpr(0);
setState(918);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::OFFSET || _la == InsightsQLParser::COMMA) {
setState(916);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::OFFSET || _la == InsightsQLParser::COMMA)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(917);
columnExpr(0);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- OrderExprListContext ------------------------------------------------------------------
InsightsQLParser::OrderExprListContext::OrderExprListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::OrderExprContext *> InsightsQLParser::OrderExprListContext::orderExpr() {
return getRuleContexts<InsightsQLParser::OrderExprContext>();
}
InsightsQLParser::OrderExprContext* InsightsQLParser::OrderExprListContext::orderExpr(size_t i) {
return getRuleContext<InsightsQLParser::OrderExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::OrderExprListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::OrderExprListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::OrderExprListContext::getRuleIndex() const {
return InsightsQLParser::RuleOrderExprList;
}
std::any InsightsQLParser::OrderExprListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitOrderExprList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::OrderExprListContext* InsightsQLParser::orderExprList() {
OrderExprListContext *_localctx = _tracker.createInstance<OrderExprListContext>(_ctx, getState());
enterRule(_localctx, 108, InsightsQLParser::RuleOrderExprList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(920);
orderExpr();
setState(925);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(921);
match(InsightsQLParser::COMMA);
setState(922);
orderExpr();
setState(927);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- OrderExprContext ------------------------------------------------------------------
InsightsQLParser::OrderExprContext::OrderExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::OrderExprContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::NULLS() {
return getToken(InsightsQLParser::NULLS, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::COLLATE() {
return getToken(InsightsQLParser::COLLATE, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::WithFillClauseContext* InsightsQLParser::OrderExprContext::withFillClause() {
return getRuleContext<InsightsQLParser::WithFillClauseContext>(0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::ASCENDING() {
return getToken(InsightsQLParser::ASCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::DESCENDING() {
return getToken(InsightsQLParser::DESCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::DESC() {
return getToken(InsightsQLParser::DESC, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::FIRST() {
return getToken(InsightsQLParser::FIRST, 0);
}
tree::TerminalNode* InsightsQLParser::OrderExprContext::LAST() {
return getToken(InsightsQLParser::LAST, 0);
}
size_t InsightsQLParser::OrderExprContext::getRuleIndex() const {
return InsightsQLParser::RuleOrderExpr;
}
std::any InsightsQLParser::OrderExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitOrderExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::OrderExprContext* InsightsQLParser::orderExpr() {
OrderExprContext *_localctx = _tracker.createInstance<OrderExprContext>(_ctx, getState());
enterRule(_localctx, 110, InsightsQLParser::RuleOrderExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(928);
columnExpr(0);
setState(930);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 25165952) != 0)) {
setState(929);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 25165952) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(934);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NULLS) {
setState(932);
match(InsightsQLParser::NULLS);
setState(933);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::FIRST
|| _la == InsightsQLParser::LAST)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(938);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COLLATE) {
setState(936);
match(InsightsQLParser::COLLATE);
setState(937);
match(InsightsQLParser::STRING_LITERAL);
}
setState(941);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::WITH) {
setState(940);
withFillClause();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithFillClauseContext ------------------------------------------------------------------
InsightsQLParser::WithFillClauseContext::WithFillClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WithFillClauseContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::WithFillClauseContext::FILL() {
return getToken(InsightsQLParser::FILL, 0);
}
tree::TerminalNode* InsightsQLParser::WithFillClauseContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::WithFillClauseContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::WithFillClauseContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::WithFillClauseContext::TO() {
return getToken(InsightsQLParser::TO, 0);
}
tree::TerminalNode* InsightsQLParser::WithFillClauseContext::STEP() {
return getToken(InsightsQLParser::STEP, 0);
}
size_t InsightsQLParser::WithFillClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWithFillClause;
}
std::any InsightsQLParser::WithFillClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithFillClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithFillClauseContext* InsightsQLParser::withFillClause() {
WithFillClauseContext *_localctx = _tracker.createInstance<WithFillClauseContext>(_ctx, getState());
enterRule(_localctx, 112, InsightsQLParser::RuleWithFillClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(943);
match(InsightsQLParser::WITH);
setState(944);
match(InsightsQLParser::FILL);
setState(947);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FROM) {
setState(945);
match(InsightsQLParser::FROM);
setState(946);
columnExpr(0);
}
setState(951);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::TO) {
setState(949);
match(InsightsQLParser::TO);
setState(950);
columnExpr(0);
}
setState(955);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::STEP) {
setState(953);
match(InsightsQLParser::STEP);
setState(954);
columnExpr(0);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InterpolateExprContext ------------------------------------------------------------------
InsightsQLParser::InterpolateExprContext::InterpolateExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::InterpolateExprContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::InterpolateExprContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::InterpolateExprContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
size_t InsightsQLParser::InterpolateExprContext::getRuleIndex() const {
return InsightsQLParser::RuleInterpolateExpr;
}
std::any InsightsQLParser::InterpolateExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInterpolateExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InterpolateExprContext* InsightsQLParser::interpolateExpr() {
InterpolateExprContext *_localctx = _tracker.createInstance<InterpolateExprContext>(_ctx, getState());
enterRule(_localctx, 114, InsightsQLParser::RuleInterpolateExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(957);
columnExpr(0);
setState(960);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::AS) {
setState(958);
match(InsightsQLParser::AS);
setState(959);
columnExpr(0);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- RatioExprContext ------------------------------------------------------------------
InsightsQLParser::RatioExprContext::RatioExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::PlaceholderContext* InsightsQLParser::RatioExprContext::placeholder() {
return getRuleContext<InsightsQLParser::PlaceholderContext>(0);
}
std::vector<InsightsQLParser::NumberLiteralContext *> InsightsQLParser::RatioExprContext::numberLiteral() {
return getRuleContexts<InsightsQLParser::NumberLiteralContext>();
}
InsightsQLParser::NumberLiteralContext* InsightsQLParser::RatioExprContext::numberLiteral(size_t i) {
return getRuleContext<InsightsQLParser::NumberLiteralContext>(i);
}
tree::TerminalNode* InsightsQLParser::RatioExprContext::SLASH() {
return getToken(InsightsQLParser::SLASH, 0);
}
size_t InsightsQLParser::RatioExprContext::getRuleIndex() const {
return InsightsQLParser::RuleRatioExpr;
}
std::any InsightsQLParser::RatioExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitRatioExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::RatioExprContext* InsightsQLParser::ratioExpr() {
RatioExprContext *_localctx = _tracker.createInstance<RatioExprContext>(_ctx, getState());
enterRule(_localctx, 116, InsightsQLParser::RuleRatioExpr);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(968);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::LBRACE: {
enterOuterAlt(_localctx, 1);
setState(962);
placeholder();
break;
}
case InsightsQLParser::INF:
case InsightsQLParser::NAN_SQL:
case InsightsQLParser::FLOATING_LITERAL:
case InsightsQLParser::BINARY_LITERAL:
case InsightsQLParser::OCTAL_LITERAL:
case InsightsQLParser::DECIMAL_LITERAL:
case InsightsQLParser::HEXADECIMAL_LITERAL:
case InsightsQLParser::OCTAL_PREFIX_LITERAL:
case InsightsQLParser::DASH:
case InsightsQLParser::DOT:
case InsightsQLParser::PLUS: {
enterOuterAlt(_localctx, 2);
setState(963);
numberLiteral();
setState(966);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx)) {
case 1: {
setState(964);
match(InsightsQLParser::SLASH);
setState(965);
numberLiteral();
break;
}
default:
break;
}
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SettingExprListContext ------------------------------------------------------------------
InsightsQLParser::SettingExprListContext::SettingExprListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::SettingExprContext *> InsightsQLParser::SettingExprListContext::settingExpr() {
return getRuleContexts<InsightsQLParser::SettingExprContext>();
}
InsightsQLParser::SettingExprContext* InsightsQLParser::SettingExprListContext::settingExpr(size_t i) {
return getRuleContext<InsightsQLParser::SettingExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::SettingExprListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::SettingExprListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::SettingExprListContext::getRuleIndex() const {
return InsightsQLParser::RuleSettingExprList;
}
std::any InsightsQLParser::SettingExprListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSettingExprList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SettingExprListContext* InsightsQLParser::settingExprList() {
SettingExprListContext *_localctx = _tracker.createInstance<SettingExprListContext>(_ctx, getState());
enterRule(_localctx, 118, InsightsQLParser::RuleSettingExprList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(970);
settingExpr();
setState(975);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(971);
match(InsightsQLParser::COMMA);
setState(972);
settingExpr();
setState(977);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SettingExprContext ------------------------------------------------------------------
InsightsQLParser::SettingExprContext::SettingExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::IdentifierContext* InsightsQLParser::SettingExprContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::SettingExprContext::EQ_SINGLE() {
return getToken(InsightsQLParser::EQ_SINGLE, 0);
}
InsightsQLParser::LiteralContext* InsightsQLParser::SettingExprContext::literal() {
return getRuleContext<InsightsQLParser::LiteralContext>(0);
}
size_t InsightsQLParser::SettingExprContext::getRuleIndex() const {
return InsightsQLParser::RuleSettingExpr;
}
std::any InsightsQLParser::SettingExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSettingExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SettingExprContext* InsightsQLParser::settingExpr() {
SettingExprContext *_localctx = _tracker.createInstance<SettingExprContext>(_ctx, getState());
enterRule(_localctx, 120, InsightsQLParser::RuleSettingExpr);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(978);
identifier();
setState(979);
match(InsightsQLParser::EQ_SINGLE);
setState(980);
literal();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WindowExprContext ------------------------------------------------------------------
InsightsQLParser::WindowExprContext::WindowExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::WinPartitionByClauseContext* InsightsQLParser::WindowExprContext::winPartitionByClause() {
return getRuleContext<InsightsQLParser::WinPartitionByClauseContext>(0);
}
InsightsQLParser::WinOrderByClauseContext* InsightsQLParser::WindowExprContext::winOrderByClause() {
return getRuleContext<InsightsQLParser::WinOrderByClauseContext>(0);
}
InsightsQLParser::WinFrameClauseContext* InsightsQLParser::WindowExprContext::winFrameClause() {
return getRuleContext<InsightsQLParser::WinFrameClauseContext>(0);
}
size_t InsightsQLParser::WindowExprContext::getRuleIndex() const {
return InsightsQLParser::RuleWindowExpr;
}
std::any InsightsQLParser::WindowExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWindowExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WindowExprContext* InsightsQLParser::windowExpr() {
WindowExprContext *_localctx = _tracker.createInstance<WindowExprContext>(_ctx, getState());
enterRule(_localctx, 122, InsightsQLParser::RuleWindowExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(983);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::PARTITION) {
setState(982);
winPartitionByClause();
}
setState(986);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::ORDER) {
setState(985);
winOrderByClause();
}
setState(989);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::RANGE
|| _la == InsightsQLParser::ROWS) {
setState(988);
winFrameClause();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WinPartitionByClauseContext ------------------------------------------------------------------
InsightsQLParser::WinPartitionByClauseContext::WinPartitionByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WinPartitionByClauseContext::PARTITION() {
return getToken(InsightsQLParser::PARTITION, 0);
}
tree::TerminalNode* InsightsQLParser::WinPartitionByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::WinPartitionByClauseContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
size_t InsightsQLParser::WinPartitionByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWinPartitionByClause;
}
std::any InsightsQLParser::WinPartitionByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWinPartitionByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WinPartitionByClauseContext* InsightsQLParser::winPartitionByClause() {
WinPartitionByClauseContext *_localctx = _tracker.createInstance<WinPartitionByClauseContext>(_ctx, getState());
enterRule(_localctx, 124, InsightsQLParser::RuleWinPartitionByClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(991);
match(InsightsQLParser::PARTITION);
setState(992);
match(InsightsQLParser::BY);
setState(993);
columnExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WinOrderByClauseContext ------------------------------------------------------------------
InsightsQLParser::WinOrderByClauseContext::WinOrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WinOrderByClauseContext::ORDER() {
return getToken(InsightsQLParser::ORDER, 0);
}
tree::TerminalNode* InsightsQLParser::WinOrderByClauseContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::OrderExprListContext* InsightsQLParser::WinOrderByClauseContext::orderExprList() {
return getRuleContext<InsightsQLParser::OrderExprListContext>(0);
}
size_t InsightsQLParser::WinOrderByClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWinOrderByClause;
}
std::any InsightsQLParser::WinOrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWinOrderByClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WinOrderByClauseContext* InsightsQLParser::winOrderByClause() {
WinOrderByClauseContext *_localctx = _tracker.createInstance<WinOrderByClauseContext>(_ctx, getState());
enterRule(_localctx, 126, InsightsQLParser::RuleWinOrderByClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(995);
match(InsightsQLParser::ORDER);
setState(996);
match(InsightsQLParser::BY);
setState(997);
orderExprList();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithinGroupClauseContext ------------------------------------------------------------------
InsightsQLParser::WithinGroupClauseContext::WithinGroupClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WithinGroupClauseContext::WITHIN() {
return getToken(InsightsQLParser::WITHIN, 0);
}
tree::TerminalNode* InsightsQLParser::WithinGroupClauseContext::GROUP() {
return getToken(InsightsQLParser::GROUP, 0);
}
tree::TerminalNode* InsightsQLParser::WithinGroupClauseContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::OrderByClauseContext* InsightsQLParser::WithinGroupClauseContext::orderByClause() {
return getRuleContext<InsightsQLParser::OrderByClauseContext>(0);
}
tree::TerminalNode* InsightsQLParser::WithinGroupClauseContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
size_t InsightsQLParser::WithinGroupClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWithinGroupClause;
}
std::any InsightsQLParser::WithinGroupClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithinGroupClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithinGroupClauseContext* InsightsQLParser::withinGroupClause() {
WithinGroupClauseContext *_localctx = _tracker.createInstance<WithinGroupClauseContext>(_ctx, getState());
enterRule(_localctx, 128, InsightsQLParser::RuleWithinGroupClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(999);
match(InsightsQLParser::WITHIN);
setState(1000);
match(InsightsQLParser::GROUP);
setState(1001);
match(InsightsQLParser::LPAREN);
setState(1002);
orderByClause();
setState(1003);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WinFrameClauseContext ------------------------------------------------------------------
InsightsQLParser::WinFrameClauseContext::WinFrameClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::WinFrameExtendContext* InsightsQLParser::WinFrameClauseContext::winFrameExtend() {
return getRuleContext<InsightsQLParser::WinFrameExtendContext>(0);
}
tree::TerminalNode* InsightsQLParser::WinFrameClauseContext::ROWS() {
return getToken(InsightsQLParser::ROWS, 0);
}
tree::TerminalNode* InsightsQLParser::WinFrameClauseContext::RANGE() {
return getToken(InsightsQLParser::RANGE, 0);
}
size_t InsightsQLParser::WinFrameClauseContext::getRuleIndex() const {
return InsightsQLParser::RuleWinFrameClause;
}
std::any InsightsQLParser::WinFrameClauseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWinFrameClause(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WinFrameClauseContext* InsightsQLParser::winFrameClause() {
WinFrameClauseContext *_localctx = _tracker.createInstance<WinFrameClauseContext>(_ctx, getState());
enterRule(_localctx, 130, InsightsQLParser::RuleWinFrameClause);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1005);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::RANGE
|| _la == InsightsQLParser::ROWS)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1006);
winFrameExtend();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WinFrameExtendContext ------------------------------------------------------------------
InsightsQLParser::WinFrameExtendContext::WinFrameExtendContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::WinFrameExtendContext::getRuleIndex() const {
return InsightsQLParser::RuleWinFrameExtend;
}
void InsightsQLParser::WinFrameExtendContext::copyFrom(WinFrameExtendContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- FrameStartContext ------------------------------------------------------------------
InsightsQLParser::WinFrameBoundContext* InsightsQLParser::FrameStartContext::winFrameBound() {
return getRuleContext<InsightsQLParser::WinFrameBoundContext>(0);
}
InsightsQLParser::FrameStartContext::FrameStartContext(WinFrameExtendContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::FrameStartContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFrameStart(this);
else
return visitor->visitChildren(this);
}
//----------------- FrameBetweenContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::FrameBetweenContext::BETWEEN() {
return getToken(InsightsQLParser::BETWEEN, 0);
}
std::vector<InsightsQLParser::WinFrameBoundContext *> InsightsQLParser::FrameBetweenContext::winFrameBound() {
return getRuleContexts<InsightsQLParser::WinFrameBoundContext>();
}
InsightsQLParser::WinFrameBoundContext* InsightsQLParser::FrameBetweenContext::winFrameBound(size_t i) {
return getRuleContext<InsightsQLParser::WinFrameBoundContext>(i);
}
tree::TerminalNode* InsightsQLParser::FrameBetweenContext::AND() {
return getToken(InsightsQLParser::AND, 0);
}
InsightsQLParser::FrameBetweenContext::FrameBetweenContext(WinFrameExtendContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::FrameBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFrameBetween(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WinFrameExtendContext* InsightsQLParser::winFrameExtend() {
WinFrameExtendContext *_localctx = _tracker.createInstance<WinFrameExtendContext>(_ctx, getState());
enterRule(_localctx, 132, InsightsQLParser::RuleWinFrameExtend);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1014);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::FrameStartContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1008);
winFrameBound();
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::FrameBetweenContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1009);
match(InsightsQLParser::BETWEEN);
setState(1010);
winFrameBound();
setState(1011);
match(InsightsQLParser::AND);
setState(1012);
winFrameBound();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WinFrameBoundContext ------------------------------------------------------------------
InsightsQLParser::WinFrameBoundContext::WinFrameBoundContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WinFrameBoundContext::CURRENT() {
return getToken(InsightsQLParser::CURRENT, 0);
}
tree::TerminalNode* InsightsQLParser::WinFrameBoundContext::ROW() {
return getToken(InsightsQLParser::ROW, 0);
}
tree::TerminalNode* InsightsQLParser::WinFrameBoundContext::UNBOUNDED() {
return getToken(InsightsQLParser::UNBOUNDED, 0);
}
tree::TerminalNode* InsightsQLParser::WinFrameBoundContext::PRECEDING() {
return getToken(InsightsQLParser::PRECEDING, 0);
}
tree::TerminalNode* InsightsQLParser::WinFrameBoundContext::FOLLOWING() {
return getToken(InsightsQLParser::FOLLOWING, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::WinFrameBoundContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::WinFrameBoundContext::getRuleIndex() const {
return InsightsQLParser::RuleWinFrameBound;
}
std::any InsightsQLParser::WinFrameBoundContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWinFrameBound(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WinFrameBoundContext* InsightsQLParser::winFrameBound() {
WinFrameBoundContext *_localctx = _tracker.createInstance<WinFrameBoundContext>(_ctx, getState());
enterRule(_localctx, 134, InsightsQLParser::RuleWinFrameBound);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1028);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx)) {
case 1: {
setState(1016);
match(InsightsQLParser::CURRENT);
setState(1017);
match(InsightsQLParser::ROW);
break;
}
case 2: {
setState(1018);
match(InsightsQLParser::UNBOUNDED);
setState(1019);
match(InsightsQLParser::PRECEDING);
break;
}
case 3: {
setState(1020);
match(InsightsQLParser::UNBOUNDED);
setState(1021);
match(InsightsQLParser::FOLLOWING);
break;
}
case 4: {
setState(1022);
columnExpr(0);
setState(1023);
match(InsightsQLParser::PRECEDING);
break;
}
case 5: {
setState(1025);
columnExpr(0);
setState(1026);
match(InsightsQLParser::FOLLOWING);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ExprContext ------------------------------------------------------------------
InsightsQLParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ExprContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ExprContext::EOF() {
return getToken(InsightsQLParser::EOF, 0);
}
size_t InsightsQLParser::ExprContext::getRuleIndex() const {
return InsightsQLParser::RuleExpr;
}
std::any InsightsQLParser::ExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ExprContext* InsightsQLParser::expr() {
ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());
enterRule(_localctx, 136, InsightsQLParser::RuleExpr);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1030);
columnExpr(0);
setState(1031);
match(InsightsQLParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnTypeExprContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeExprContext::ColumnTypeExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::ColumnTypeExprContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnTypeExpr;
}
void InsightsQLParser::ColumnTypeExprContext::copyFrom(ColumnTypeExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ColumnTypeExprNestedContext ------------------------------------------------------------------
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColumnTypeExprNestedContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprNestedContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprNestedContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnTypeExprContext *> InsightsQLParser::ColumnTypeExprNestedContext::columnTypeExpr() {
return getRuleContexts<InsightsQLParser::ColumnTypeExprContext>();
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::ColumnTypeExprNestedContext::columnTypeExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnTypeExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprNestedContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnTypeExprNestedContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprNestedContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ColumnTypeExprNestedContext::ColumnTypeExprNestedContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprNestedContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprNested(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprParamContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprParamContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprParamContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprParamContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnTypeExprParamContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
InsightsQLParser::ColumnTypeExprParamContext::ColumnTypeExprParamContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprParamContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprParam(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprArrayContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::ColumnTypeExprArrayContext::columnTypeExpr() {
return getRuleContext<InsightsQLParser::ColumnTypeExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprArrayContext::LBRACKET() {
return getToken(InsightsQLParser::LBRACKET, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprArrayContext::RBRACKET() {
return getToken(InsightsQLParser::RBRACKET, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprArrayContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
InsightsQLParser::ColumnTypeExprArrayContext::ColumnTypeExprArrayContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprArrayContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprArray(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprComplexContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprComplexContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprComplexContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnTypeExprContext *> InsightsQLParser::ColumnTypeExprComplexContext::columnTypeExpr() {
return getRuleContexts<InsightsQLParser::ColumnTypeExprContext>();
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::ColumnTypeExprComplexContext::columnTypeExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnTypeExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprComplexContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnTypeExprComplexContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprComplexContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ColumnTypeExprComplexContext::ColumnTypeExprComplexContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprComplexContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprComplex(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprSimpleContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprSimpleContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
InsightsQLParser::ColumnTypeExprSimpleContext::ColumnTypeExprSimpleContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprSimpleContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprSimple(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprEnumContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprEnumContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprEnumContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::EnumValueContext *> InsightsQLParser::ColumnTypeExprEnumContext::enumValue() {
return getRuleContexts<InsightsQLParser::EnumValueContext>();
}
InsightsQLParser::EnumValueContext* InsightsQLParser::ColumnTypeExprEnumContext::enumValue(size_t i) {
return getRuleContext<InsightsQLParser::EnumValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprEnumContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnTypeExprEnumContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeExprEnumContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ColumnTypeExprEnumContext::ColumnTypeExprEnumContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprEnumContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprEnum(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeExprCompoundContext ------------------------------------------------------------------
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColumnTypeExprCompoundContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnTypeExprCompoundContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
InsightsQLParser::ColumnTypeExprCompoundContext::ColumnTypeExprCompoundContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeExprCompoundContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeExprCompound(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::columnTypeExpr() {
return columnTypeExpr(0);
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::columnTypeExpr(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
InsightsQLParser::ColumnTypeExprContext *_localctx = _tracker.createInstance<ColumnTypeExprContext>(_ctx, parentState);
InsightsQLParser::ColumnTypeExprContext *previousContext = _localctx;
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
size_t startState = 138;
enterRecursionRule(_localctx, 138, InsightsQLParser::RuleColumnTypeExpr, precedence);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1096);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<ColumnTypeExprNestedContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1034);
identifier();
setState(1035);
match(InsightsQLParser::LPAREN);
setState(1036);
identifier();
setState(1037);
columnTypeExpr(0);
setState(1044);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1038);
match(InsightsQLParser::COMMA);
setState(1039);
identifier();
setState(1040);
columnTypeExpr(0);
}
setState(1046);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx);
}
setState(1048);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1047);
match(InsightsQLParser::COMMA);
}
setState(1050);
match(InsightsQLParser::RPAREN);
break;
}
case 2: {
_localctx = _tracker.createInstance<ColumnTypeExprEnumContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1052);
identifier();
setState(1053);
match(InsightsQLParser::LPAREN);
setState(1054);
enumValue();
setState(1059);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1055);
match(InsightsQLParser::COMMA);
setState(1056);
enumValue();
}
setState(1061);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx);
}
setState(1063);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1062);
match(InsightsQLParser::COMMA);
}
setState(1065);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
_localctx = _tracker.createInstance<ColumnTypeExprComplexContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1067);
identifier();
setState(1068);
match(InsightsQLParser::LPAREN);
setState(1069);
columnTypeExpr(0);
setState(1074);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1070);
match(InsightsQLParser::COMMA);
setState(1071);
columnTypeExpr(0);
}
setState(1076);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx);
}
setState(1078);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1077);
match(InsightsQLParser::COMMA);
}
setState(1080);
match(InsightsQLParser::RPAREN);
break;
}
case 4: {
_localctx = _tracker.createInstance<ColumnTypeExprParamContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1082);
identifier();
setState(1083);
match(InsightsQLParser::LPAREN);
setState(1085);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1084);
columnExprList();
}
setState(1087);
match(InsightsQLParser::RPAREN);
break;
}
case 5: {
_localctx = _tracker.createInstance<ColumnTypeExprCompoundContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1089);
identifier();
setState(1091);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(1090);
identifier();
break;
}
default:
throw NoViableAltException(this);
}
setState(1093);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
break;
}
case 6: {
_localctx = _tracker.createInstance<ColumnTypeExprSimpleContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1095);
identifier();
break;
}
default:
break;
}
_ctx->stop = _input->LT(-1);
setState(1106);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
auto newContext = _tracker.createInstance<ColumnTypeExprArrayContext>(_tracker.createInstance<ColumnTypeExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnTypeExpr);
setState(1098);
if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1099);
match(InsightsQLParser::LBRACKET);
setState(1101);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::DECIMAL_LITERAL) {
setState(1100);
match(InsightsQLParser::DECIMAL_LITERAL);
}
setState(1103);
match(InsightsQLParser::RBRACKET);
}
setState(1108);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnTypeCastExprContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeCastExprContext::ColumnTypeCastExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::ColumnTypeCastExprContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnTypeCastExpr;
}
void InsightsQLParser::ColumnTypeCastExprContext::copyFrom(ColumnTypeCastExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ColumnTypeCastExprSimpleContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeCastIdentifierContext* InsightsQLParser::ColumnTypeCastExprSimpleContext::columnTypeCastIdentifier() {
return getRuleContext<InsightsQLParser::ColumnTypeCastIdentifierContext>(0);
}
InsightsQLParser::ColumnTypeCastExprSimpleContext::ColumnTypeCastExprSimpleContext(ColumnTypeCastExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeCastExprSimpleContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeCastExprSimple(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnTypeCastExprWithTimeZoneContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeCastIdentifierContext* InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::columnTypeCastIdentifier() {
return getRuleContext<InsightsQLParser::ColumnTypeCastIdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::TIME() {
return getToken(InsightsQLParser::TIME, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::ZONE() {
return getToken(InsightsQLParser::ZONE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::LOCAL() {
return getToken(InsightsQLParser::LOCAL, 0);
}
InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::ColumnTypeCastExprWithTimeZoneContext(ColumnTypeCastExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeCastExprWithTimeZone(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnTypeCastExprContext* InsightsQLParser::columnTypeCastExpr() {
ColumnTypeCastExprContext *_localctx = _tracker.createInstance<ColumnTypeCastExprContext>(_ctx, getState());
enterRule(_localctx, 140, InsightsQLParser::RuleColumnTypeCastExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1118);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 147, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnTypeCastExprWithTimeZoneContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1109);
columnTypeCastIdentifier();
setState(1110);
match(InsightsQLParser::WITH);
setState(1112);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LOCAL) {
setState(1111);
match(InsightsQLParser::LOCAL);
}
setState(1114);
match(InsightsQLParser::TIME);
setState(1115);
match(InsightsQLParser::ZONE);
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnTypeCastExprSimpleContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1117);
columnTypeCastIdentifier();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnTypeCastIdentifierContext ------------------------------------------------------------------
InsightsQLParser::ColumnTypeCastIdentifierContext::ColumnTypeCastIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastIdentifierContext::IDENTIFIER() {
return getToken(InsightsQLParser::IDENTIFIER, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnTypeCastIdentifierContext::QUOTED_IDENTIFIER() {
return getToken(InsightsQLParser::QUOTED_IDENTIFIER, 0);
}
InsightsQLParser::IntervalContext* InsightsQLParser::ColumnTypeCastIdentifierContext::interval() {
return getRuleContext<InsightsQLParser::IntervalContext>(0);
}
InsightsQLParser::KeywordForTypeCastContext* InsightsQLParser::ColumnTypeCastIdentifierContext::keywordForTypeCast() {
return getRuleContext<InsightsQLParser::KeywordForTypeCastContext>(0);
}
size_t InsightsQLParser::ColumnTypeCastIdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnTypeCastIdentifier;
}
std::any InsightsQLParser::ColumnTypeCastIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnTypeCastIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnTypeCastIdentifierContext* InsightsQLParser::columnTypeCastIdentifier() {
ColumnTypeCastIdentifierContext *_localctx = _tracker.createInstance<ColumnTypeCastIdentifierContext>(_ctx, getState());
enterRule(_localctx, 142, InsightsQLParser::RuleColumnTypeCastIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1124);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::IDENTIFIER: {
enterOuterAlt(_localctx, 1);
setState(1120);
match(InsightsQLParser::IDENTIFIER);
break;
}
case InsightsQLParser::QUOTED_IDENTIFIER: {
enterOuterAlt(_localctx, 2);
setState(1121);
match(InsightsQLParser::QUOTED_IDENTIFIER);
break;
}
case InsightsQLParser::DAY:
case InsightsQLParser::HOUR:
case InsightsQLParser::MINUTE:
case InsightsQLParser::MONTH:
case InsightsQLParser::QUARTER:
case InsightsQLParser::SECOND:
case InsightsQLParser::WEEK:
case InsightsQLParser::YEAR: {
enterOuterAlt(_localctx, 3);
setState(1122);
interval();
break;
}
case InsightsQLParser::DATE:
case InsightsQLParser::INTERVAL:
case InsightsQLParser::TIMESTAMP:
case InsightsQLParser::TIME: {
enterOuterAlt(_localctx, 4);
setState(1123);
keywordForTypeCast();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KeywordForTypeCastContext ------------------------------------------------------------------
InsightsQLParser::KeywordForTypeCastContext::KeywordForTypeCastContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::KeywordForTypeCastContext::DATE() {
return getToken(InsightsQLParser::DATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForTypeCastContext::TIME() {
return getToken(InsightsQLParser::TIME, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForTypeCastContext::TIMESTAMP() {
return getToken(InsightsQLParser::TIMESTAMP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForTypeCastContext::INTERVAL() {
return getToken(InsightsQLParser::INTERVAL, 0);
}
size_t InsightsQLParser::KeywordForTypeCastContext::getRuleIndex() const {
return InsightsQLParser::RuleKeywordForTypeCast;
}
std::any InsightsQLParser::KeywordForTypeCastContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKeywordForTypeCast(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KeywordForTypeCastContext* InsightsQLParser::keywordForTypeCast() {
KeywordForTypeCastContext *_localctx = _tracker.createInstance<KeywordForTypeCastContext>(_ctx, getState());
enterRule(_localctx, 144, InsightsQLParser::RuleKeywordForTypeCast);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1126);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::DATE
|| _la == InsightsQLParser::INTERVAL || _la == InsightsQLParser::TIMESTAMP
|| _la == InsightsQLParser::TIME)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnExprListContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprListContext::ColumnExprListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprListContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprListContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnExprListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::ColumnExprListContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnExprList;
}
std::any InsightsQLParser::ColumnExprListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::columnExprList() {
ColumnExprListContext *_localctx = _tracker.createInstance<ColumnExprListContext>(_ctx, getState());
enterRule(_localctx, 146, InsightsQLParser::RuleColumnExprList);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1128);
columnExpr(0);
setState(1133);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1129);
match(InsightsQLParser::COMMA);
setState(1130);
columnExpr(0);
}
setState(1135);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx);
}
setState(1137);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx)) {
case 1: {
setState(1136);
match(InsightsQLParser::COMMA);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectColumnExprListBeforeFromContext ------------------------------------------------------------------
InsightsQLParser::SelectColumnExprListBeforeFromContext::SelectColumnExprListBeforeFromContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::SelectColumnExprListBeforeFromContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectColumnExprListBeforeFrom;
}
void InsightsQLParser::SelectColumnExprListBeforeFromContext::copyFrom(SelectColumnExprListBeforeFromContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- SelectColumnExprListBeforeFromTrailingCommaContext ------------------------------------------------------------------
std::vector<InsightsQLParser::SelectColumnExprContext *> InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::selectColumnExpr() {
return getRuleContexts<InsightsQLParser::SelectColumnExprContext>();
}
InsightsQLParser::SelectColumnExprContext* InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::selectColumnExpr(size_t i) {
return getRuleContext<InsightsQLParser::SelectColumnExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::SelectColumnExprListBeforeFromTrailingCommaContext(SelectColumnExprListBeforeFromContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectColumnExprListBeforeFromTrailingComma(this);
else
return visitor->visitChildren(this);
}
//----------------- SelectColumnExprListBeforeFromPlainContext ------------------------------------------------------------------
InsightsQLParser::SelectColumnExprListContext* InsightsQLParser::SelectColumnExprListBeforeFromPlainContext::selectColumnExprList() {
return getRuleContext<InsightsQLParser::SelectColumnExprListContext>(0);
}
InsightsQLParser::SelectColumnExprListBeforeFromPlainContext::SelectColumnExprListBeforeFromPlainContext(SelectColumnExprListBeforeFromContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::SelectColumnExprListBeforeFromPlainContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectColumnExprListBeforeFromPlain(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectColumnExprListBeforeFromContext* InsightsQLParser::selectColumnExprListBeforeFrom() {
SelectColumnExprListBeforeFromContext *_localctx = _tracker.createInstance<SelectColumnExprListBeforeFromContext>(_ctx, getState());
enterRule(_localctx, 148, InsightsQLParser::RuleSelectColumnExprListBeforeFrom);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1150);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 152, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::SelectColumnExprListBeforeFromTrailingCommaContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1139);
selectColumnExpr();
setState(1144);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1140);
match(InsightsQLParser::COMMA);
setState(1141);
selectColumnExpr();
}
setState(1146);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _ctx);
}
setState(1147);
match(InsightsQLParser::COMMA);
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::SelectColumnExprListBeforeFromPlainContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1149);
selectColumnExprList();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectColumnExprListContext ------------------------------------------------------------------
InsightsQLParser::SelectColumnExprListContext::SelectColumnExprListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::SelectColumnExprContext *> InsightsQLParser::SelectColumnExprListContext::selectColumnExpr() {
return getRuleContexts<InsightsQLParser::SelectColumnExprContext>();
}
InsightsQLParser::SelectColumnExprContext* InsightsQLParser::SelectColumnExprListContext::selectColumnExpr(size_t i) {
return getRuleContext<InsightsQLParser::SelectColumnExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::SelectColumnExprListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::SelectColumnExprListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::SelectColumnExprListContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectColumnExprList;
}
std::any InsightsQLParser::SelectColumnExprListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitSelectColumnExprList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectColumnExprListContext* InsightsQLParser::selectColumnExprList() {
SelectColumnExprListContext *_localctx = _tracker.createInstance<SelectColumnExprListContext>(_ctx, getState());
enterRule(_localctx, 150, InsightsQLParser::RuleSelectColumnExprList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1152);
selectColumnExpr();
setState(1157);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1153);
match(InsightsQLParser::COMMA);
setState(1154);
selectColumnExpr();
}
setState(1159);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
}
setState(1161);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1160);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- SelectColumnExprContext ------------------------------------------------------------------
InsightsQLParser::SelectColumnExprContext::SelectColumnExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::SelectColumnExprContext::getRuleIndex() const {
return InsightsQLParser::RuleSelectColumnExpr;
}
void InsightsQLParser::SelectColumnExprContext::copyFrom(SelectColumnExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ColumnExprAliasBeforeContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprAliasBeforeContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAliasBeforeContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprAliasBeforeContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::ColumnExprAliasBeforeContext::ColumnExprAliasBeforeContext(SelectColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprAliasBeforeContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprAliasBefore(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprInvalidFromImplicitAliasContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprInvalidFromImplicitAliasContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
InsightsQLParser::ImplicitAliasContext* InsightsQLParser::ColumnExprInvalidFromImplicitAliasContext::implicitAlias() {
return getRuleContext<InsightsQLParser::ImplicitAliasContext>(0);
}
InsightsQLParser::ColumnExprInvalidFromImplicitAliasContext::ColumnExprInvalidFromImplicitAliasContext(SelectColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprInvalidFromImplicitAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprInvalidFromImplicitAlias(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprAliasImplicitContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprAliasImplicitContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::ImplicitAliasContext* InsightsQLParser::ColumnExprAliasImplicitContext::implicitAlias() {
return getRuleContext<InsightsQLParser::ImplicitAliasContext>(0);
}
InsightsQLParser::ColumnExprAliasImplicitContext::ColumnExprAliasImplicitContext(SelectColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprAliasImplicitContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprAliasImplicit(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprSelectValueContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprSelectValueContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::ColumnExprSelectValueContext::ColumnExprSelectValueContext(SelectColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprSelectValueContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprSelectValue(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::SelectColumnExprContext* InsightsQLParser::selectColumnExpr() {
SelectColumnExprContext *_localctx = _tracker.createInstance<SelectColumnExprContext>(_ctx, getState());
enterRule(_localctx, 152, InsightsQLParser::RuleSelectColumnExpr);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1173);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnExprAliasBeforeContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1163);
identifier();
setState(1164);
match(InsightsQLParser::COLON);
setState(1165);
columnExpr(0);
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnExprInvalidFromImplicitAliasContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1167);
match(InsightsQLParser::FROM);
setState(1168);
implicitAlias();
break;
}
case 3: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnExprSelectValueContext>(_localctx);
enterOuterAlt(_localctx, 3);
setState(1169);
columnExpr(0);
break;
}
case 4: {
_localctx = _tracker.createInstance<InsightsQLParser::ColumnExprAliasImplicitContext>(_localctx);
enterOuterAlt(_localctx, 4);
setState(1170);
columnExpr(0);
setState(1171);
implicitAlias();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnExprContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprContext::ColumnExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::ColumnExprContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnExpr;
}
void InsightsQLParser::ColumnExprContext::copyFrom(ColumnExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ColumnExprTernaryOpContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprTernaryOpContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprTernaryOpContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTernaryOpContext::QUERY() {
return getToken(InsightsQLParser::QUERY, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTernaryOpContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
InsightsQLParser::ColumnExprTernaryOpContext::ColumnExprTernaryOpContext(ColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTernaryOpContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTernaryOp(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprAliasContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprAliasContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAliasContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprAliasContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAliasContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::ColumnExprAliasContext::ColumnExprAliasContext(ColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprAlias(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprAndContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprAndContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprAndContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAndContext::AND() {
return getToken(InsightsQLParser::AND, 0);
}
InsightsQLParser::ColumnExprAndContext::ColumnExprAndContext(ColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprAndContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprAnd(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprValuePassthroughContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprValuePassthroughContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
InsightsQLParser::ColumnExprValuePassthroughContext::ColumnExprValuePassthroughContext(ColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprValuePassthroughContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprValuePassthrough(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprOrContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprOrContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprOrContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprOrContext::OR() {
return getToken(InsightsQLParser::OR, 0);
}
InsightsQLParser::ColumnExprOrContext::ColumnExprOrContext(ColumnExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprOrContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprOr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::columnExpr() {
return columnExpr(0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::columnExpr(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
InsightsQLParser::ColumnExprContext *_localctx = _tracker.createInstance<ColumnExprContext>(_ctx, parentState);
InsightsQLParser::ColumnExprContext *previousContext = _localctx;
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
size_t startState = 154;
enterRecursionRule(_localctx, 154, InsightsQLParser::RuleColumnExpr, precedence);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
_localctx = _tracker.createInstance<ColumnExprValuePassthroughContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1176);
columnExprValue(0);
_ctx->stop = _input->LT(-1);
setState(1198);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
setState(1196);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 157, _ctx)) {
case 1: {
auto newContext = _tracker.createInstance<ColumnExprAndContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
setState(1178);
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1179);
match(InsightsQLParser::AND);
setState(1180);
columnExpr(6);
break;
}
case 2: {
auto newContext = _tracker.createInstance<ColumnExprOrContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
setState(1181);
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1182);
match(InsightsQLParser::OR);
setState(1183);
columnExpr(5);
break;
}
case 3: {
auto newContext = _tracker.createInstance<ColumnExprTernaryOpContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
setState(1184);
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1185);
match(InsightsQLParser::QUERY);
setState(1186);
columnExpr(0);
setState(1187);
match(InsightsQLParser::COLON);
setState(1188);
columnExpr(3);
break;
}
case 4: {
auto newContext = _tracker.createInstance<ColumnExprAliasContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
setState(1190);
if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1191);
match(InsightsQLParser::AS);
setState(1194);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::ALL:
case InsightsQLParser::AND:
case InsightsQLParser::ANTI:
case InsightsQLParser::ANY:
case InsightsQLParser::ARRAY:
case InsightsQLParser::AS:
case InsightsQLParser::ASCENDING:
case InsightsQLParser::ASOF:
case InsightsQLParser::BETWEEN:
case InsightsQLParser::BOTH:
case InsightsQLParser::BY:
case InsightsQLParser::CASE:
case InsightsQLParser::CAST:
case InsightsQLParser::COHORT:
case InsightsQLParser::COLLATE:
case InsightsQLParser::COLUMNS:
case InsightsQLParser::CROSS:
case InsightsQLParser::CUBE:
case InsightsQLParser::CURRENT:
case InsightsQLParser::DATE:
case InsightsQLParser::DAY:
case InsightsQLParser::DESC:
case InsightsQLParser::DESCENDING:
case InsightsQLParser::DISTINCT:
case InsightsQLParser::ELSE:
case InsightsQLParser::END:
case InsightsQLParser::EXCLUDE:
case InsightsQLParser::EXTRACT:
case InsightsQLParser::FINAL:
case InsightsQLParser::FILL:
case InsightsQLParser::FILTER:
case InsightsQLParser::FIRST:
case InsightsQLParser::FOLLOWING:
case InsightsQLParser::FOR:
case InsightsQLParser::FROM:
case InsightsQLParser::FULL:
case InsightsQLParser::GROUP:
case InsightsQLParser::GROUPING:
case InsightsQLParser::HAVING:
case InsightsQLParser::HOUR:
case InsightsQLParser::ID:
case InsightsQLParser::IF:
case InsightsQLParser::ILIKE:
case InsightsQLParser::IGNORE:
case InsightsQLParser::INCLUDE:
case InsightsQLParser::IN:
case InsightsQLParser::INNER:
case InsightsQLParser::INTERPOLATE:
case InsightsQLParser::INTERVAL:
case InsightsQLParser::IS:
case InsightsQLParser::JOIN:
case InsightsQLParser::KEY:
case InsightsQLParser::LAMBDA:
case InsightsQLParser::LAST:
case InsightsQLParser::LEADING:
case InsightsQLParser::LEFT:
case InsightsQLParser::LIKE:
case InsightsQLParser::LIMIT:
case InsightsQLParser::MINUTE:
case InsightsQLParser::MONTH:
case InsightsQLParser::NAME:
case InsightsQLParser::NATURAL:
case InsightsQLParser::NOT:
case InsightsQLParser::NULLS:
case InsightsQLParser::OFFSET:
case InsightsQLParser::ON:
case InsightsQLParser::OR:
case InsightsQLParser::ORDER:
case InsightsQLParser::OUTER:
case InsightsQLParser::OVER:
case InsightsQLParser::PARTITION:
case InsightsQLParser::PIVOT:
case InsightsQLParser::POSITIONAL:
case InsightsQLParser::PRECEDING:
case InsightsQLParser::PREWHERE:
case InsightsQLParser::QUALIFY:
case InsightsQLParser::QUARTER:
case InsightsQLParser::RANGE:
case InsightsQLParser::RECURSIVE:
case InsightsQLParser::REPLACE:
case InsightsQLParser::RETURN:
case InsightsQLParser::RIGHT:
case InsightsQLParser::ROLLUP:
case InsightsQLParser::ROW:
case InsightsQLParser::ROWS:
case InsightsQLParser::SAMPLE:
case InsightsQLParser::SECOND:
case InsightsQLParser::SELECT:
case InsightsQLParser::SEMI:
case InsightsQLParser::SETS:
case InsightsQLParser::SETTINGS:
case InsightsQLParser::STEP:
case InsightsQLParser::SUBSTRING:
case InsightsQLParser::THEN:
case InsightsQLParser::TIES:
case InsightsQLParser::TIMESTAMP:
case InsightsQLParser::TIME:
case InsightsQLParser::LOCAL:
case InsightsQLParser::ZONE:
case InsightsQLParser::TO:
case InsightsQLParser::TOP:
case InsightsQLParser::TOTALS:
case InsightsQLParser::TRAILING:
case InsightsQLParser::TRIM:
case InsightsQLParser::TRUNCATE:
case InsightsQLParser::TRY_CAST:
case InsightsQLParser::UNBOUNDED:
case InsightsQLParser::UNION:
case InsightsQLParser::UNPIVOT:
case InsightsQLParser::USING:
case InsightsQLParser::VALUES:
case InsightsQLParser::WEEK:
case InsightsQLParser::WHEN:
case InsightsQLParser::WHERE:
case InsightsQLParser::WINDOW:
case InsightsQLParser::WITH:
case InsightsQLParser::YEAR:
case InsightsQLParser::IDENTIFIER:
case InsightsQLParser::QUOTED_IDENTIFIER: {
setState(1192);
identifier();
break;
}
case InsightsQLParser::STRING_LITERAL: {
setState(1193);
match(InsightsQLParser::STRING_LITERAL);
break;
}
default:
throw NoViableAltException(this);
}
break;
}
default:
break;
}
}
setState(1200);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnExprValueContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext::ColumnExprValueContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::ColumnExprValueContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnExprValue;
}
void InsightsQLParser::ColumnExprValueContext::copyFrom(ColumnExprValueContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ColumnExprColumnsAllContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsAllContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsAllContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsAllContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsAllContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprColumnsAllContext::ColumnExprColumnsAllContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsAllContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsAll(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNegateContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprNegateContext::DASH() {
return getToken(InsightsQLParser::DASH, 0);
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNegateContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
InsightsQLParser::ColumnExprNegateContext::ColumnExprNegateContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNegateContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNegate(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprLiteralContext ------------------------------------------------------------------
InsightsQLParser::LiteralContext* InsightsQLParser::ColumnExprLiteralContext::literal() {
return getRuleContext<InsightsQLParser::LiteralContext>(0);
}
InsightsQLParser::ColumnExprLiteralContext::ColumnExprLiteralContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprLiteral(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprArrayContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprArrayContext::LBRACKET() {
return getToken(InsightsQLParser::LBRACKET, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArrayContext::RBRACKET() {
return getToken(InsightsQLParser::RBRACKET, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArrayContext::ARRAY() {
return getToken(InsightsQLParser::ARRAY, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprArrayContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
InsightsQLParser::ColumnExprArrayContext::ColumnExprArrayContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprArrayContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprArray(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprPrecedence1Context ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprPrecedence1Context::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprPrecedence1Context::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence1Context::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence1Context::SLASH() {
return getToken(InsightsQLParser::SLASH, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence1Context::PERCENT() {
return getToken(InsightsQLParser::PERCENT, 0);
}
InsightsQLParser::ColumnExprPrecedence1Context::ColumnExprPrecedence1Context(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprPrecedence1Context::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprPrecedence1(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprPrecedence2Context ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprPrecedence2Context::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprPrecedence2Context::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence2Context::PLUS() {
return getToken(InsightsQLParser::PLUS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence2Context::DASH() {
return getToken(InsightsQLParser::DASH, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence2Context::CONCAT() {
return getToken(InsightsQLParser::CONCAT, 0);
}
InsightsQLParser::ColumnExprPrecedence2Context::ColumnExprPrecedence2Context(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprPrecedence2Context::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprPrecedence2(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNullSafeEqContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprNullSafeEqContext::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNullSafeEqContext::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullSafeEqContext::NULL_SAFE_EQ() {
return getToken(InsightsQLParser::NULL_SAFE_EQ, 0);
}
InsightsQLParser::ColumnExprNullSafeEqContext::ColumnExprNullSafeEqContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNullSafeEqContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNullSafeEq(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprPrecedence3Context ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprPrecedence3Context::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprPrecedence3Context::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::IN() {
return getToken(InsightsQLParser::IN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::EQ_DOUBLE() {
return getToken(InsightsQLParser::EQ_DOUBLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::EQ_SINGLE() {
return getToken(InsightsQLParser::EQ_SINGLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::NOT_EQ() {
return getToken(InsightsQLParser::NOT_EQ, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::LT_EQ() {
return getToken(InsightsQLParser::LT_EQ, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::LT() {
return getToken(InsightsQLParser::LT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::GT_EQ() {
return getToken(InsightsQLParser::GT_EQ, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::GT() {
return getToken(InsightsQLParser::GT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::LIKE() {
return getToken(InsightsQLParser::LIKE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::ILIKE() {
return getToken(InsightsQLParser::ILIKE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::REGEX_SINGLE() {
return getToken(InsightsQLParser::REGEX_SINGLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::REGEX_DOUBLE() {
return getToken(InsightsQLParser::REGEX_DOUBLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::NOT_REGEX() {
return getToken(InsightsQLParser::NOT_REGEX, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::IREGEX_SINGLE() {
return getToken(InsightsQLParser::IREGEX_SINGLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::IREGEX_DOUBLE() {
return getToken(InsightsQLParser::IREGEX_DOUBLE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::NOT_IREGEX() {
return getToken(InsightsQLParser::NOT_IREGEX, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::COHORT() {
return getToken(InsightsQLParser::COHORT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPrecedence3Context::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::ColumnExprPrecedence3Context::ColumnExprPrecedence3Context(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprPrecedence3Context::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprPrecedence3(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIntervalContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprIntervalContext::INTERVAL() {
return getToken(InsightsQLParser::INTERVAL, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprIntervalContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::IntervalContext* InsightsQLParser::ColumnExprIntervalContext::interval() {
return getRuleContext<InsightsQLParser::IntervalContext>(0);
}
InsightsQLParser::ColumnExprIntervalContext::ColumnExprIntervalContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprInterval(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIsNullContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprIsNullContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsNullContext::IS() {
return getToken(InsightsQLParser::IS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsNullContext::NULL_SQL() {
return getToken(InsightsQLParser::NULL_SQL, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsNullContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::ColumnExprIsNullContext::ColumnExprIsNullContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIsNullContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprIsNull(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprWinFunctionTargetContext ------------------------------------------------------------------
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColumnExprWinFunctionTargetContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprWinFunctionTargetContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::OVER() {
return getToken(InsightsQLParser::OVER, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprWinFunctionTargetContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprWinFunctionTargetContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::FILTER() {
return getToken(InsightsQLParser::FILTER, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::WHERE() {
return getToken(InsightsQLParser::WHERE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprWinFunctionTargetContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::ColumnExprWinFunctionTargetContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprWinFunctionTargetContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionTargetContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
InsightsQLParser::ColumnExprWinFunctionTargetContext::ColumnExprWinFunctionTargetContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprWinFunctionTargetContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprWinFunctionTarget(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNamedArgContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprNamedArgContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNamedArgContext::COLONEQUALS() {
return getToken(InsightsQLParser::COLONEQUALS, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprNamedArgContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::ColumnExprNamedArgContext::ColumnExprNamedArgContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNamedArgContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNamedArg(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNullPropertyAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNullPropertyAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullPropertyAccessContext::NULL_PROPERTY() {
return getToken(InsightsQLParser::NULL_PROPERTY, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprNullPropertyAccessContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
InsightsQLParser::ColumnExprNullPropertyAccessContext::ColumnExprNullPropertyAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNullPropertyAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNullPropertyAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIntervalStringContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprIntervalStringContext::INTERVAL() {
return getToken(InsightsQLParser::INTERVAL, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIntervalStringContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::ColumnExprIntervalStringContext::ColumnExprIntervalStringContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIntervalStringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprIntervalString(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTagElementContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxTagElementContext* InsightsQLParser::ColumnExprTagElementContext::insightsqlxTagElement() {
return getRuleContext<InsightsQLParser::InsightsqlxTagElementContext>(0);
}
InsightsQLParser::ColumnExprTagElementContext::ColumnExprTagElementContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTagElementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTagElement(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprCallContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprCallContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCallContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCallContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprCallContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
InsightsQLParser::ColumnExprCallContext::ColumnExprCallContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprCallContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprCall(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprArrayAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprArrayAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArrayAccessContext::LBRACKET() {
return getToken(InsightsQLParser::LBRACKET, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprArrayAccessContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArrayAccessContext::RBRACKET() {
return getToken(InsightsQLParser::RBRACKET, 0);
}
InsightsQLParser::ColumnExprArrayAccessContext::ColumnExprArrayAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprArrayAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprArrayAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprBetweenContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprBetweenContext::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprBetweenContext::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprBetweenContext::BETWEEN() {
return getToken(InsightsQLParser::BETWEEN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprBetweenContext::AND() {
return getToken(InsightsQLParser::AND, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprBetweenContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::ColumnExprBetweenContext::ColumnExprBetweenContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprBetween(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprParensContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprParensContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprParensContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprParensContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprParensContext::ColumnExprParensContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprParensContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprParens(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTimestampContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprTimestampContext::TIMESTAMP() {
return getToken(InsightsQLParser::TIMESTAMP, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTimestampContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::ColumnExprTimestampContext::ColumnExprTimestampContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTimestampContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTimestamp(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsQualifiedExcludeContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::ColumnExprColumnsQualifiedExcludeContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsQualifiedExcludeContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsQualifiedExclude(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNotContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprNotContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNotContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
InsightsQLParser::ColumnExprNotContext::ColumnExprNotContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNotContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNot(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprFunctionContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprFunctionContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprFunctionContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprFunctionContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::ORDER() {
return getToken(InsightsQLParser::ORDER, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::OrderExprListContext* InsightsQLParser::ColumnExprFunctionContext::orderExprList() {
return getRuleContext<InsightsQLParser::OrderExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::FILTER() {
return getToken(InsightsQLParser::FILTER, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionContext::WHERE() {
return getToken(InsightsQLParser::WHERE, 0);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::ColumnExprFunctionContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprFunctionContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprFunctionContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::ColumnExprFunctionContext::ColumnExprFunctionContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprFunction(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprDictContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprDictContext::LBRACE() {
return getToken(InsightsQLParser::LBRACE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprDictContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
InsightsQLParser::KvPairListContext* InsightsQLParser::ColumnExprDictContext::kvPairList() {
return getRuleContext<InsightsQLParser::KvPairListContext>(0);
}
InsightsQLParser::ColumnExprDictContext::ColumnExprDictContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprDictContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprDict(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprSubqueryContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprSubqueryContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::ColumnExprSubqueryContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSubqueryContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprSubqueryContext::ColumnExprSubqueryContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprSubquery(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprSubstringContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprSubstringContext::SUBSTRING() {
return getToken(InsightsQLParser::SUBSTRING, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSubstringContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprSubstringContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprSubstringContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSubstringContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSubstringContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSubstringContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
InsightsQLParser::ColumnExprSubstringContext::ColumnExprSubstringContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprSubstringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprSubstring(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprCastContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprCastContext::CAST() {
return getToken(InsightsQLParser::CAST, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCastContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprCastContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCastContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::ColumnExprCastContext::columnTypeExpr() {
return getRuleContext<InsightsQLParser::ColumnTypeExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCastContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprCastContext::ColumnExprCastContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprCastContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprCast(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprArraySliceContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprArraySliceContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArraySliceContext::LBRACKET() {
return getToken(InsightsQLParser::LBRACKET, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArraySliceContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprArraySliceContext::RBRACKET() {
return getToken(InsightsQLParser::RBRACKET, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprArraySliceContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprArraySliceContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
InsightsQLParser::ColumnExprArraySliceContext::ColumnExprArraySliceContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprArraySliceContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprArraySlice(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsQualifiedReplaceContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::REPLACE() {
return getToken(InsightsQLParser::REPLACE, 0);
}
InsightsQLParser::ColumnsReplaceListContext* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::columnsReplaceList() {
return getRuleContext<InsightsQLParser::ColumnsReplaceListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::ColumnExprColumnsQualifiedReplaceContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsQualifiedReplaceContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsQualifiedReplace(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNullTupleAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNullTupleAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullTupleAccessContext::NULL_PROPERTY() {
return getToken(InsightsQLParser::NULL_PROPERTY, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullTupleAccessContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
InsightsQLParser::ColumnExprNullTupleAccessContext::ColumnExprNullTupleAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNullTupleAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNullTupleAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprFunctionWithinGroupContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprFunctionWithinGroupContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionWithinGroupContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprFunctionWithinGroupContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::WithinGroupClauseContext* InsightsQLParser::ColumnExprFunctionWithinGroupContext::withinGroupClause() {
return getRuleContext<InsightsQLParser::WithinGroupClauseContext>(0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprFunctionWithinGroupContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
InsightsQLParser::ColumnExprFunctionWithinGroupContext::ColumnExprFunctionWithinGroupContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprFunctionWithinGroupContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprFunctionWithinGroup(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprPositionalContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprPositionalContext::HASH() {
return getToken(InsightsQLParser::HASH, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPositionalContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
InsightsQLParser::ColumnExprPositionalContext::ColumnExprPositionalContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprPositionalContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprPositional(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsRegexContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsRegexContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsRegexContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsRegexContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsRegexContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprColumnsRegexContext::ColumnExprColumnsRegexContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsRegexContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsRegex(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTypeCastContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprTypeCastContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTypeCastContext::DOUBLECOLON() {
return getToken(InsightsQLParser::DOUBLECOLON, 0);
}
InsightsQLParser::ColumnTypeCastExprContext* InsightsQLParser::ColumnExprTypeCastContext::columnTypeCastExpr() {
return getRuleContext<InsightsQLParser::ColumnTypeCastExprContext>(0);
}
InsightsQLParser::ColumnExprTypeCastContext::ColumnExprTypeCastContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTypeCastContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTypeCast(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIsDistinctFromContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprIsDistinctFromContext::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprIsDistinctFromContext::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsDistinctFromContext::IS() {
return getToken(InsightsQLParser::IS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsDistinctFromContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsDistinctFromContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIsDistinctFromContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::ColumnExprIsDistinctFromContext::ColumnExprIsDistinctFromContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIsDistinctFromContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprIsDistinctFrom(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprSpreadColumnsListContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsListContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsListContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsListContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprSpreadColumnsListContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsListContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprSpreadColumnsListContext::ColumnExprSpreadColumnsListContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprSpreadColumnsListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprSpreadColumnsList(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsExcludeReplaceContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::REPLACE() {
return getToken(InsightsQLParser::REPLACE, 0);
}
InsightsQLParser::ColumnsReplaceListContext* InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::columnsReplaceList() {
return getRuleContext<InsightsQLParser::ColumnsReplaceListContext>(0);
}
InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::ColumnExprColumnsExcludeReplaceContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsExcludeReplaceContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsExcludeReplace(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsQualifiedExcludeReplaceContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::REPLACE() {
return getToken(InsightsQLParser::REPLACE, 0);
}
InsightsQLParser::ColumnsReplaceListContext* InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::columnsReplaceList() {
return getRuleContext<InsightsQLParser::ColumnsReplaceListContext>(0);
}
InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::ColumnExprColumnsQualifiedExcludeReplaceContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsQualifiedExcludeReplaceContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsQualifiedExcludeReplace(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsExcludeContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsExcludeContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::ColumnExprColumnsExcludeContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsExcludeContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsExcludeContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
InsightsQLParser::ColumnExprColumnsExcludeContext::ColumnExprColumnsExcludeContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsExcludeContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsExclude(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColonLambdaContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColonLambdaContext::LAMBDA() {
return getToken(InsightsQLParser::LAMBDA, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColumnExprColonLambdaContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprColonLambdaContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColonLambdaContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprColonLambdaContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColonLambdaContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColonLambdaContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ColumnExprColonLambdaContext::ColumnExprColonLambdaContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColonLambdaContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColonLambda(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprCallSelectContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprCallSelectContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCallSelectContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::ColumnExprCallSelectContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCallSelectContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprCallSelectContext::ColumnExprCallSelectContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprCallSelectContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprCallSelect(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsQualifiedAllContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsQualifiedAllContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprColumnsQualifiedAllContext::ColumnExprColumnsQualifiedAllContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsQualifiedAllContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsQualifiedAll(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTrimContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::TRIM() {
return getToken(InsightsQLParser::TRIM, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::StringContext* InsightsQLParser::ColumnExprTrimContext::string() {
return getRuleContext<InsightsQLParser::StringContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprTrimContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::BOTH() {
return getToken(InsightsQLParser::BOTH, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::LEADING() {
return getToken(InsightsQLParser::LEADING, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTrimContext::TRAILING() {
return getToken(InsightsQLParser::TRAILING, 0);
}
InsightsQLParser::ColumnExprTrimContext::ColumnExprTrimContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTrimContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTrim(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTemplateStringContext ------------------------------------------------------------------
InsightsQLParser::TemplateStringContext* InsightsQLParser::ColumnExprTemplateStringContext::templateString() {
return getRuleContext<InsightsQLParser::TemplateStringContext>(0);
}
InsightsQLParser::ColumnExprTemplateStringContext::ColumnExprTemplateStringContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTemplateString(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTupleContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprTupleContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprTupleContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTupleContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprTupleContext::ColumnExprTupleContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTupleContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTuple(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTryCastContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprTryCastContext::TRY_CAST() {
return getToken(InsightsQLParser::TRY_CAST, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTryCastContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprTryCastContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTryCastContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::ColumnTypeExprContext* InsightsQLParser::ColumnExprTryCastContext::columnTypeExpr() {
return getRuleContext<InsightsQLParser::ColumnTypeExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTryCastContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprTryCastContext::ColumnExprTryCastContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTryCastContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTryCast(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsListContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsListContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsListContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprColumnsListContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsListContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprColumnsListContext::ColumnExprColumnsListContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsList(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprColumnsReplaceContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsReplaceContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsReplaceContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsReplaceContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsReplaceContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsReplaceContext::REPLACE() {
return getToken(InsightsQLParser::REPLACE, 0);
}
InsightsQLParser::ColumnsReplaceListContext* InsightsQLParser::ColumnExprColumnsReplaceContext::columnsReplaceList() {
return getRuleContext<InsightsQLParser::ColumnsReplaceListContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprColumnsReplaceContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprColumnsReplaceContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
InsightsQLParser::ColumnExprColumnsReplaceContext::ColumnExprColumnsReplaceContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprColumnsReplaceContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprColumnsReplace(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprSpreadColumnsRegexContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsRegexContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsRegexContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsRegexContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsRegexContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprSpreadColumnsRegexContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprSpreadColumnsRegexContext::ColumnExprSpreadColumnsRegexContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprSpreadColumnsRegexContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprSpreadColumnsRegex(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprPropertyAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprPropertyAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprPropertyAccessContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprPropertyAccessContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
InsightsQLParser::ColumnExprPropertyAccessContext::ColumnExprPropertyAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprPropertyAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprPropertyAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNullArrayAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNullArrayAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullArrayAccessContext::NULL_PROPERTY() {
return getToken(InsightsQLParser::NULL_PROPERTY, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullArrayAccessContext::LBRACKET() {
return getToken(InsightsQLParser::LBRACKET, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprNullArrayAccessContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullArrayAccessContext::RBRACKET() {
return getToken(InsightsQLParser::RBRACKET, 0);
}
InsightsQLParser::ColumnExprNullArrayAccessContext::ColumnExprNullArrayAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNullArrayAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNullArrayAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIgnoreNullsContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprIgnoreNullsContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIgnoreNullsContext::IGNORE() {
return getToken(InsightsQLParser::IGNORE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprIgnoreNullsContext::NULLS() {
return getToken(InsightsQLParser::NULLS, 0);
}
InsightsQLParser::ColumnExprIgnoreNullsContext::ColumnExprIgnoreNullsContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIgnoreNullsContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprIgnoreNulls(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprNullishContext ------------------------------------------------------------------
std::vector<InsightsQLParser::ColumnExprValueContext *> InsightsQLParser::ColumnExprNullishContext::columnExprValue() {
return getRuleContexts<InsightsQLParser::ColumnExprValueContext>();
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprNullishContext::columnExprValue(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprNullishContext::NULLISH() {
return getToken(InsightsQLParser::NULLISH, 0);
}
InsightsQLParser::ColumnExprNullishContext::ColumnExprNullishContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprNullishContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprNullish(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprTupleAccessContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::ColumnExprTupleAccessContext::columnExprValue() {
return getRuleContext<InsightsQLParser::ColumnExprValueContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTupleAccessContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTupleAccessContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
InsightsQLParser::ColumnExprTupleAccessContext::ColumnExprTupleAccessContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprTupleAccessContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTupleAccess(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprCaseContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprCaseContext::CASE() {
return getToken(InsightsQLParser::CASE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCaseContext::END() {
return getToken(InsightsQLParser::END, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprCaseContext::WHEN() {
return getTokens(InsightsQLParser::WHEN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCaseContext::WHEN(size_t i) {
return getToken(InsightsQLParser::WHEN, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprCaseContext::THEN() {
return getTokens(InsightsQLParser::THEN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCaseContext::THEN(size_t i) {
return getToken(InsightsQLParser::THEN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprCaseContext::ELSE() {
return getToken(InsightsQLParser::ELSE, 0);
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::ColumnExprCaseContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprCaseContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
InsightsQLParser::ColumnExprCaseContext::ColumnExprCaseContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprCaseContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprCase(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprDateContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprDateContext::DATE() {
return getToken(InsightsQLParser::DATE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprDateContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::ColumnExprDateContext::ColumnExprDateContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprDateContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprDate(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprWinFunctionContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnExprWinFunctionContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::OVER() {
return getToken(InsightsQLParser::OVER, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprWinFunctionContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
InsightsQLParser::WindowExprContext* InsightsQLParser::ColumnExprWinFunctionContext::windowExpr() {
return getRuleContext<InsightsQLParser::WindowExprContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnExprWinFunctionContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::FILTER() {
return getToken(InsightsQLParser::FILTER, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::WHERE() {
return getToken(InsightsQLParser::WHERE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprWinFunctionContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::ColumnExprWinFunctionContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprWinFunctionContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnExprWinFunctionContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
InsightsQLParser::ColumnExprWinFunctionContext::ColumnExprWinFunctionContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprWinFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprWinFunction(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprLambdaContext ------------------------------------------------------------------
InsightsQLParser::ColumnLambdaExprContext* InsightsQLParser::ColumnExprLambdaContext::columnLambdaExpr() {
return getRuleContext<InsightsQLParser::ColumnLambdaExprContext>(0);
}
InsightsQLParser::ColumnExprLambdaContext::ColumnExprLambdaContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprLambdaContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprLambda(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprIdentifierContext ------------------------------------------------------------------
InsightsQLParser::ColumnIdentifierContext* InsightsQLParser::ColumnExprIdentifierContext::columnIdentifier() {
return getRuleContext<InsightsQLParser::ColumnIdentifierContext>(0);
}
InsightsQLParser::ColumnExprIdentifierContext::ColumnExprIdentifierContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprIdentifier(this);
else
return visitor->visitChildren(this);
}
//----------------- ColumnExprAsteriskContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColumnExprAsteriskContext::ASTERISK() {
return getToken(InsightsQLParser::ASTERISK, 0);
}
InsightsQLParser::TableIdentifierContext* InsightsQLParser::ColumnExprAsteriskContext::tableIdentifier() {
return getRuleContext<InsightsQLParser::TableIdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAsteriskContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAsteriskContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAsteriskContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::IdentifierListContext* InsightsQLParser::ColumnExprAsteriskContext::identifierList() {
return getRuleContext<InsightsQLParser::IdentifierListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprAsteriskContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprAsteriskContext::ColumnExprAsteriskContext(ColumnExprValueContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColumnExprAsteriskContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprAsterisk(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::columnExprValue() {
return columnExprValue(0);
}
InsightsQLParser::ColumnExprValueContext* InsightsQLParser::columnExprValue(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
InsightsQLParser::ColumnExprValueContext *_localctx = _tracker.createInstance<ColumnExprValueContext>(_ctx, parentState);
InsightsQLParser::ColumnExprValueContext *previousContext = _localctx;
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
size_t startState = 156;
enterRecursionRule(_localctx, 156, InsightsQLParser::RuleColumnExprValue, precedence);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1550);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 189, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<ColumnExprCaseContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1202);
match(InsightsQLParser::CASE);
setState(1204);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _ctx)) {
case 1: {
setState(1203);
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->caseExpr = columnExpr(0);
break;
}
default:
break;
}
setState(1211);
_errHandler->sync(this);
_la = _input->LA(1);
do {
setState(1206);
match(InsightsQLParser::WHEN);
setState(1207);
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->whenExpr = columnExpr(0);
setState(1208);
match(InsightsQLParser::THEN);
setState(1209);
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->thenExpr = columnExpr(0);
setState(1213);
_errHandler->sync(this);
_la = _input->LA(1);
} while (_la == InsightsQLParser::WHEN);
setState(1217);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::ELSE) {
setState(1215);
match(InsightsQLParser::ELSE);
setState(1216);
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->elseExpr = columnExpr(0);
}
setState(1219);
match(InsightsQLParser::END);
break;
}
case 2: {
_localctx = _tracker.createInstance<ColumnExprCastContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1221);
match(InsightsQLParser::CAST);
setState(1222);
match(InsightsQLParser::LPAREN);
setState(1223);
columnExpr(0);
setState(1224);
match(InsightsQLParser::AS);
setState(1225);
columnTypeExpr(0);
setState(1226);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
_localctx = _tracker.createInstance<ColumnExprTryCastContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1228);
match(InsightsQLParser::TRY_CAST);
setState(1229);
match(InsightsQLParser::LPAREN);
setState(1230);
columnExpr(0);
setState(1231);
match(InsightsQLParser::AS);
setState(1232);
columnTypeExpr(0);
setState(1233);
match(InsightsQLParser::RPAREN);
break;
}
case 4: {
_localctx = _tracker.createInstance<ColumnExprDateContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1235);
match(InsightsQLParser::DATE);
setState(1236);
match(InsightsQLParser::STRING_LITERAL);
break;
}
case 5: {
_localctx = _tracker.createInstance<ColumnExprIntervalContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1237);
match(InsightsQLParser::INTERVAL);
setState(1238);
columnExpr(0);
setState(1239);
interval();
break;
}
case 6: {
_localctx = _tracker.createInstance<ColumnExprIntervalStringContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1241);
match(InsightsQLParser::INTERVAL);
setState(1242);
match(InsightsQLParser::STRING_LITERAL);
break;
}
case 7: {
_localctx = _tracker.createInstance<ColumnExprSubstringContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1243);
match(InsightsQLParser::SUBSTRING);
setState(1244);
match(InsightsQLParser::LPAREN);
setState(1245);
columnExpr(0);
setState(1246);
match(InsightsQLParser::FROM);
setState(1247);
columnExpr(0);
setState(1250);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FOR) {
setState(1248);
match(InsightsQLParser::FOR);
setState(1249);
columnExpr(0);
}
setState(1252);
match(InsightsQLParser::RPAREN);
break;
}
case 8: {
_localctx = _tracker.createInstance<ColumnExprTimestampContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1254);
match(InsightsQLParser::TIMESTAMP);
setState(1255);
match(InsightsQLParser::STRING_LITERAL);
break;
}
case 9: {
_localctx = _tracker.createInstance<ColumnExprTrimContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1256);
match(InsightsQLParser::TRIM);
setState(1257);
match(InsightsQLParser::LPAREN);
setState(1258);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::BOTH
|| _la == InsightsQLParser::LEADING || _la == InsightsQLParser::TRAILING)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1259);
string();
setState(1260);
match(InsightsQLParser::FROM);
setState(1261);
columnExpr(0);
setState(1262);
match(InsightsQLParser::RPAREN);
break;
}
case 10: {
_localctx = _tracker.createInstance<ColumnExprColumnsRegexContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1264);
match(InsightsQLParser::COLUMNS);
setState(1265);
match(InsightsQLParser::LPAREN);
setState(1266);
match(InsightsQLParser::STRING_LITERAL);
setState(1267);
match(InsightsQLParser::RPAREN);
break;
}
case 11: {
_localctx = _tracker.createInstance<ColumnExprColumnsListContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1268);
match(InsightsQLParser::COLUMNS);
setState(1269);
match(InsightsQLParser::LPAREN);
setState(1270);
columnExprList();
setState(1271);
match(InsightsQLParser::RPAREN);
break;
}
case 12: {
_localctx = _tracker.createInstance<ColumnExprColumnsExcludeReplaceContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1298);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::COLUMNS: {
setState(1273);
match(InsightsQLParser::COLUMNS);
setState(1274);
match(InsightsQLParser::LPAREN);
setState(1275);
match(InsightsQLParser::ASTERISK);
setState(1276);
match(InsightsQLParser::EXCLUDE);
setState(1277);
match(InsightsQLParser::LPAREN);
setState(1278);
identifierList();
setState(1279);
match(InsightsQLParser::RPAREN);
setState(1280);
match(InsightsQLParser::REPLACE);
setState(1281);
match(InsightsQLParser::LPAREN);
setState(1282);
columnsReplaceList();
setState(1283);
match(InsightsQLParser::RPAREN);
setState(1284);
match(InsightsQLParser::RPAREN);
break;
}
case InsightsQLParser::LPAREN: {
setState(1286);
match(InsightsQLParser::LPAREN);
setState(1287);
match(InsightsQLParser::ASTERISK);
setState(1288);
match(InsightsQLParser::EXCLUDE);
setState(1289);
match(InsightsQLParser::LPAREN);
setState(1290);
identifierList();
setState(1291);
match(InsightsQLParser::RPAREN);
setState(1292);
match(InsightsQLParser::REPLACE);
setState(1293);
match(InsightsQLParser::LPAREN);
setState(1294);
columnsReplaceList();
setState(1295);
match(InsightsQLParser::RPAREN);
setState(1296);
match(InsightsQLParser::RPAREN);
break;
}
default:
throw NoViableAltException(this);
}
break;
}
case 13: {
_localctx = _tracker.createInstance<ColumnExprColumnsExcludeContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1300);
match(InsightsQLParser::COLUMNS);
setState(1301);
match(InsightsQLParser::LPAREN);
setState(1302);
match(InsightsQLParser::ASTERISK);
setState(1303);
match(InsightsQLParser::EXCLUDE);
setState(1304);
match(InsightsQLParser::LPAREN);
setState(1305);
identifierList();
setState(1306);
match(InsightsQLParser::RPAREN);
setState(1307);
match(InsightsQLParser::RPAREN);
break;
}
case 14: {
_localctx = _tracker.createInstance<ColumnExprColumnsReplaceContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1326);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::COLUMNS: {
setState(1309);
match(InsightsQLParser::COLUMNS);
setState(1310);
match(InsightsQLParser::LPAREN);
setState(1311);
match(InsightsQLParser::ASTERISK);
setState(1312);
match(InsightsQLParser::REPLACE);
setState(1313);
match(InsightsQLParser::LPAREN);
setState(1314);
columnsReplaceList();
setState(1315);
match(InsightsQLParser::RPAREN);
setState(1316);
match(InsightsQLParser::RPAREN);
break;
}
case InsightsQLParser::LPAREN: {
setState(1318);
match(InsightsQLParser::LPAREN);
setState(1319);
match(InsightsQLParser::ASTERISK);
setState(1320);
match(InsightsQLParser::REPLACE);
setState(1321);
match(InsightsQLParser::LPAREN);
setState(1322);
columnsReplaceList();
setState(1323);
match(InsightsQLParser::RPAREN);
setState(1324);
match(InsightsQLParser::RPAREN);
break;
}
default:
throw NoViableAltException(this);
}
break;
}
case 15: {
_localctx = _tracker.createInstance<ColumnExprColumnsAllContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1328);
match(InsightsQLParser::COLUMNS);
setState(1329);
match(InsightsQLParser::LPAREN);
setState(1330);
match(InsightsQLParser::ASTERISK);
setState(1331);
match(InsightsQLParser::RPAREN);
break;
}
case 16: {
_localctx = _tracker.createInstance<ColumnExprColumnsQualifiedExcludeReplaceContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1332);
match(InsightsQLParser::COLUMNS);
setState(1333);
match(InsightsQLParser::LPAREN);
setState(1334);
identifier();
setState(1335);
match(InsightsQLParser::DOT);
setState(1336);
match(InsightsQLParser::ASTERISK);
setState(1337);
match(InsightsQLParser::EXCLUDE);
setState(1338);
match(InsightsQLParser::LPAREN);
setState(1339);
identifierList();
setState(1340);
match(InsightsQLParser::RPAREN);
setState(1341);
match(InsightsQLParser::REPLACE);
setState(1342);
match(InsightsQLParser::LPAREN);
setState(1343);
columnsReplaceList();
setState(1344);
match(InsightsQLParser::RPAREN);
setState(1345);
match(InsightsQLParser::RPAREN);
break;
}
case 17: {
_localctx = _tracker.createInstance<ColumnExprColumnsQualifiedExcludeContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1347);
match(InsightsQLParser::COLUMNS);
setState(1348);
match(InsightsQLParser::LPAREN);
setState(1349);
identifier();
setState(1350);
match(InsightsQLParser::DOT);
setState(1351);
match(InsightsQLParser::ASTERISK);
setState(1352);
match(InsightsQLParser::EXCLUDE);
setState(1353);
match(InsightsQLParser::LPAREN);
setState(1354);
identifierList();
setState(1355);
match(InsightsQLParser::RPAREN);
setState(1356);
match(InsightsQLParser::RPAREN);
break;
}
case 18: {
_localctx = _tracker.createInstance<ColumnExprColumnsQualifiedReplaceContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1358);
match(InsightsQLParser::COLUMNS);
setState(1359);
match(InsightsQLParser::LPAREN);
setState(1360);
identifier();
setState(1361);
match(InsightsQLParser::DOT);
setState(1362);
match(InsightsQLParser::ASTERISK);
setState(1363);
match(InsightsQLParser::REPLACE);
setState(1364);
match(InsightsQLParser::LPAREN);
setState(1365);
columnsReplaceList();
setState(1366);
match(InsightsQLParser::RPAREN);
setState(1367);
match(InsightsQLParser::RPAREN);
break;
}
case 19: {
_localctx = _tracker.createInstance<ColumnExprColumnsQualifiedAllContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1369);
match(InsightsQLParser::COLUMNS);
setState(1370);
match(InsightsQLParser::LPAREN);
setState(1371);
identifier();
setState(1372);
match(InsightsQLParser::DOT);
setState(1373);
match(InsightsQLParser::ASTERISK);
setState(1374);
match(InsightsQLParser::RPAREN);
break;
}
case 20: {
_localctx = _tracker.createInstance<ColumnExprSpreadColumnsRegexContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1376);
match(InsightsQLParser::ASTERISK);
setState(1377);
match(InsightsQLParser::COLUMNS);
setState(1378);
match(InsightsQLParser::LPAREN);
setState(1379);
match(InsightsQLParser::STRING_LITERAL);
setState(1380);
match(InsightsQLParser::RPAREN);
break;
}
case 21: {
_localctx = _tracker.createInstance<ColumnExprSpreadColumnsListContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1381);
match(InsightsQLParser::ASTERISK);
setState(1382);
match(InsightsQLParser::COLUMNS);
setState(1383);
match(InsightsQLParser::LPAREN);
setState(1384);
columnExprList();
setState(1385);
match(InsightsQLParser::RPAREN);
break;
}
case 22: {
_localctx = _tracker.createInstance<ColumnExprFunctionWithinGroupContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1387);
identifier();
setState(1388);
match(InsightsQLParser::LPAREN);
setState(1390);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1389);
antlrcpp::downCast<ColumnExprFunctionWithinGroupContext *>(_localctx)->columnExprs = columnExprList();
}
setState(1392);
match(InsightsQLParser::RPAREN);
setState(1393);
withinGroupClause();
break;
}
case 23: {
_localctx = _tracker.createInstance<ColumnExprWinFunctionContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1395);
identifier();
setState(1396);
match(InsightsQLParser::LPAREN);
setState(1398);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1397);
antlrcpp::downCast<ColumnExprWinFunctionContext *>(_localctx)->columnExprs = columnExprList();
}
setState(1400);
match(InsightsQLParser::RPAREN);
setState(1410);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LPAREN) {
setState(1402);
match(InsightsQLParser::LPAREN);
setState(1404);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx)) {
case 1: {
setState(1403);
match(InsightsQLParser::DISTINCT);
break;
}
default:
break;
}
setState(1407);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1406);
antlrcpp::downCast<ColumnExprWinFunctionContext *>(_localctx)->columnArgList = columnExprList();
}
setState(1409);
match(InsightsQLParser::RPAREN);
}
setState(1418);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FILTER) {
setState(1412);
match(InsightsQLParser::FILTER);
setState(1413);
match(InsightsQLParser::LPAREN);
setState(1414);
match(InsightsQLParser::WHERE);
setState(1415);
antlrcpp::downCast<ColumnExprWinFunctionContext *>(_localctx)->filterExpr = columnExpr(0);
setState(1416);
match(InsightsQLParser::RPAREN);
}
setState(1420);
match(InsightsQLParser::OVER);
setState(1421);
match(InsightsQLParser::LPAREN);
setState(1422);
windowExpr();
setState(1423);
match(InsightsQLParser::RPAREN);
break;
}
case 24: {
_localctx = _tracker.createInstance<ColumnExprWinFunctionTargetContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1425);
identifier();
setState(1426);
match(InsightsQLParser::LPAREN);
setState(1428);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1427);
antlrcpp::downCast<ColumnExprWinFunctionTargetContext *>(_localctx)->columnExprs = columnExprList();
}
setState(1430);
match(InsightsQLParser::RPAREN);
setState(1440);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LPAREN) {
setState(1432);
match(InsightsQLParser::LPAREN);
setState(1434);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx)) {
case 1: {
setState(1433);
match(InsightsQLParser::DISTINCT);
break;
}
default:
break;
}
setState(1437);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1436);
antlrcpp::downCast<ColumnExprWinFunctionTargetContext *>(_localctx)->columnArgList = columnExprList();
}
setState(1439);
match(InsightsQLParser::RPAREN);
}
setState(1448);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::FILTER) {
setState(1442);
match(InsightsQLParser::FILTER);
setState(1443);
match(InsightsQLParser::LPAREN);
setState(1444);
match(InsightsQLParser::WHERE);
setState(1445);
antlrcpp::downCast<ColumnExprWinFunctionTargetContext *>(_localctx)->filterExpr = columnExpr(0);
setState(1446);
match(InsightsQLParser::RPAREN);
}
setState(1450);
match(InsightsQLParser::OVER);
setState(1451);
identifier();
break;
}
case 25: {
_localctx = _tracker.createInstance<ColumnExprFunctionContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1453);
identifier();
setState(1459);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 177, _ctx)) {
case 1: {
setState(1454);
match(InsightsQLParser::LPAREN);
setState(1456);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1455);
antlrcpp::downCast<ColumnExprFunctionContext *>(_localctx)->columnExprs = columnExprList();
}
setState(1458);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
setState(1461);
match(InsightsQLParser::LPAREN);
setState(1463);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 178, _ctx)) {
case 1: {
setState(1462);
match(InsightsQLParser::DISTINCT);
break;
}
default:
break;
}
setState(1466);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx)) {
case 1: {
setState(1465);
antlrcpp::downCast<ColumnExprFunctionContext *>(_localctx)->columnArgList = columnExprList();
break;
}
default:
break;
}
setState(1471);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::ORDER) {
setState(1468);
match(InsightsQLParser::ORDER);
setState(1469);
match(InsightsQLParser::BY);
setState(1470);
orderExprList();
}
setState(1473);
match(InsightsQLParser::RPAREN);
setState(1480);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
case 1: {
setState(1474);
match(InsightsQLParser::FILTER);
setState(1475);
match(InsightsQLParser::LPAREN);
setState(1476);
match(InsightsQLParser::WHERE);
setState(1477);
antlrcpp::downCast<ColumnExprFunctionContext *>(_localctx)->filterExpr = columnExpr(0);
setState(1478);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
break;
}
case 26: {
_localctx = _tracker.createInstance<ColumnExprTagElementContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1482);
insightsqlxTagElement();
break;
}
case 27: {
_localctx = _tracker.createInstance<ColumnExprTemplateStringContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1483);
templateString();
break;
}
case 28: {
_localctx = _tracker.createInstance<ColumnExprLiteralContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1484);
literal();
break;
}
case 29: {
_localctx = _tracker.createInstance<ColumnExprNegateContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1485);
match(InsightsQLParser::DASH);
setState(1486);
columnExprValue(22);
break;
}
case 30: {
_localctx = _tracker.createInstance<ColumnExprNotContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1487);
match(InsightsQLParser::NOT);
setState(1488);
columnExprValue(12);
break;
}
case 31: {
_localctx = _tracker.createInstance<ColumnExprAsteriskContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1492);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -22520283327905794) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576778619) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 107) != 0)) {
setState(1489);
tableIdentifier();
setState(1490);
match(InsightsQLParser::DOT);
}
setState(1494);
match(InsightsQLParser::ASTERISK);
setState(1500);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 183, _ctx)) {
case 1: {
setState(1495);
match(InsightsQLParser::EXCLUDE);
setState(1496);
match(InsightsQLParser::LPAREN);
setState(1497);
identifierList();
setState(1498);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
break;
}
case 32: {
_localctx = _tracker.createInstance<ColumnExprColonLambdaContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1502);
match(InsightsQLParser::LAMBDA);
setState(1503);
identifier();
setState(1508);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 184, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1504);
match(InsightsQLParser::COMMA);
setState(1505);
identifier();
}
setState(1510);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 184, _ctx);
}
setState(1512);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1511);
match(InsightsQLParser::COMMA);
}
setState(1514);
match(InsightsQLParser::COLON);
setState(1515);
columnExpr(0);
break;
}
case 33: {
_localctx = _tracker.createInstance<ColumnExprSubqueryContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1517);
match(InsightsQLParser::LPAREN);
setState(1518);
selectSetStmt();
setState(1519);
match(InsightsQLParser::RPAREN);
break;
}
case 34: {
_localctx = _tracker.createInstance<ColumnExprParensContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1521);
match(InsightsQLParser::LPAREN);
setState(1522);
columnExpr(0);
setState(1523);
match(InsightsQLParser::RPAREN);
break;
}
case 35: {
_localctx = _tracker.createInstance<ColumnExprTupleContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1525);
match(InsightsQLParser::LPAREN);
setState(1526);
columnExprList();
setState(1527);
match(InsightsQLParser::RPAREN);
break;
}
case 36: {
_localctx = _tracker.createInstance<ColumnExprArrayContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1530);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::ARRAY) {
setState(1529);
match(InsightsQLParser::ARRAY);
}
setState(1532);
match(InsightsQLParser::LBRACKET);
setState(1534);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1533);
columnExprList();
}
setState(1536);
match(InsightsQLParser::RBRACKET);
break;
}
case 37: {
_localctx = _tracker.createInstance<ColumnExprDictContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1537);
match(InsightsQLParser::LBRACE);
setState(1539);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1538);
kvPairList();
}
setState(1541);
match(InsightsQLParser::RBRACE);
break;
}
case 38: {
_localctx = _tracker.createInstance<ColumnExprLambdaContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1542);
columnLambdaExpr();
break;
}
case 39: {
_localctx = _tracker.createInstance<ColumnExprNamedArgContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1543);
identifier();
setState(1544);
match(InsightsQLParser::COLONEQUALS);
setState(1545);
columnExpr(0);
break;
}
case 40: {
_localctx = _tracker.createInstance<ColumnExprPositionalContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1547);
match(InsightsQLParser::HASH);
setState(1548);
match(InsightsQLParser::DECIMAL_LITERAL);
break;
}
case 41: {
_localctx = _tracker.createInstance<ColumnExprIdentifierContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1549);
columnIdentifier();
break;
}
default:
break;
}
_ctx->stop = _input->LT(-1);
setState(1675);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 203, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
setState(1673);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 202, _ctx)) {
case 1: {
auto newContext = _tracker.createInstance<ColumnExprPrecedence1Context>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
newContext->left = previousContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1552);
if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1556);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::ASTERISK: {
setState(1553);
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(InsightsQLParser::ASTERISK);
break;
}
case InsightsQLParser::SLASH: {
setState(1554);
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(InsightsQLParser::SLASH);
break;
}
case InsightsQLParser::PERCENT: {
setState(1555);
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(InsightsQLParser::PERCENT);
break;
}
default:
throw NoViableAltException(this);
}
setState(1558);
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->right = columnExprValue(22);
break;
}
case 2: {
auto newContext = _tracker.createInstance<ColumnExprPrecedence2Context>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
newContext->left = previousContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1559);
if (!(precpred(_ctx, 20))) throw FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1563);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::PLUS: {
setState(1560);
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(InsightsQLParser::PLUS);
break;
}
case InsightsQLParser::DASH: {
setState(1561);
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(InsightsQLParser::DASH);
break;
}
case InsightsQLParser::CONCAT: {
setState(1562);
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(InsightsQLParser::CONCAT);
break;
}
default:
throw NoViableAltException(this);
}
setState(1565);
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->right = columnExprValue(21);
break;
}
case 3: {
auto newContext = _tracker.createInstance<ColumnExprPrecedence3Context>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
newContext->left = previousContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1566);
if (!(precpred(_ctx, 19))) throw FailedPredicateException(this, "precpred(_ctx, 19)");
setState(1591);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 195, _ctx)) {
case 1: {
setState(1567);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::EQ_DOUBLE);
break;
}
case 2: {
setState(1568);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::EQ_SINGLE);
break;
}
case 3: {
setState(1569);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::NOT_EQ);
break;
}
case 4: {
setState(1570);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::LT_EQ);
break;
}
case 5: {
setState(1571);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::LT);
break;
}
case 6: {
setState(1572);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::GT_EQ);
break;
}
case 7: {
setState(1573);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::GT);
break;
}
case 8: {
setState(1575);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1574);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::NOT);
}
setState(1577);
match(InsightsQLParser::IN);
setState(1579);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 193, _ctx)) {
case 1: {
setState(1578);
match(InsightsQLParser::COHORT);
break;
}
default:
break;
}
break;
}
case 9: {
setState(1582);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1581);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::NOT);
}
setState(1584);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::ILIKE
|| _la == InsightsQLParser::LIKE)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
case 10: {
setState(1585);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::REGEX_SINGLE);
break;
}
case 11: {
setState(1586);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::REGEX_DOUBLE);
break;
}
case 12: {
setState(1587);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::NOT_REGEX);
break;
}
case 13: {
setState(1588);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::IREGEX_SINGLE);
break;
}
case 14: {
setState(1589);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::IREGEX_DOUBLE);
break;
}
case 15: {
setState(1590);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(InsightsQLParser::NOT_IREGEX);
break;
}
default:
break;
}
setState(1593);
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->right = columnExprValue(20);
break;
}
case 4: {
auto newContext = _tracker.createInstance<ColumnExprIsDistinctFromContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1594);
if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
setState(1595);
match(InsightsQLParser::IS);
setState(1597);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1596);
match(InsightsQLParser::NOT);
}
setState(1599);
match(InsightsQLParser::DISTINCT);
setState(1600);
match(InsightsQLParser::FROM);
setState(1601);
columnExprValue(17);
break;
}
case 5: {
auto newContext = _tracker.createInstance<ColumnExprNullSafeEqContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1602);
if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)");
setState(1603);
match(InsightsQLParser::NULL_SAFE_EQ);
setState(1604);
columnExprValue(16);
break;
}
case 6: {
auto newContext = _tracker.createInstance<ColumnExprNullishContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1605);
if (!(precpred(_ctx, 14))) throw FailedPredicateException(this, "precpred(_ctx, 14)");
setState(1606);
match(InsightsQLParser::NULLISH);
setState(1607);
columnExprValue(15);
break;
}
case 7: {
auto newContext = _tracker.createInstance<ColumnExprBetweenContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1608);
if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1610);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1609);
match(InsightsQLParser::NOT);
}
setState(1612);
match(InsightsQLParser::BETWEEN);
setState(1613);
columnExprValue(0);
setState(1614);
match(InsightsQLParser::AND);
setState(1615);
columnExprValue(14);
break;
}
case 8: {
auto newContext = _tracker.createInstance<ColumnExprCallSelectContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1617);
if (!(precpred(_ctx, 35))) throw FailedPredicateException(this, "precpred(_ctx, 35)");
setState(1618);
match(InsightsQLParser::LPAREN);
setState(1619);
selectSetStmt();
setState(1620);
match(InsightsQLParser::RPAREN);
break;
}
case 9: {
auto newContext = _tracker.createInstance<ColumnExprCallContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1622);
if (!(precpred(_ctx, 34))) throw FailedPredicateException(this, "precpred(_ctx, 34)");
setState(1623);
match(InsightsQLParser::LPAREN);
setState(1625);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1624);
columnExprList();
}
setState(1627);
match(InsightsQLParser::RPAREN);
break;
}
case 10: {
auto newContext = _tracker.createInstance<ColumnExprArrayAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1628);
if (!(precpred(_ctx, 30))) throw FailedPredicateException(this, "precpred(_ctx, 30)");
setState(1629);
match(InsightsQLParser::LBRACKET);
setState(1630);
columnExpr(0);
setState(1631);
match(InsightsQLParser::RBRACKET);
break;
}
case 11: {
auto newContext = _tracker.createInstance<ColumnExprArraySliceContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1633);
if (!(precpred(_ctx, 29))) throw FailedPredicateException(this, "precpred(_ctx, 29)");
setState(1634);
match(InsightsQLParser::LBRACKET);
setState(1636);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1635);
columnExpr(0);
}
setState(1638);
match(InsightsQLParser::COLON);
setState(1640);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1639);
columnExpr(0);
}
setState(1642);
match(InsightsQLParser::RBRACKET);
break;
}
case 12: {
auto newContext = _tracker.createInstance<ColumnExprTupleAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1643);
if (!(precpred(_ctx, 28))) throw FailedPredicateException(this, "precpred(_ctx, 28)");
setState(1644);
match(InsightsQLParser::DOT);
setState(1645);
match(InsightsQLParser::DECIMAL_LITERAL);
break;
}
case 13: {
auto newContext = _tracker.createInstance<ColumnExprPropertyAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1646);
if (!(precpred(_ctx, 27))) throw FailedPredicateException(this, "precpred(_ctx, 27)");
setState(1647);
match(InsightsQLParser::DOT);
setState(1648);
identifier();
break;
}
case 14: {
auto newContext = _tracker.createInstance<ColumnExprNullArrayAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1649);
if (!(precpred(_ctx, 26))) throw FailedPredicateException(this, "precpred(_ctx, 26)");
setState(1650);
match(InsightsQLParser::NULL_PROPERTY);
setState(1651);
match(InsightsQLParser::LBRACKET);
setState(1652);
columnExpr(0);
setState(1653);
match(InsightsQLParser::RBRACKET);
break;
}
case 15: {
auto newContext = _tracker.createInstance<ColumnExprNullTupleAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1655);
if (!(precpred(_ctx, 25))) throw FailedPredicateException(this, "precpred(_ctx, 25)");
setState(1656);
match(InsightsQLParser::NULL_PROPERTY);
setState(1657);
match(InsightsQLParser::DECIMAL_LITERAL);
break;
}
case 16: {
auto newContext = _tracker.createInstance<ColumnExprNullPropertyAccessContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1658);
if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)");
setState(1659);
match(InsightsQLParser::NULL_PROPERTY);
setState(1660);
identifier();
break;
}
case 17: {
auto newContext = _tracker.createInstance<ColumnExprTypeCastContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1661);
if (!(precpred(_ctx, 23))) throw FailedPredicateException(this, "precpred(_ctx, 23)");
setState(1662);
match(InsightsQLParser::DOUBLECOLON);
setState(1663);
columnTypeCastExpr();
break;
}
case 18: {
auto newContext = _tracker.createInstance<ColumnExprIgnoreNullsContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1664);
if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)");
setState(1665);
match(InsightsQLParser::IGNORE);
setState(1666);
match(InsightsQLParser::NULLS);
break;
}
case 19: {
auto newContext = _tracker.createInstance<ColumnExprIsNullContext>(_tracker.createInstance<ColumnExprValueContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleColumnExprValue);
setState(1667);
if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)");
setState(1668);
match(InsightsQLParser::IS);
setState(1670);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1669);
match(InsightsQLParser::NOT);
}
setState(1672);
match(InsightsQLParser::NULL_SQL);
break;
}
default:
break;
}
}
setState(1677);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 203, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnLambdaExprContext ------------------------------------------------------------------
InsightsQLParser::ColumnLambdaExprContext::ColumnLambdaExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::ColumnLambdaExprContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnLambdaExpr;
}
void InsightsQLParser::ColumnLambdaExprContext::copyFrom(ColumnLambdaExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- ArrowLambdaContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ArrowLambdaContext::ARROW() {
return getToken(InsightsQLParser::ARROW, 0);
}
tree::TerminalNode* InsightsQLParser::ArrowLambdaContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ArrowLambdaContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ArrowLambdaContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ArrowLambdaContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ArrowLambdaContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
InsightsQLParser::BlockContext* InsightsQLParser::ArrowLambdaContext::block() {
return getRuleContext<InsightsQLParser::BlockContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ArrowLambdaContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ArrowLambdaContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ArrowLambdaContext::ArrowLambdaContext(ColumnLambdaExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ArrowLambdaContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitArrowLambda(this);
else
return visitor->visitChildren(this);
}
//----------------- ColonLambdaContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::ColonLambdaContext::LAMBDA() {
return getToken(InsightsQLParser::LAMBDA, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColonLambdaContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColonLambdaContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColonLambdaContext::COLON() {
return getToken(InsightsQLParser::COLON, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColonLambdaContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColonLambdaContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColonLambdaContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
InsightsQLParser::ColonLambdaContext::ColonLambdaContext(ColumnLambdaExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::ColonLambdaContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColonLambda(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnLambdaExprContext* InsightsQLParser::columnLambdaExpr() {
ColumnLambdaExprContext *_localctx = _tracker.createInstance<ColumnLambdaExprContext>(_ctx, getState());
enterRule(_localctx, 158, InsightsQLParser::RuleColumnLambdaExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1727);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 212, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::ArrowLambdaContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1705);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 208, _ctx)) {
case 1: {
setState(1678);
match(InsightsQLParser::LPAREN);
setState(1679);
identifier();
setState(1684);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1680);
match(InsightsQLParser::COMMA);
setState(1681);
identifier();
}
setState(1686);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx);
}
setState(1688);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1687);
match(InsightsQLParser::COMMA);
}
setState(1690);
match(InsightsQLParser::RPAREN);
break;
}
case 2: {
setState(1692);
identifier();
setState(1697);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 206, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1693);
match(InsightsQLParser::COMMA);
setState(1694);
identifier();
}
setState(1699);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 206, _ctx);
}
setState(1701);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1700);
match(InsightsQLParser::COMMA);
}
break;
}
case 3: {
setState(1703);
match(InsightsQLParser::LPAREN);
setState(1704);
match(InsightsQLParser::RPAREN);
break;
}
default:
break;
}
setState(1707);
match(InsightsQLParser::ARROW);
setState(1710);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 209, _ctx)) {
case 1: {
setState(1708);
columnExpr(0);
break;
}
case 2: {
setState(1709);
block();
break;
}
default:
break;
}
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::ColonLambdaContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1712);
match(InsightsQLParser::LAMBDA);
setState(1713);
identifier();
setState(1718);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1714);
match(InsightsQLParser::COMMA);
setState(1715);
identifier();
}
setState(1720);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx);
}
setState(1722);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1721);
match(InsightsQLParser::COMMA);
}
setState(1724);
match(InsightsQLParser::COLON);
setState(1725);
columnExpr(0);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnsReplaceListContext ------------------------------------------------------------------
InsightsQLParser::ColumnsReplaceListContext::ColumnsReplaceListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnsReplaceItemContext *> InsightsQLParser::ColumnsReplaceListContext::columnsReplaceItem() {
return getRuleContexts<InsightsQLParser::ColumnsReplaceItemContext>();
}
InsightsQLParser::ColumnsReplaceItemContext* InsightsQLParser::ColumnsReplaceListContext::columnsReplaceItem(size_t i) {
return getRuleContext<InsightsQLParser::ColumnsReplaceItemContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnsReplaceListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnsReplaceListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::ColumnsReplaceListContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnsReplaceList;
}
std::any InsightsQLParser::ColumnsReplaceListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnsReplaceList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnsReplaceListContext* InsightsQLParser::columnsReplaceList() {
ColumnsReplaceListContext *_localctx = _tracker.createInstance<ColumnsReplaceListContext>(_ctx, getState());
enterRule(_localctx, 160, InsightsQLParser::RuleColumnsReplaceList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1729);
columnsReplaceItem();
setState(1734);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(1730);
match(InsightsQLParser::COMMA);
setState(1731);
columnsReplaceItem();
setState(1736);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnsReplaceItemContext ------------------------------------------------------------------
InsightsQLParser::ColumnsReplaceItemContext::ColumnsReplaceItemContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnsReplaceItemContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnsReplaceItemContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnsReplaceItemContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
size_t InsightsQLParser::ColumnsReplaceItemContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnsReplaceItem;
}
std::any InsightsQLParser::ColumnsReplaceItemContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnsReplaceItem(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnsReplaceItemContext* InsightsQLParser::columnsReplaceItem() {
ColumnsReplaceItemContext *_localctx = _tracker.createInstance<ColumnsReplaceItemContext>(_ctx, getState());
enterRule(_localctx, 162, InsightsQLParser::RuleColumnsReplaceItem);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1737);
columnExpr(0);
setState(1738);
match(InsightsQLParser::AS);
setState(1739);
identifier();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InsightsqlxChildElementContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxChildElementContext::InsightsqlxChildElementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::InsightsqlxTagElementContext* InsightsQLParser::InsightsqlxChildElementContext::insightsqlxTagElement() {
return getRuleContext<InsightsQLParser::InsightsqlxTagElementContext>(0);
}
InsightsQLParser::InsightsqlxTextContext* InsightsQLParser::InsightsqlxChildElementContext::insightsqlxText() {
return getRuleContext<InsightsQLParser::InsightsqlxTextContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxChildElementContext::LBRACE() {
return getToken(InsightsQLParser::LBRACE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::InsightsqlxChildElementContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxChildElementContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
size_t InsightsQLParser::InsightsqlxChildElementContext::getRuleIndex() const {
return InsightsQLParser::RuleInsightsqlxChildElement;
}
std::any InsightsQLParser::InsightsqlxChildElementContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInsightsqlxChildElement(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InsightsqlxChildElementContext* InsightsQLParser::insightsqlxChildElement() {
InsightsqlxChildElementContext *_localctx = _tracker.createInstance<InsightsqlxChildElementContext>(_ctx, getState());
enterRule(_localctx, 164, InsightsQLParser::RuleInsightsqlxChildElement);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1747);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::LT: {
enterOuterAlt(_localctx, 1);
setState(1741);
insightsqlxTagElement();
break;
}
case InsightsQLParser::INSIGHTSQLX_TEXT_TEXT: {
enterOuterAlt(_localctx, 2);
setState(1742);
insightsqlxText();
break;
}
case InsightsQLParser::LBRACE: {
enterOuterAlt(_localctx, 3);
setState(1743);
match(InsightsQLParser::LBRACE);
setState(1744);
columnExpr(0);
setState(1745);
match(InsightsQLParser::RBRACE);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InsightsqlxTextContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxTextContext::InsightsqlxTextContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTextContext::INSIGHTSQLX_TEXT_TEXT() {
return getToken(InsightsQLParser::INSIGHTSQLX_TEXT_TEXT, 0);
}
size_t InsightsQLParser::InsightsqlxTextContext::getRuleIndex() const {
return InsightsQLParser::RuleInsightsqlxText;
}
std::any InsightsQLParser::InsightsqlxTextContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInsightsqlxText(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InsightsqlxTextContext* InsightsQLParser::insightsqlxText() {
InsightsqlxTextContext *_localctx = _tracker.createInstance<InsightsqlxTextContext>(_ctx, getState());
enterRule(_localctx, 166, InsightsQLParser::RuleInsightsqlxText);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1749);
match(InsightsQLParser::INSIGHTSQLX_TEXT_TEXT);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InsightsqlxTagElementContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxTagElementContext::InsightsqlxTagElementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::InsightsqlxTagElementContext::getRuleIndex() const {
return InsightsQLParser::RuleInsightsqlxTagElement;
}
void InsightsQLParser::InsightsqlxTagElementContext::copyFrom(InsightsqlxTagElementContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- InsightsqlxTagElementClosedContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::InsightsqlxTagElementClosedContext::LT() {
return getToken(InsightsQLParser::LT, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::InsightsqlxTagElementClosedContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagElementClosedContext::SLASH_GT() {
return getToken(InsightsQLParser::SLASH_GT, 0);
}
std::vector<InsightsQLParser::InsightsqlxTagAttributeContext *> InsightsQLParser::InsightsqlxTagElementClosedContext::insightsqlxTagAttribute() {
return getRuleContexts<InsightsQLParser::InsightsqlxTagAttributeContext>();
}
InsightsQLParser::InsightsqlxTagAttributeContext* InsightsQLParser::InsightsqlxTagElementClosedContext::insightsqlxTagAttribute(size_t i) {
return getRuleContext<InsightsQLParser::InsightsqlxTagAttributeContext>(i);
}
InsightsQLParser::InsightsqlxTagElementClosedContext::InsightsqlxTagElementClosedContext(InsightsqlxTagElementContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::InsightsqlxTagElementClosedContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInsightsqlxTagElementClosed(this);
else
return visitor->visitChildren(this);
}
//----------------- InsightsqlxTagElementNestedContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::InsightsqlxTagElementNestedContext::LT() {
return getToken(InsightsQLParser::LT, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::InsightsqlxTagElementNestedContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::InsightsqlxTagElementNestedContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::InsightsqlxTagElementNestedContext::GT() {
return getTokens(InsightsQLParser::GT);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagElementNestedContext::GT(size_t i) {
return getToken(InsightsQLParser::GT, i);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagElementNestedContext::LT_SLASH() {
return getToken(InsightsQLParser::LT_SLASH, 0);
}
std::vector<InsightsQLParser::InsightsqlxTagAttributeContext *> InsightsQLParser::InsightsqlxTagElementNestedContext::insightsqlxTagAttribute() {
return getRuleContexts<InsightsQLParser::InsightsqlxTagAttributeContext>();
}
InsightsQLParser::InsightsqlxTagAttributeContext* InsightsQLParser::InsightsqlxTagElementNestedContext::insightsqlxTagAttribute(size_t i) {
return getRuleContext<InsightsQLParser::InsightsqlxTagAttributeContext>(i);
}
std::vector<InsightsQLParser::InsightsqlxChildElementContext *> InsightsQLParser::InsightsqlxTagElementNestedContext::insightsqlxChildElement() {
return getRuleContexts<InsightsQLParser::InsightsqlxChildElementContext>();
}
InsightsQLParser::InsightsqlxChildElementContext* InsightsQLParser::InsightsqlxTagElementNestedContext::insightsqlxChildElement(size_t i) {
return getRuleContext<InsightsQLParser::InsightsqlxChildElementContext>(i);
}
InsightsQLParser::InsightsqlxTagElementNestedContext::InsightsqlxTagElementNestedContext(InsightsqlxTagElementContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::InsightsqlxTagElementNestedContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInsightsqlxTagElementNested(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InsightsqlxTagElementContext* InsightsQLParser::insightsqlxTagElement() {
InsightsqlxTagElementContext *_localctx = _tracker.createInstance<InsightsqlxTagElementContext>(_ctx, getState());
enterRule(_localctx, 168, InsightsQLParser::RuleInsightsqlxTagElement);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1780);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 218, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::InsightsqlxTagElementClosedContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1751);
match(InsightsQLParser::LT);
setState(1752);
identifier();
setState(1756);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -22520283327905794) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576778619) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 107) != 0)) {
setState(1753);
insightsqlxTagAttribute();
setState(1758);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1759);
match(InsightsQLParser::SLASH_GT);
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::InsightsqlxTagElementNestedContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1761);
match(InsightsQLParser::LT);
setState(1762);
identifier();
setState(1766);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -22520283327905794) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576778619) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 107) != 0)) {
setState(1763);
insightsqlxTagAttribute();
setState(1768);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1769);
match(InsightsQLParser::GT);
setState(1773);
_errHandler->sync(this);
_la = _input->LA(1);
while (((((_la - 163) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 163)) & 8796093022241) != 0)) {
setState(1770);
insightsqlxChildElement();
setState(1775);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1776);
match(InsightsQLParser::LT_SLASH);
setState(1777);
identifier();
setState(1778);
match(InsightsQLParser::GT);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- InsightsqlxTagAttributeContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxTagAttributeContext::InsightsqlxTagAttributeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::IdentifierContext* InsightsQLParser::InsightsqlxTagAttributeContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagAttributeContext::EQ_SINGLE() {
return getToken(InsightsQLParser::EQ_SINGLE, 0);
}
InsightsQLParser::StringContext* InsightsQLParser::InsightsqlxTagAttributeContext::string() {
return getRuleContext<InsightsQLParser::StringContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagAttributeContext::LBRACE() {
return getToken(InsightsQLParser::LBRACE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::InsightsqlxTagAttributeContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::InsightsqlxTagAttributeContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
size_t InsightsQLParser::InsightsqlxTagAttributeContext::getRuleIndex() const {
return InsightsQLParser::RuleInsightsqlxTagAttribute;
}
std::any InsightsQLParser::InsightsqlxTagAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInsightsqlxTagAttribute(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::InsightsqlxTagAttributeContext* InsightsQLParser::insightsqlxTagAttribute() {
InsightsqlxTagAttributeContext *_localctx = _tracker.createInstance<InsightsqlxTagAttributeContext>(_ctx, getState());
enterRule(_localctx, 170, InsightsQLParser::RuleInsightsqlxTagAttribute);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1793);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 219, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1782);
identifier();
setState(1783);
match(InsightsQLParser::EQ_SINGLE);
setState(1784);
string();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1786);
identifier();
setState(1787);
match(InsightsQLParser::EQ_SINGLE);
setState(1788);
match(InsightsQLParser::LBRACE);
setState(1789);
columnExpr(0);
setState(1790);
match(InsightsQLParser::RBRACE);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(1792);
identifier();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithExprListContext ------------------------------------------------------------------
InsightsQLParser::WithExprListContext::WithExprListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::WithExprContext *> InsightsQLParser::WithExprListContext::withExpr() {
return getRuleContexts<InsightsQLParser::WithExprContext>();
}
InsightsQLParser::WithExprContext* InsightsQLParser::WithExprListContext::withExpr(size_t i) {
return getRuleContext<InsightsQLParser::WithExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WithExprListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::WithExprListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::WithExprListContext::getRuleIndex() const {
return InsightsQLParser::RuleWithExprList;
}
std::any InsightsQLParser::WithExprListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithExprList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithExprListContext* InsightsQLParser::withExprList() {
WithExprListContext *_localctx = _tracker.createInstance<WithExprListContext>(_ctx, getState());
enterRule(_localctx, 172, InsightsQLParser::RuleWithExprList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1795);
withExpr();
setState(1800);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 220, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1796);
match(InsightsQLParser::COMMA);
setState(1797);
withExpr();
}
setState(1802);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 220, _ctx);
}
setState(1804);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1803);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithExprContext ------------------------------------------------------------------
InsightsQLParser::WithExprContext::WithExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::WithExprContext::getRuleIndex() const {
return InsightsQLParser::RuleWithExpr;
}
void InsightsQLParser::WithExprContext::copyFrom(WithExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- WithExprColumnContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprContext* InsightsQLParser::WithExprColumnContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::WithExprColumnContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::WithExprColumnContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
InsightsQLParser::WithExprColumnContext::WithExprColumnContext(WithExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::WithExprColumnContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithExprColumn(this);
else
return visitor->visitChildren(this);
}
//----------------- WithExprSubqueryContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext* InsightsQLParser::WithExprSubqueryContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::WithExprSubqueryContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<InsightsQLParser::WithExprColumnNameListContext *> InsightsQLParser::WithExprSubqueryContext::withExprColumnNameList() {
return getRuleContexts<InsightsQLParser::WithExprColumnNameListContext>();
}
InsightsQLParser::WithExprColumnNameListContext* InsightsQLParser::WithExprSubqueryContext::withExprColumnNameList(size_t i) {
return getRuleContext<InsightsQLParser::WithExprColumnNameListContext>(i);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::USING() {
return getToken(InsightsQLParser::USING, 0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::KEY() {
return getToken(InsightsQLParser::KEY, 0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::MATERIALIZED() {
return getToken(InsightsQLParser::MATERIALIZED, 0);
}
tree::TerminalNode* InsightsQLParser::WithExprSubqueryContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
InsightsQLParser::WithExprSubqueryContext::WithExprSubqueryContext(WithExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::WithExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithExprSubquery(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithExprContext* InsightsQLParser::withExpr() {
WithExprContext *_localctx = _tracker.createInstance<WithExprContext>(_ctx, getState());
enterRule(_localctx, 174, InsightsQLParser::RuleWithExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1830);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 226, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<InsightsQLParser::WithExprSubqueryContext>(_localctx);
enterOuterAlt(_localctx, 1);
setState(1806);
identifier();
setState(1808);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::LPAREN) {
setState(1807);
withExprColumnNameList();
}
setState(1813);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::USING) {
setState(1810);
match(InsightsQLParser::USING);
setState(1811);
match(InsightsQLParser::KEY);
setState(1812);
withExprColumnNameList();
}
setState(1815);
match(InsightsQLParser::AS);
setState(1820);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::MATERIALIZED
|| _la == InsightsQLParser::NOT) {
setState(1817);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::NOT) {
setState(1816);
match(InsightsQLParser::NOT);
}
setState(1819);
match(InsightsQLParser::MATERIALIZED);
}
setState(1822);
match(InsightsQLParser::LPAREN);
setState(1823);
selectSetStmt();
setState(1824);
match(InsightsQLParser::RPAREN);
break;
}
case 2: {
_localctx = _tracker.createInstance<InsightsQLParser::WithExprColumnContext>(_localctx);
enterOuterAlt(_localctx, 2);
setState(1826);
columnExpr(0);
setState(1827);
match(InsightsQLParser::AS);
setState(1828);
identifier();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- WithExprColumnNameListContext ------------------------------------------------------------------
InsightsQLParser::WithExprColumnNameListContext::WithExprColumnNameListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::WithExprColumnNameListContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::WithExprColumnNameListContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::WithExprColumnNameListContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::WithExprColumnNameListContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::WithExprColumnNameListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::WithExprColumnNameListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::WithExprColumnNameListContext::getRuleIndex() const {
return InsightsQLParser::RuleWithExprColumnNameList;
}
std::any InsightsQLParser::WithExprColumnNameListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitWithExprColumnNameList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::WithExprColumnNameListContext* InsightsQLParser::withExprColumnNameList() {
WithExprColumnNameListContext *_localctx = _tracker.createInstance<WithExprColumnNameListContext>(_ctx, getState());
enterRule(_localctx, 176, InsightsQLParser::RuleWithExprColumnNameList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1832);
match(InsightsQLParser::LPAREN);
setState(1833);
identifier();
setState(1838);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(1834);
match(InsightsQLParser::COMMA);
setState(1835);
identifier();
setState(1840);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1841);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnIdentifierContext ------------------------------------------------------------------
InsightsQLParser::ColumnIdentifierContext::ColumnIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::PlaceholderContext* InsightsQLParser::ColumnIdentifierContext::placeholder() {
return getRuleContext<InsightsQLParser::PlaceholderContext>(0);
}
InsightsQLParser::NestedIdentifierContext* InsightsQLParser::ColumnIdentifierContext::nestedIdentifier() {
return getRuleContext<InsightsQLParser::NestedIdentifierContext>(0);
}
InsightsQLParser::TableIdentifierContext* InsightsQLParser::ColumnIdentifierContext::tableIdentifier() {
return getRuleContext<InsightsQLParser::TableIdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnIdentifierContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
size_t InsightsQLParser::ColumnIdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnIdentifier;
}
std::any InsightsQLParser::ColumnIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnIdentifierContext* InsightsQLParser::columnIdentifier() {
ColumnIdentifierContext *_localctx = _tracker.createInstance<ColumnIdentifierContext>(_ctx, getState());
enterRule(_localctx, 178, InsightsQLParser::RuleColumnIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1850);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::LBRACE: {
enterOuterAlt(_localctx, 1);
setState(1843);
placeholder();
break;
}
case InsightsQLParser::ALL:
case InsightsQLParser::AND:
case InsightsQLParser::ANTI:
case InsightsQLParser::ANY:
case InsightsQLParser::ARRAY:
case InsightsQLParser::AS:
case InsightsQLParser::ASCENDING:
case InsightsQLParser::ASOF:
case InsightsQLParser::BETWEEN:
case InsightsQLParser::BOTH:
case InsightsQLParser::BY:
case InsightsQLParser::CASE:
case InsightsQLParser::CAST:
case InsightsQLParser::COHORT:
case InsightsQLParser::COLLATE:
case InsightsQLParser::COLUMNS:
case InsightsQLParser::CROSS:
case InsightsQLParser::CUBE:
case InsightsQLParser::CURRENT:
case InsightsQLParser::DATE:
case InsightsQLParser::DAY:
case InsightsQLParser::DESC:
case InsightsQLParser::DESCENDING:
case InsightsQLParser::DISTINCT:
case InsightsQLParser::ELSE:
case InsightsQLParser::END:
case InsightsQLParser::EXCLUDE:
case InsightsQLParser::EXTRACT:
case InsightsQLParser::FINAL:
case InsightsQLParser::FILL:
case InsightsQLParser::FILTER:
case InsightsQLParser::FIRST:
case InsightsQLParser::FOLLOWING:
case InsightsQLParser::FOR:
case InsightsQLParser::FROM:
case InsightsQLParser::FULL:
case InsightsQLParser::GROUP:
case InsightsQLParser::GROUPING:
case InsightsQLParser::HAVING:
case InsightsQLParser::HOUR:
case InsightsQLParser::ID:
case InsightsQLParser::IF:
case InsightsQLParser::ILIKE:
case InsightsQLParser::IGNORE:
case InsightsQLParser::INCLUDE:
case InsightsQLParser::IN:
case InsightsQLParser::INNER:
case InsightsQLParser::INTERPOLATE:
case InsightsQLParser::INTERVAL:
case InsightsQLParser::IS:
case InsightsQLParser::JOIN:
case InsightsQLParser::KEY:
case InsightsQLParser::LAMBDA:
case InsightsQLParser::LAST:
case InsightsQLParser::LEADING:
case InsightsQLParser::LEFT:
case InsightsQLParser::LIKE:
case InsightsQLParser::LIMIT:
case InsightsQLParser::MINUTE:
case InsightsQLParser::MONTH:
case InsightsQLParser::NAME:
case InsightsQLParser::NATURAL:
case InsightsQLParser::NOT:
case InsightsQLParser::NULLS:
case InsightsQLParser::OFFSET:
case InsightsQLParser::ON:
case InsightsQLParser::OR:
case InsightsQLParser::ORDER:
case InsightsQLParser::OUTER:
case InsightsQLParser::OVER:
case InsightsQLParser::PARTITION:
case InsightsQLParser::PIVOT:
case InsightsQLParser::POSITIONAL:
case InsightsQLParser::PRECEDING:
case InsightsQLParser::PREWHERE:
case InsightsQLParser::QUALIFY:
case InsightsQLParser::QUARTER:
case InsightsQLParser::RANGE:
case InsightsQLParser::RECURSIVE:
case InsightsQLParser::REPLACE:
case InsightsQLParser::RETURN:
case InsightsQLParser::RIGHT:
case InsightsQLParser::ROLLUP:
case InsightsQLParser::ROW:
case InsightsQLParser::ROWS:
case InsightsQLParser::SAMPLE:
case InsightsQLParser::SECOND:
case InsightsQLParser::SELECT:
case InsightsQLParser::SEMI:
case InsightsQLParser::SETS:
case InsightsQLParser::SETTINGS:
case InsightsQLParser::STEP:
case InsightsQLParser::SUBSTRING:
case InsightsQLParser::THEN:
case InsightsQLParser::TIES:
case InsightsQLParser::TIMESTAMP:
case InsightsQLParser::TIME:
case InsightsQLParser::LOCAL:
case InsightsQLParser::ZONE:
case InsightsQLParser::TO:
case InsightsQLParser::TOP:
case InsightsQLParser::TOTALS:
case InsightsQLParser::TRAILING:
case InsightsQLParser::TRIM:
case InsightsQLParser::TRUNCATE:
case InsightsQLParser::TRY_CAST:
case InsightsQLParser::UNBOUNDED:
case InsightsQLParser::UNION:
case InsightsQLParser::UNPIVOT:
case InsightsQLParser::USING:
case InsightsQLParser::VALUES:
case InsightsQLParser::WEEK:
case InsightsQLParser::WHEN:
case InsightsQLParser::WHERE:
case InsightsQLParser::WINDOW:
case InsightsQLParser::WITH:
case InsightsQLParser::YEAR:
case InsightsQLParser::IDENTIFIER:
case InsightsQLParser::QUOTED_IDENTIFIER: {
enterOuterAlt(_localctx, 2);
setState(1847);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx)) {
case 1: {
setState(1844);
tableIdentifier();
setState(1845);
match(InsightsQLParser::DOT);
break;
}
default:
break;
}
setState(1849);
nestedIdentifier();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- NestedIdentifierContext ------------------------------------------------------------------
InsightsQLParser::NestedIdentifierContext::NestedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::NestedIdentifierContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::NestedIdentifierContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::NestedIdentifierContext::DOT() {
return getTokens(InsightsQLParser::DOT);
}
tree::TerminalNode* InsightsQLParser::NestedIdentifierContext::DOT(size_t i) {
return getToken(InsightsQLParser::DOT, i);
}
size_t InsightsQLParser::NestedIdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleNestedIdentifier;
}
std::any InsightsQLParser::NestedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitNestedIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::NestedIdentifierContext* InsightsQLParser::nestedIdentifier() {
NestedIdentifierContext *_localctx = _tracker.createInstance<NestedIdentifierContext>(_ctx, getState());
enterRule(_localctx, 180, InsightsQLParser::RuleNestedIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1852);
identifier();
setState(1857);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1853);
match(InsightsQLParser::DOT);
setState(1854);
identifier();
}
setState(1859);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TableExprContext ------------------------------------------------------------------
InsightsQLParser::TableExprContext::TableExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t InsightsQLParser::TableExprContext::getRuleIndex() const {
return InsightsQLParser::RuleTableExpr;
}
void InsightsQLParser::TableExprContext::copyFrom(TableExprContext *ctx) {
ParserRuleContext::copyFrom(ctx);
}
//----------------- TableExprTagContext ------------------------------------------------------------------
InsightsQLParser::InsightsqlxTagElementContext* InsightsQLParser::TableExprTagContext::insightsqlxTagElement() {
return getRuleContext<InsightsQLParser::InsightsqlxTagElementContext>(0);
}
InsightsQLParser::TableExprTagContext::TableExprTagContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprTagContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprTag(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprIdentifierContext ------------------------------------------------------------------
InsightsQLParser::TableIdentifierContext* InsightsQLParser::TableExprIdentifierContext::tableIdentifier() {
return getRuleContext<InsightsQLParser::TableIdentifierContext>(0);
}
InsightsQLParser::TableExprIdentifierContext::TableExprIdentifierContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprIdentifier(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprPlaceholderContext ------------------------------------------------------------------
InsightsQLParser::PlaceholderContext* InsightsQLParser::TableExprPlaceholderContext::placeholder() {
return getRuleContext<InsightsQLParser::PlaceholderContext>(0);
}
InsightsQLParser::TableExprPlaceholderContext::TableExprPlaceholderContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprPlaceholderContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprPlaceholder(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprSubqueryContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::TableExprSubqueryContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::SelectSetStmtContext* InsightsQLParser::TableExprSubqueryContext::selectSetStmt() {
return getRuleContext<InsightsQLParser::SelectSetStmtContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprSubqueryContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::TableExprSubqueryContext::TableExprSubqueryContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprSubquery(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprPivotContext ------------------------------------------------------------------
InsightsQLParser::TableExprContext* InsightsQLParser::TableExprPivotContext::tableExpr() {
return getRuleContext<InsightsQLParser::TableExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprPivotContext::PIVOT() {
return getToken(InsightsQLParser::PIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprPivotContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::TableExprPivotContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::TableExprPivotContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
InsightsQLParser::PivotColumnListContext* InsightsQLParser::TableExprPivotContext::pivotColumnList() {
return getRuleContext<InsightsQLParser::PivotColumnListContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprPivotContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprPivotContext::GROUP() {
return getToken(InsightsQLParser::GROUP, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprPivotContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
InsightsQLParser::TableExprPivotContext::TableExprPivotContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprPivotContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprPivot(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprValuesContext ------------------------------------------------------------------
tree::TerminalNode* InsightsQLParser::TableExprValuesContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ValuesClauseContext* InsightsQLParser::TableExprValuesContext::valuesClause() {
return getRuleContext<InsightsQLParser::ValuesClauseContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprValuesContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::TableExprValuesContext::TableExprValuesContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprValuesContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprValues(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprAliasContext ------------------------------------------------------------------
InsightsQLParser::TableExprContext* InsightsQLParser::TableExprAliasContext::tableExpr() {
return getRuleContext<InsightsQLParser::TableExprContext>(0);
}
InsightsQLParser::AliasContext* InsightsQLParser::TableExprAliasContext::alias() {
return getRuleContext<InsightsQLParser::AliasContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprAliasContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::TableExprAliasContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
InsightsQLParser::ColumnAliasesContext* InsightsQLParser::TableExprAliasContext::columnAliases() {
return getRuleContext<InsightsQLParser::ColumnAliasesContext>(0);
}
InsightsQLParser::TableExprAliasContext::TableExprAliasContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprAlias(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprFunctionContext ------------------------------------------------------------------
InsightsQLParser::TableFunctionExprContext* InsightsQLParser::TableExprFunctionContext::tableFunctionExpr() {
return getRuleContext<InsightsQLParser::TableFunctionExprContext>(0);
}
InsightsQLParser::TableExprFunctionContext::TableExprFunctionContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprFunction(this);
else
return visitor->visitChildren(this);
}
//----------------- TableExprUnpivotContext ------------------------------------------------------------------
InsightsQLParser::TableExprContext* InsightsQLParser::TableExprUnpivotContext::tableExpr() {
return getRuleContext<InsightsQLParser::TableExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprUnpivotContext::UNPIVOT() {
return getToken(InsightsQLParser::UNPIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprUnpivotContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::UnpivotColumnListContext* InsightsQLParser::TableExprUnpivotContext::unpivotColumnList() {
return getRuleContext<InsightsQLParser::UnpivotColumnListContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableExprUnpivotContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprUnpivotContext::INCLUDE() {
return getToken(InsightsQLParser::INCLUDE, 0);
}
tree::TerminalNode* InsightsQLParser::TableExprUnpivotContext::NULLS() {
return getToken(InsightsQLParser::NULLS, 0);
}
InsightsQLParser::TableExprUnpivotContext::TableExprUnpivotContext(TableExprContext *ctx) { copyFrom(ctx); }
std::any InsightsQLParser::TableExprUnpivotContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableExprUnpivot(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TableExprContext* InsightsQLParser::tableExpr() {
return tableExpr(0);
}
InsightsQLParser::TableExprContext* InsightsQLParser::tableExpr(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
InsightsQLParser::TableExprContext *_localctx = _tracker.createInstance<TableExprContext>(_ctx, parentState);
InsightsQLParser::TableExprContext *previousContext = _localctx;
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
size_t startState = 182;
enterRecursionRule(_localctx, 182, InsightsQLParser::RuleTableExpr, precedence);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1873);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 231, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<TableExprIdentifierContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1861);
tableIdentifier();
break;
}
case 2: {
_localctx = _tracker.createInstance<TableExprFunctionContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1862);
tableFunctionExpr();
break;
}
case 3: {
_localctx = _tracker.createInstance<TableExprSubqueryContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1863);
match(InsightsQLParser::LPAREN);
setState(1864);
selectSetStmt();
setState(1865);
match(InsightsQLParser::RPAREN);
break;
}
case 4: {
_localctx = _tracker.createInstance<TableExprValuesContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1867);
match(InsightsQLParser::LPAREN);
setState(1868);
valuesClause();
setState(1869);
match(InsightsQLParser::RPAREN);
break;
}
case 5: {
_localctx = _tracker.createInstance<TableExprTagContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1871);
insightsqlxTagElement();
break;
}
case 6: {
_localctx = _tracker.createInstance<TableExprPlaceholderContext>(_localctx);
_ctx = _localctx;
previousContext = _localctx;
setState(1872);
placeholder();
break;
}
default:
break;
}
_ctx->stop = _input->LT(-1);
setState(1908);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
setState(1906);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _ctx)) {
case 1: {
auto newContext = _tracker.createInstance<TableExprPivotContext>(_tracker.createInstance<TableExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleTableExpr);
setState(1875);
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1876);
match(InsightsQLParser::PIVOT);
setState(1877);
match(InsightsQLParser::LPAREN);
setState(1878);
columnExprList();
setState(1879);
pivotColumnList();
setState(1883);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::GROUP) {
setState(1880);
match(InsightsQLParser::GROUP);
setState(1881);
match(InsightsQLParser::BY);
setState(1882);
columnExprList();
}
setState(1885);
match(InsightsQLParser::RPAREN);
break;
}
case 2: {
auto newContext = _tracker.createInstance<TableExprUnpivotContext>(_tracker.createInstance<TableExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleTableExpr);
setState(1887);
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1888);
match(InsightsQLParser::UNPIVOT);
setState(1891);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::INCLUDE) {
setState(1889);
match(InsightsQLParser::INCLUDE);
setState(1890);
match(InsightsQLParser::NULLS);
}
setState(1893);
match(InsightsQLParser::LPAREN);
setState(1894);
unpivotColumnList();
setState(1895);
match(InsightsQLParser::RPAREN);
break;
}
case 3: {
auto newContext = _tracker.createInstance<TableExprAliasContext>(_tracker.createInstance<TableExprContext>(parentContext, parentState));
_localctx = newContext;
pushNewRecursionContext(newContext, startState, RuleTableExpr);
setState(1897);
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1901);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::DATE:
case InsightsQLParser::FIRST:
case InsightsQLParser::ID:
case InsightsQLParser::KEY:
case InsightsQLParser::IDENTIFIER:
case InsightsQLParser::QUOTED_IDENTIFIER: {
setState(1898);
alias();
break;
}
case InsightsQLParser::AS: {
setState(1899);
match(InsightsQLParser::AS);
setState(1900);
identifier();
break;
}
default:
throw NoViableAltException(this);
}
setState(1904);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 235, _ctx)) {
case 1: {
setState(1903);
columnAliases();
break;
}
default:
break;
}
break;
}
default:
break;
}
}
setState(1910);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- PivotColumnListContext ------------------------------------------------------------------
InsightsQLParser::PivotColumnListContext::PivotColumnListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::PivotColumnListContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
std::vector<InsightsQLParser::PivotColumnContext *> InsightsQLParser::PivotColumnListContext::pivotColumn() {
return getRuleContexts<InsightsQLParser::PivotColumnContext>();
}
InsightsQLParser::PivotColumnContext* InsightsQLParser::PivotColumnListContext::pivotColumn(size_t i) {
return getRuleContext<InsightsQLParser::PivotColumnContext>(i);
}
size_t InsightsQLParser::PivotColumnListContext::getRuleIndex() const {
return InsightsQLParser::RulePivotColumnList;
}
std::any InsightsQLParser::PivotColumnListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitPivotColumnList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::PivotColumnListContext* InsightsQLParser::pivotColumnList() {
PivotColumnListContext *_localctx = _tracker.createInstance<PivotColumnListContext>(_ctx, getState());
enterRule(_localctx, 184, InsightsQLParser::RulePivotColumnList);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1911);
match(InsightsQLParser::FOR);
setState(1913);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(1912);
pivotColumn();
break;
}
default:
throw NoViableAltException(this);
}
setState(1915);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 238, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- PivotColumnContext ------------------------------------------------------------------
InsightsQLParser::PivotColumnContext::PivotColumnContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::ColumnExprTupleOrSingleContext* InsightsQLParser::PivotColumnContext::columnExprTupleOrSingle() {
return getRuleContext<InsightsQLParser::ColumnExprTupleOrSingleContext>(0);
}
tree::TerminalNode* InsightsQLParser::PivotColumnContext::IN() {
return getToken(InsightsQLParser::IN, 0);
}
tree::TerminalNode* InsightsQLParser::PivotColumnContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::PivotColumnContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::PivotColumnContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
size_t InsightsQLParser::PivotColumnContext::getRuleIndex() const {
return InsightsQLParser::RulePivotColumn;
}
std::any InsightsQLParser::PivotColumnContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitPivotColumn(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::PivotColumnContext* InsightsQLParser::pivotColumn() {
PivotColumnContext *_localctx = _tracker.createInstance<PivotColumnContext>(_ctx, getState());
enterRule(_localctx, 186, InsightsQLParser::RulePivotColumn);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1917);
columnExprTupleOrSingle();
setState(1918);
match(InsightsQLParser::IN);
setState(1919);
match(InsightsQLParser::LPAREN);
setState(1920);
columnExprList();
setState(1921);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- UnpivotColumnListContext ------------------------------------------------------------------
InsightsQLParser::UnpivotColumnListContext::UnpivotColumnListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::UnpivotColumnContext *> InsightsQLParser::UnpivotColumnListContext::unpivotColumn() {
return getRuleContexts<InsightsQLParser::UnpivotColumnContext>();
}
InsightsQLParser::UnpivotColumnContext* InsightsQLParser::UnpivotColumnListContext::unpivotColumn(size_t i) {
return getRuleContext<InsightsQLParser::UnpivotColumnContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::UnpivotColumnListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::UnpivotColumnListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::UnpivotColumnListContext::getRuleIndex() const {
return InsightsQLParser::RuleUnpivotColumnList;
}
std::any InsightsQLParser::UnpivotColumnListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitUnpivotColumnList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::UnpivotColumnListContext* InsightsQLParser::unpivotColumnList() {
UnpivotColumnListContext *_localctx = _tracker.createInstance<UnpivotColumnListContext>(_ctx, getState());
enterRule(_localctx, 188, InsightsQLParser::RuleUnpivotColumnList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1923);
unpivotColumn();
setState(1928);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 239, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1924);
match(InsightsQLParser::COMMA);
setState(1925);
unpivotColumn();
}
setState(1930);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 239, _ctx);
}
setState(1932);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1931);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- UnpivotColumnContext ------------------------------------------------------------------
InsightsQLParser::UnpivotColumnContext::UnpivotColumnContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnExprTupleOrSingleContext *> InsightsQLParser::UnpivotColumnContext::columnExprTupleOrSingle() {
return getRuleContexts<InsightsQLParser::ColumnExprTupleOrSingleContext>();
}
InsightsQLParser::ColumnExprTupleOrSingleContext* InsightsQLParser::UnpivotColumnContext::columnExprTupleOrSingle(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprTupleOrSingleContext>(i);
}
tree::TerminalNode* InsightsQLParser::UnpivotColumnContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::UnpivotColumnContext::IN() {
return getTokens(InsightsQLParser::IN);
}
tree::TerminalNode* InsightsQLParser::UnpivotColumnContext::IN(size_t i) {
return getToken(InsightsQLParser::IN, i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::UnpivotColumnContext::LPAREN() {
return getTokens(InsightsQLParser::LPAREN);
}
tree::TerminalNode* InsightsQLParser::UnpivotColumnContext::LPAREN(size_t i) {
return getToken(InsightsQLParser::LPAREN, i);
}
std::vector<InsightsQLParser::ColumnExprListContext *> InsightsQLParser::UnpivotColumnContext::columnExprList() {
return getRuleContexts<InsightsQLParser::ColumnExprListContext>();
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::UnpivotColumnContext::columnExprList(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::UnpivotColumnContext::RPAREN() {
return getTokens(InsightsQLParser::RPAREN);
}
tree::TerminalNode* InsightsQLParser::UnpivotColumnContext::RPAREN(size_t i) {
return getToken(InsightsQLParser::RPAREN, i);
}
size_t InsightsQLParser::UnpivotColumnContext::getRuleIndex() const {
return InsightsQLParser::RuleUnpivotColumn;
}
std::any InsightsQLParser::UnpivotColumnContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitUnpivotColumn(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::UnpivotColumnContext* InsightsQLParser::unpivotColumn() {
UnpivotColumnContext *_localctx = _tracker.createInstance<UnpivotColumnContext>(_ctx, getState());
enterRule(_localctx, 190, InsightsQLParser::RuleUnpivotColumn);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1934);
columnExprTupleOrSingle();
setState(1935);
match(InsightsQLParser::FOR);
setState(1936);
columnExprTupleOrSingle();
setState(1937);
match(InsightsQLParser::IN);
setState(1938);
match(InsightsQLParser::LPAREN);
setState(1939);
columnExprList();
setState(1940);
match(InsightsQLParser::RPAREN);
setState(1949);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1941);
columnExprTupleOrSingle();
setState(1942);
match(InsightsQLParser::IN);
setState(1943);
match(InsightsQLParser::LPAREN);
setState(1944);
columnExprList();
setState(1945);
match(InsightsQLParser::RPAREN);
setState(1951);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnExprTupleOrSingleContext ------------------------------------------------------------------
InsightsQLParser::ColumnExprTupleOrSingleContext::ColumnExprTupleOrSingleContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ColumnExprTupleOrSingleContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
InsightsQLParser::ColumnExprListContext* InsightsQLParser::ColumnExprTupleOrSingleContext::columnExprList() {
return getRuleContext<InsightsQLParser::ColumnExprListContext>(0);
}
tree::TerminalNode* InsightsQLParser::ColumnExprTupleOrSingleContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::ColumnExprTupleOrSingleContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
size_t InsightsQLParser::ColumnExprTupleOrSingleContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnExprTupleOrSingle;
}
std::any InsightsQLParser::ColumnExprTupleOrSingleContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnExprTupleOrSingle(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnExprTupleOrSingleContext* InsightsQLParser::columnExprTupleOrSingle() {
ColumnExprTupleOrSingleContext *_localctx = _tracker.createInstance<ColumnExprTupleOrSingleContext>(_ctx, getState());
enterRule(_localctx, 192, InsightsQLParser::RuleColumnExprTupleOrSingle);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1957);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 242, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1952);
match(InsightsQLParser::LPAREN);
setState(1953);
columnExprList();
setState(1954);
match(InsightsQLParser::RPAREN);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1956);
columnExpr(0);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ColumnAliasesContext ------------------------------------------------------------------
InsightsQLParser::ColumnAliasesContext::ColumnAliasesContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ColumnAliasesContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
std::vector<InsightsQLParser::IdentifierContext *> InsightsQLParser::ColumnAliasesContext::identifier() {
return getRuleContexts<InsightsQLParser::IdentifierContext>();
}
InsightsQLParser::IdentifierContext* InsightsQLParser::ColumnAliasesContext::identifier(size_t i) {
return getRuleContext<InsightsQLParser::IdentifierContext>(i);
}
tree::TerminalNode* InsightsQLParser::ColumnAliasesContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::ColumnAliasesContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::ColumnAliasesContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::ColumnAliasesContext::getRuleIndex() const {
return InsightsQLParser::RuleColumnAliases;
}
std::any InsightsQLParser::ColumnAliasesContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitColumnAliases(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ColumnAliasesContext* InsightsQLParser::columnAliases() {
ColumnAliasesContext *_localctx = _tracker.createInstance<ColumnAliasesContext>(_ctx, getState());
enterRule(_localctx, 194, InsightsQLParser::RuleColumnAliases);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1959);
match(InsightsQLParser::LPAREN);
setState(1960);
identifier();
setState(1965);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::COMMA) {
setState(1961);
match(InsightsQLParser::COMMA);
setState(1962);
identifier();
setState(1967);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1968);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TableFunctionExprContext ------------------------------------------------------------------
InsightsQLParser::TableFunctionExprContext::TableFunctionExprContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::IdentifierContext* InsightsQLParser::TableFunctionExprContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableFunctionExprContext::LPAREN() {
return getToken(InsightsQLParser::LPAREN, 0);
}
tree::TerminalNode* InsightsQLParser::TableFunctionExprContext::RPAREN() {
return getToken(InsightsQLParser::RPAREN, 0);
}
InsightsQLParser::TableArgListContext* InsightsQLParser::TableFunctionExprContext::tableArgList() {
return getRuleContext<InsightsQLParser::TableArgListContext>(0);
}
size_t InsightsQLParser::TableFunctionExprContext::getRuleIndex() const {
return InsightsQLParser::RuleTableFunctionExpr;
}
std::any InsightsQLParser::TableFunctionExprContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableFunctionExpr(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TableFunctionExprContext* InsightsQLParser::tableFunctionExpr() {
TableFunctionExprContext *_localctx = _tracker.createInstance<TableFunctionExprContext>(_ctx, getState());
enterRule(_localctx, 196, InsightsQLParser::RuleTableFunctionExpr);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1970);
identifier();
setState(1971);
match(InsightsQLParser::LPAREN);
setState(1973);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -18016683700535298) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 9214362638576779259) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 129)) & 1267309641555947) != 0)) {
setState(1972);
tableArgList();
}
setState(1975);
match(InsightsQLParser::RPAREN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TableIdentifierContext ------------------------------------------------------------------
InsightsQLParser::TableIdentifierContext::TableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::NestedIdentifierContext* InsightsQLParser::TableIdentifierContext::nestedIdentifier() {
return getRuleContext<InsightsQLParser::NestedIdentifierContext>(0);
}
InsightsQLParser::DatabaseIdentifierContext* InsightsQLParser::TableIdentifierContext::databaseIdentifier() {
return getRuleContext<InsightsQLParser::DatabaseIdentifierContext>(0);
}
tree::TerminalNode* InsightsQLParser::TableIdentifierContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
size_t InsightsQLParser::TableIdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleTableIdentifier;
}
std::any InsightsQLParser::TableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TableIdentifierContext* InsightsQLParser::tableIdentifier() {
TableIdentifierContext *_localctx = _tracker.createInstance<TableIdentifierContext>(_ctx, getState());
enterRule(_localctx, 198, InsightsQLParser::RuleTableIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1980);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx)) {
case 1: {
setState(1977);
databaseIdentifier();
setState(1978);
match(InsightsQLParser::DOT);
break;
}
default:
break;
}
setState(1982);
nestedIdentifier();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TableArgListContext ------------------------------------------------------------------
InsightsQLParser::TableArgListContext::TableArgListContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<InsightsQLParser::ColumnExprContext *> InsightsQLParser::TableArgListContext::columnExpr() {
return getRuleContexts<InsightsQLParser::ColumnExprContext>();
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::TableArgListContext::columnExpr(size_t i) {
return getRuleContext<InsightsQLParser::ColumnExprContext>(i);
}
std::vector<tree::TerminalNode *> InsightsQLParser::TableArgListContext::COMMA() {
return getTokens(InsightsQLParser::COMMA);
}
tree::TerminalNode* InsightsQLParser::TableArgListContext::COMMA(size_t i) {
return getToken(InsightsQLParser::COMMA, i);
}
size_t InsightsQLParser::TableArgListContext::getRuleIndex() const {
return InsightsQLParser::RuleTableArgList;
}
std::any InsightsQLParser::TableArgListContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTableArgList(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TableArgListContext* InsightsQLParser::tableArgList() {
TableArgListContext *_localctx = _tracker.createInstance<TableArgListContext>(_ctx, getState());
enterRule(_localctx, 200, InsightsQLParser::RuleTableArgList);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1984);
columnExpr(0);
setState(1989);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 246, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1985);
match(InsightsQLParser::COMMA);
setState(1986);
columnExpr(0);
}
setState(1991);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 246, _ctx);
}
setState(1993);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::COMMA) {
setState(1992);
match(InsightsQLParser::COMMA);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- DatabaseIdentifierContext ------------------------------------------------------------------
InsightsQLParser::DatabaseIdentifierContext::DatabaseIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::IdentifierContext* InsightsQLParser::DatabaseIdentifierContext::identifier() {
return getRuleContext<InsightsQLParser::IdentifierContext>(0);
}
size_t InsightsQLParser::DatabaseIdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleDatabaseIdentifier;
}
std::any InsightsQLParser::DatabaseIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitDatabaseIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::DatabaseIdentifierContext* InsightsQLParser::databaseIdentifier() {
DatabaseIdentifierContext *_localctx = _tracker.createInstance<DatabaseIdentifierContext>(_ctx, getState());
enterRule(_localctx, 202, InsightsQLParser::RuleDatabaseIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1995);
identifier();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- FloatingLiteralContext ------------------------------------------------------------------
InsightsQLParser::FloatingLiteralContext::FloatingLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::FloatingLiteralContext::FLOATING_LITERAL() {
return getToken(InsightsQLParser::FLOATING_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::FloatingLiteralContext::DOT() {
return getToken(InsightsQLParser::DOT, 0);
}
std::vector<tree::TerminalNode *> InsightsQLParser::FloatingLiteralContext::DECIMAL_LITERAL() {
return getTokens(InsightsQLParser::DECIMAL_LITERAL);
}
tree::TerminalNode* InsightsQLParser::FloatingLiteralContext::DECIMAL_LITERAL(size_t i) {
return getToken(InsightsQLParser::DECIMAL_LITERAL, i);
}
tree::TerminalNode* InsightsQLParser::FloatingLiteralContext::OCTAL_LITERAL() {
return getToken(InsightsQLParser::OCTAL_LITERAL, 0);
}
size_t InsightsQLParser::FloatingLiteralContext::getRuleIndex() const {
return InsightsQLParser::RuleFloatingLiteral;
}
std::any InsightsQLParser::FloatingLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFloatingLiteral(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::FloatingLiteralContext* InsightsQLParser::floatingLiteral() {
FloatingLiteralContext *_localctx = _tracker.createInstance<FloatingLiteralContext>(_ctx, getState());
enterRule(_localctx, 204, InsightsQLParser::RuleFloatingLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2005);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::FLOATING_LITERAL: {
enterOuterAlt(_localctx, 1);
setState(1997);
match(InsightsQLParser::FLOATING_LITERAL);
break;
}
case InsightsQLParser::DOT: {
enterOuterAlt(_localctx, 2);
setState(1998);
match(InsightsQLParser::DOT);
setState(1999);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::OCTAL_LITERAL
|| _la == InsightsQLParser::DECIMAL_LITERAL)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
case InsightsQLParser::DECIMAL_LITERAL: {
enterOuterAlt(_localctx, 3);
setState(2000);
match(InsightsQLParser::DECIMAL_LITERAL);
setState(2001);
match(InsightsQLParser::DOT);
setState(2003);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 248, _ctx)) {
case 1: {
setState(2002);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::OCTAL_LITERAL
|| _la == InsightsQLParser::DECIMAL_LITERAL)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
break;
}
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- NumberLiteralContext ------------------------------------------------------------------
InsightsQLParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::FloatingLiteralContext* InsightsQLParser::NumberLiteralContext::floatingLiteral() {
return getRuleContext<InsightsQLParser::FloatingLiteralContext>(0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::BINARY_LITERAL() {
return getToken(InsightsQLParser::BINARY_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::OCTAL_LITERAL() {
return getToken(InsightsQLParser::OCTAL_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::OCTAL_PREFIX_LITERAL() {
return getToken(InsightsQLParser::OCTAL_PREFIX_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::DECIMAL_LITERAL() {
return getToken(InsightsQLParser::DECIMAL_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::HEXADECIMAL_LITERAL() {
return getToken(InsightsQLParser::HEXADECIMAL_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::INF() {
return getToken(InsightsQLParser::INF, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::NAN_SQL() {
return getToken(InsightsQLParser::NAN_SQL, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::PLUS() {
return getToken(InsightsQLParser::PLUS, 0);
}
tree::TerminalNode* InsightsQLParser::NumberLiteralContext::DASH() {
return getToken(InsightsQLParser::DASH, 0);
}
size_t InsightsQLParser::NumberLiteralContext::getRuleIndex() const {
return InsightsQLParser::RuleNumberLiteral;
}
std::any InsightsQLParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitNumberLiteral(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::NumberLiteralContext* InsightsQLParser::numberLiteral() {
NumberLiteralContext *_localctx = _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
enterRule(_localctx, 206, InsightsQLParser::RuleNumberLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2008);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == InsightsQLParser::DASH
|| _la == InsightsQLParser::PLUS) {
setState(2007);
_la = _input->LA(1);
if (!(_la == InsightsQLParser::DASH
|| _la == InsightsQLParser::PLUS)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
setState(2018);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx)) {
case 1: {
setState(2010);
floatingLiteral();
break;
}
case 2: {
setState(2011);
match(InsightsQLParser::BINARY_LITERAL);
break;
}
case 3: {
setState(2012);
match(InsightsQLParser::OCTAL_LITERAL);
break;
}
case 4: {
setState(2013);
match(InsightsQLParser::OCTAL_PREFIX_LITERAL);
break;
}
case 5: {
setState(2014);
match(InsightsQLParser::DECIMAL_LITERAL);
break;
}
case 6: {
setState(2015);
match(InsightsQLParser::HEXADECIMAL_LITERAL);
break;
}
case 7: {
setState(2016);
match(InsightsQLParser::INF);
break;
}
case 8: {
setState(2017);
match(InsightsQLParser::NAN_SQL);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- LiteralContext ------------------------------------------------------------------
InsightsQLParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::NumberLiteralContext* InsightsQLParser::LiteralContext::numberLiteral() {
return getRuleContext<InsightsQLParser::NumberLiteralContext>(0);
}
tree::TerminalNode* InsightsQLParser::LiteralContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
tree::TerminalNode* InsightsQLParser::LiteralContext::NULL_SQL() {
return getToken(InsightsQLParser::NULL_SQL, 0);
}
size_t InsightsQLParser::LiteralContext::getRuleIndex() const {
return InsightsQLParser::RuleLiteral;
}
std::any InsightsQLParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitLiteral(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::LiteralContext* InsightsQLParser::literal() {
LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
enterRule(_localctx, 208, InsightsQLParser::RuleLiteral);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2023);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::INF:
case InsightsQLParser::NAN_SQL:
case InsightsQLParser::FLOATING_LITERAL:
case InsightsQLParser::BINARY_LITERAL:
case InsightsQLParser::OCTAL_LITERAL:
case InsightsQLParser::DECIMAL_LITERAL:
case InsightsQLParser::HEXADECIMAL_LITERAL:
case InsightsQLParser::OCTAL_PREFIX_LITERAL:
case InsightsQLParser::DASH:
case InsightsQLParser::DOT:
case InsightsQLParser::PLUS: {
enterOuterAlt(_localctx, 1);
setState(2020);
numberLiteral();
break;
}
case InsightsQLParser::STRING_LITERAL: {
enterOuterAlt(_localctx, 2);
setState(2021);
match(InsightsQLParser::STRING_LITERAL);
break;
}
case InsightsQLParser::NULL_SQL: {
enterOuterAlt(_localctx, 3);
setState(2022);
match(InsightsQLParser::NULL_SQL);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- IntervalContext ------------------------------------------------------------------
InsightsQLParser::IntervalContext::IntervalContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::IntervalContext::SECOND() {
return getToken(InsightsQLParser::SECOND, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::MINUTE() {
return getToken(InsightsQLParser::MINUTE, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::HOUR() {
return getToken(InsightsQLParser::HOUR, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::DAY() {
return getToken(InsightsQLParser::DAY, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::WEEK() {
return getToken(InsightsQLParser::WEEK, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::MONTH() {
return getToken(InsightsQLParser::MONTH, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::QUARTER() {
return getToken(InsightsQLParser::QUARTER, 0);
}
tree::TerminalNode* InsightsQLParser::IntervalContext::YEAR() {
return getToken(InsightsQLParser::YEAR, 0);
}
size_t InsightsQLParser::IntervalContext::getRuleIndex() const {
return InsightsQLParser::RuleInterval;
}
std::any InsightsQLParser::IntervalContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitInterval(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::IntervalContext* InsightsQLParser::interval() {
IntervalContext *_localctx = _tracker.createInstance<IntervalContext>(_ctx, getState());
enterRule(_localctx, 210, InsightsQLParser::RuleInterval);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2025);
_la = _input->LA(1);
if (!(((((_la - 22) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 22)) & 211106240921601) != 0) || ((((_la - 88) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 88)) & 17729624998913) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KeywordContext ------------------------------------------------------------------
InsightsQLParser::KeywordContext::KeywordContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ALL() {
return getToken(InsightsQLParser::ALL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::AND() {
return getToken(InsightsQLParser::AND, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ANTI() {
return getToken(InsightsQLParser::ANTI, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ANY() {
return getToken(InsightsQLParser::ANY, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ARRAY() {
return getToken(InsightsQLParser::ARRAY, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::AS() {
return getToken(InsightsQLParser::AS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ASCENDING() {
return getToken(InsightsQLParser::ASCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ASOF() {
return getToken(InsightsQLParser::ASOF, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::BETWEEN() {
return getToken(InsightsQLParser::BETWEEN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::BOTH() {
return getToken(InsightsQLParser::BOTH, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::BY() {
return getToken(InsightsQLParser::BY, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::CASE() {
return getToken(InsightsQLParser::CASE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::CAST() {
return getToken(InsightsQLParser::CAST, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::COHORT() {
return getToken(InsightsQLParser::COHORT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::COLLATE() {
return getToken(InsightsQLParser::COLLATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::COLUMNS() {
return getToken(InsightsQLParser::COLUMNS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::CROSS() {
return getToken(InsightsQLParser::CROSS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::CUBE() {
return getToken(InsightsQLParser::CUBE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::CURRENT() {
return getToken(InsightsQLParser::CURRENT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::DATE() {
return getToken(InsightsQLParser::DATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::DESC() {
return getToken(InsightsQLParser::DESC, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::DESCENDING() {
return getToken(InsightsQLParser::DESCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::DISTINCT() {
return getToken(InsightsQLParser::DISTINCT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ELSE() {
return getToken(InsightsQLParser::ELSE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::END() {
return getToken(InsightsQLParser::END, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::EXCLUDE() {
return getToken(InsightsQLParser::EXCLUDE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::EXTRACT() {
return getToken(InsightsQLParser::EXTRACT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FILL() {
return getToken(InsightsQLParser::FILL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FILTER() {
return getToken(InsightsQLParser::FILTER, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FINAL() {
return getToken(InsightsQLParser::FINAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FIRST() {
return getToken(InsightsQLParser::FIRST, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FOR() {
return getToken(InsightsQLParser::FOR, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FOLLOWING() {
return getToken(InsightsQLParser::FOLLOWING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FROM() {
return getToken(InsightsQLParser::FROM, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::FULL() {
return getToken(InsightsQLParser::FULL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::GROUP() {
return getToken(InsightsQLParser::GROUP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::HAVING() {
return getToken(InsightsQLParser::HAVING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ID() {
return getToken(InsightsQLParser::ID, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::INTERPOLATE() {
return getToken(InsightsQLParser::INTERPOLATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::IS() {
return getToken(InsightsQLParser::IS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::GROUPING() {
return getToken(InsightsQLParser::GROUPING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::IF() {
return getToken(InsightsQLParser::IF, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::IGNORE() {
return getToken(InsightsQLParser::IGNORE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ILIKE() {
return getToken(InsightsQLParser::ILIKE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::INCLUDE() {
return getToken(InsightsQLParser::INCLUDE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::IN() {
return getToken(InsightsQLParser::IN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::INNER() {
return getToken(InsightsQLParser::INNER, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::INTERVAL() {
return getToken(InsightsQLParser::INTERVAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::JOIN() {
return getToken(InsightsQLParser::JOIN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::KEY() {
return getToken(InsightsQLParser::KEY, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LAMBDA() {
return getToken(InsightsQLParser::LAMBDA, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LAST() {
return getToken(InsightsQLParser::LAST, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LEADING() {
return getToken(InsightsQLParser::LEADING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LEFT() {
return getToken(InsightsQLParser::LEFT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LIKE() {
return getToken(InsightsQLParser::LIKE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LIMIT() {
return getToken(InsightsQLParser::LIMIT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::LOCAL() {
return getToken(InsightsQLParser::LOCAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::NAME() {
return getToken(InsightsQLParser::NAME, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::NATURAL() {
return getToken(InsightsQLParser::NATURAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::NOT() {
return getToken(InsightsQLParser::NOT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::NULLS() {
return getToken(InsightsQLParser::NULLS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::OFFSET() {
return getToken(InsightsQLParser::OFFSET, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ON() {
return getToken(InsightsQLParser::ON, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::OR() {
return getToken(InsightsQLParser::OR, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ORDER() {
return getToken(InsightsQLParser::ORDER, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::OUTER() {
return getToken(InsightsQLParser::OUTER, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::OVER() {
return getToken(InsightsQLParser::OVER, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::PARTITION() {
return getToken(InsightsQLParser::PARTITION, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::PIVOT() {
return getToken(InsightsQLParser::PIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::POSITIONAL() {
return getToken(InsightsQLParser::POSITIONAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::PRECEDING() {
return getToken(InsightsQLParser::PRECEDING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::PREWHERE() {
return getToken(InsightsQLParser::PREWHERE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::QUALIFY() {
return getToken(InsightsQLParser::QUALIFY, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::RANGE() {
return getToken(InsightsQLParser::RANGE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::RECURSIVE() {
return getToken(InsightsQLParser::RECURSIVE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::REPLACE() {
return getToken(InsightsQLParser::REPLACE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::RETURN() {
return getToken(InsightsQLParser::RETURN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::RIGHT() {
return getToken(InsightsQLParser::RIGHT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ROLLUP() {
return getToken(InsightsQLParser::ROLLUP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ROW() {
return getToken(InsightsQLParser::ROW, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ROWS() {
return getToken(InsightsQLParser::ROWS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SAMPLE() {
return getToken(InsightsQLParser::SAMPLE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SELECT() {
return getToken(InsightsQLParser::SELECT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SEMI() {
return getToken(InsightsQLParser::SEMI, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SETS() {
return getToken(InsightsQLParser::SETS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SETTINGS() {
return getToken(InsightsQLParser::SETTINGS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::STEP() {
return getToken(InsightsQLParser::STEP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::SUBSTRING() {
return getToken(InsightsQLParser::SUBSTRING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::THEN() {
return getToken(InsightsQLParser::THEN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TIES() {
return getToken(InsightsQLParser::TIES, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TIME() {
return getToken(InsightsQLParser::TIME, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TIMESTAMP() {
return getToken(InsightsQLParser::TIMESTAMP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TOTALS() {
return getToken(InsightsQLParser::TOTALS, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TRAILING() {
return getToken(InsightsQLParser::TRAILING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TRIM() {
return getToken(InsightsQLParser::TRIM, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TRUNCATE() {
return getToken(InsightsQLParser::TRUNCATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TRY_CAST() {
return getToken(InsightsQLParser::TRY_CAST, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TO() {
return getToken(InsightsQLParser::TO, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::TOP() {
return getToken(InsightsQLParser::TOP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::UNBOUNDED() {
return getToken(InsightsQLParser::UNBOUNDED, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::UNION() {
return getToken(InsightsQLParser::UNION, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::UNPIVOT() {
return getToken(InsightsQLParser::UNPIVOT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::USING() {
return getToken(InsightsQLParser::USING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::VALUES() {
return getToken(InsightsQLParser::VALUES, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::WHEN() {
return getToken(InsightsQLParser::WHEN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::WHERE() {
return getToken(InsightsQLParser::WHERE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::WINDOW() {
return getToken(InsightsQLParser::WINDOW, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::WITH() {
return getToken(InsightsQLParser::WITH, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordContext::ZONE() {
return getToken(InsightsQLParser::ZONE, 0);
}
size_t InsightsQLParser::KeywordContext::getRuleIndex() const {
return InsightsQLParser::RuleKeyword;
}
std::any InsightsQLParser::KeywordContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKeyword(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KeywordContext* InsightsQLParser::keyword() {
KeywordContext *_localctx = _tracker.createInstance<KeywordContext>(_ctx, getState());
enterRule(_localctx, 212, InsightsQLParser::RuleKeyword);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2027);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -22555467704188930) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & 8061441125371608419) != 0) || _la == InsightsQLParser::WINDOW
|| _la == InsightsQLParser::WITH)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KeywordForAliasContext ------------------------------------------------------------------
InsightsQLParser::KeywordForAliasContext::KeywordForAliasContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::KeywordForAliasContext::DATE() {
return getToken(InsightsQLParser::DATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForAliasContext::FIRST() {
return getToken(InsightsQLParser::FIRST, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForAliasContext::ID() {
return getToken(InsightsQLParser::ID, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForAliasContext::KEY() {
return getToken(InsightsQLParser::KEY, 0);
}
size_t InsightsQLParser::KeywordForAliasContext::getRuleIndex() const {
return InsightsQLParser::RuleKeywordForAlias;
}
std::any InsightsQLParser::KeywordForAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKeywordForAlias(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KeywordForAliasContext* InsightsQLParser::keywordForAlias() {
KeywordForAliasContext *_localctx = _tracker.createInstance<KeywordForAliasContext>(_ctx, getState());
enterRule(_localctx, 214, InsightsQLParser::RuleKeywordForAlias);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2029);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 576531155409436672) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- KeywordForImplicitAliasContext ------------------------------------------------------------------
InsightsQLParser::KeywordForImplicitAliasContext::KeywordForImplicitAliasContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::ASCENDING() {
return getToken(InsightsQLParser::ASCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::COHORT() {
return getToken(InsightsQLParser::COHORT, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::DATE() {
return getToken(InsightsQLParser::DATE, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::DESCENDING() {
return getToken(InsightsQLParser::DESCENDING, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::FINAL() {
return getToken(InsightsQLParser::FINAL, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::ID() {
return getToken(InsightsQLParser::ID, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::RETURN() {
return getToken(InsightsQLParser::RETURN, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::TOP() {
return getToken(InsightsQLParser::TOP, 0);
}
tree::TerminalNode* InsightsQLParser::KeywordForImplicitAliasContext::TOTALS() {
return getToken(InsightsQLParser::TOTALS, 0);
}
size_t InsightsQLParser::KeywordForImplicitAliasContext::getRuleIndex() const {
return InsightsQLParser::RuleKeywordForImplicitAlias;
}
std::any InsightsQLParser::KeywordForImplicitAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitKeywordForImplicitAlias(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::KeywordForImplicitAliasContext* InsightsQLParser::keywordForImplicitAlias() {
KeywordForImplicitAliasContext *_localctx = _tracker.createInstance<KeywordForImplicitAliasContext>(_ctx, getState());
enterRule(_localctx, 216, InsightsQLParser::RuleKeywordForImplicitAlias);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2031);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 70370910568576) != 0) || ((((_la - 92) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 92)) & 6291457) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- AliasContext ------------------------------------------------------------------
InsightsQLParser::AliasContext::AliasContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::AliasContext::IDENTIFIER() {
return getToken(InsightsQLParser::IDENTIFIER, 0);
}
tree::TerminalNode* InsightsQLParser::AliasContext::QUOTED_IDENTIFIER() {
return getToken(InsightsQLParser::QUOTED_IDENTIFIER, 0);
}
InsightsQLParser::KeywordForAliasContext* InsightsQLParser::AliasContext::keywordForAlias() {
return getRuleContext<InsightsQLParser::KeywordForAliasContext>(0);
}
size_t InsightsQLParser::AliasContext::getRuleIndex() const {
return InsightsQLParser::RuleAlias;
}
std::any InsightsQLParser::AliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitAlias(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::AliasContext* InsightsQLParser::alias() {
AliasContext *_localctx = _tracker.createInstance<AliasContext>(_ctx, getState());
enterRule(_localctx, 218, InsightsQLParser::RuleAlias);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2036);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::IDENTIFIER: {
enterOuterAlt(_localctx, 1);
setState(2033);
match(InsightsQLParser::IDENTIFIER);
break;
}
case InsightsQLParser::QUOTED_IDENTIFIER: {
enterOuterAlt(_localctx, 2);
setState(2034);
match(InsightsQLParser::QUOTED_IDENTIFIER);
break;
}
case InsightsQLParser::DATE:
case InsightsQLParser::FIRST:
case InsightsQLParser::ID:
case InsightsQLParser::KEY: {
enterOuterAlt(_localctx, 3);
setState(2035);
keywordForAlias();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- ImplicitAliasContext ------------------------------------------------------------------
InsightsQLParser::ImplicitAliasContext::ImplicitAliasContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::ImplicitAliasContext::IDENTIFIER() {
return getToken(InsightsQLParser::IDENTIFIER, 0);
}
tree::TerminalNode* InsightsQLParser::ImplicitAliasContext::QUOTED_IDENTIFIER() {
return getToken(InsightsQLParser::QUOTED_IDENTIFIER, 0);
}
InsightsQLParser::KeywordForImplicitAliasContext* InsightsQLParser::ImplicitAliasContext::keywordForImplicitAlias() {
return getRuleContext<InsightsQLParser::KeywordForImplicitAliasContext>(0);
}
size_t InsightsQLParser::ImplicitAliasContext::getRuleIndex() const {
return InsightsQLParser::RuleImplicitAlias;
}
std::any InsightsQLParser::ImplicitAliasContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitImplicitAlias(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::ImplicitAliasContext* InsightsQLParser::implicitAlias() {
ImplicitAliasContext *_localctx = _tracker.createInstance<ImplicitAliasContext>(_ctx, getState());
enterRule(_localctx, 220, InsightsQLParser::RuleImplicitAlias);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2041);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::IDENTIFIER: {
enterOuterAlt(_localctx, 1);
setState(2038);
match(InsightsQLParser::IDENTIFIER);
break;
}
case InsightsQLParser::QUOTED_IDENTIFIER: {
enterOuterAlt(_localctx, 2);
setState(2039);
match(InsightsQLParser::QUOTED_IDENTIFIER);
break;
}
case InsightsQLParser::ASCENDING:
case InsightsQLParser::COHORT:
case InsightsQLParser::DATE:
case InsightsQLParser::DESCENDING:
case InsightsQLParser::FINAL:
case InsightsQLParser::ID:
case InsightsQLParser::RETURN:
case InsightsQLParser::TOP:
case InsightsQLParser::TOTALS: {
enterOuterAlt(_localctx, 3);
setState(2040);
keywordForImplicitAlias();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- IdentifierContext ------------------------------------------------------------------
InsightsQLParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::IdentifierContext::IDENTIFIER() {
return getToken(InsightsQLParser::IDENTIFIER, 0);
}
tree::TerminalNode* InsightsQLParser::IdentifierContext::QUOTED_IDENTIFIER() {
return getToken(InsightsQLParser::QUOTED_IDENTIFIER, 0);
}
InsightsQLParser::IntervalContext* InsightsQLParser::IdentifierContext::interval() {
return getRuleContext<InsightsQLParser::IntervalContext>(0);
}
InsightsQLParser::KeywordContext* InsightsQLParser::IdentifierContext::keyword() {
return getRuleContext<InsightsQLParser::KeywordContext>(0);
}
size_t InsightsQLParser::IdentifierContext::getRuleIndex() const {
return InsightsQLParser::RuleIdentifier;
}
std::any InsightsQLParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitIdentifier(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::IdentifierContext* InsightsQLParser::identifier() {
IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
enterRule(_localctx, 222, InsightsQLParser::RuleIdentifier);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2047);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::IDENTIFIER: {
enterOuterAlt(_localctx, 1);
setState(2043);
match(InsightsQLParser::IDENTIFIER);
break;
}
case InsightsQLParser::QUOTED_IDENTIFIER: {
enterOuterAlt(_localctx, 2);
setState(2044);
match(InsightsQLParser::QUOTED_IDENTIFIER);
break;
}
case InsightsQLParser::DAY:
case InsightsQLParser::HOUR:
case InsightsQLParser::MINUTE:
case InsightsQLParser::MONTH:
case InsightsQLParser::QUARTER:
case InsightsQLParser::SECOND:
case InsightsQLParser::WEEK:
case InsightsQLParser::YEAR: {
enterOuterAlt(_localctx, 3);
setState(2045);
interval();
break;
}
case InsightsQLParser::ALL:
case InsightsQLParser::AND:
case InsightsQLParser::ANTI:
case InsightsQLParser::ANY:
case InsightsQLParser::ARRAY:
case InsightsQLParser::AS:
case InsightsQLParser::ASCENDING:
case InsightsQLParser::ASOF:
case InsightsQLParser::BETWEEN:
case InsightsQLParser::BOTH:
case InsightsQLParser::BY:
case InsightsQLParser::CASE:
case InsightsQLParser::CAST:
case InsightsQLParser::COHORT:
case InsightsQLParser::COLLATE:
case InsightsQLParser::COLUMNS:
case InsightsQLParser::CROSS:
case InsightsQLParser::CUBE:
case InsightsQLParser::CURRENT:
case InsightsQLParser::DATE:
case InsightsQLParser::DESC:
case InsightsQLParser::DESCENDING:
case InsightsQLParser::DISTINCT:
case InsightsQLParser::ELSE:
case InsightsQLParser::END:
case InsightsQLParser::EXCLUDE:
case InsightsQLParser::EXTRACT:
case InsightsQLParser::FINAL:
case InsightsQLParser::FILL:
case InsightsQLParser::FILTER:
case InsightsQLParser::FIRST:
case InsightsQLParser::FOLLOWING:
case InsightsQLParser::FOR:
case InsightsQLParser::FROM:
case InsightsQLParser::FULL:
case InsightsQLParser::GROUP:
case InsightsQLParser::GROUPING:
case InsightsQLParser::HAVING:
case InsightsQLParser::ID:
case InsightsQLParser::IF:
case InsightsQLParser::ILIKE:
case InsightsQLParser::IGNORE:
case InsightsQLParser::INCLUDE:
case InsightsQLParser::IN:
case InsightsQLParser::INNER:
case InsightsQLParser::INTERPOLATE:
case InsightsQLParser::INTERVAL:
case InsightsQLParser::IS:
case InsightsQLParser::JOIN:
case InsightsQLParser::KEY:
case InsightsQLParser::LAMBDA:
case InsightsQLParser::LAST:
case InsightsQLParser::LEADING:
case InsightsQLParser::LEFT:
case InsightsQLParser::LIKE:
case InsightsQLParser::LIMIT:
case InsightsQLParser::NAME:
case InsightsQLParser::NATURAL:
case InsightsQLParser::NOT:
case InsightsQLParser::NULLS:
case InsightsQLParser::OFFSET:
case InsightsQLParser::ON:
case InsightsQLParser::OR:
case InsightsQLParser::ORDER:
case InsightsQLParser::OUTER:
case InsightsQLParser::OVER:
case InsightsQLParser::PARTITION:
case InsightsQLParser::PIVOT:
case InsightsQLParser::POSITIONAL:
case InsightsQLParser::PRECEDING:
case InsightsQLParser::PREWHERE:
case InsightsQLParser::QUALIFY:
case InsightsQLParser::RANGE:
case InsightsQLParser::RECURSIVE:
case InsightsQLParser::REPLACE:
case InsightsQLParser::RETURN:
case InsightsQLParser::RIGHT:
case InsightsQLParser::ROLLUP:
case InsightsQLParser::ROW:
case InsightsQLParser::ROWS:
case InsightsQLParser::SAMPLE:
case InsightsQLParser::SELECT:
case InsightsQLParser::SEMI:
case InsightsQLParser::SETS:
case InsightsQLParser::SETTINGS:
case InsightsQLParser::STEP:
case InsightsQLParser::SUBSTRING:
case InsightsQLParser::THEN:
case InsightsQLParser::TIES:
case InsightsQLParser::TIMESTAMP:
case InsightsQLParser::TIME:
case InsightsQLParser::LOCAL:
case InsightsQLParser::ZONE:
case InsightsQLParser::TO:
case InsightsQLParser::TOP:
case InsightsQLParser::TOTALS:
case InsightsQLParser::TRAILING:
case InsightsQLParser::TRIM:
case InsightsQLParser::TRUNCATE:
case InsightsQLParser::TRY_CAST:
case InsightsQLParser::UNBOUNDED:
case InsightsQLParser::UNION:
case InsightsQLParser::UNPIVOT:
case InsightsQLParser::USING:
case InsightsQLParser::VALUES:
case InsightsQLParser::WHEN:
case InsightsQLParser::WHERE:
case InsightsQLParser::WINDOW:
case InsightsQLParser::WITH: {
enterOuterAlt(_localctx, 4);
setState(2046);
keyword();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- EnumValueContext ------------------------------------------------------------------
InsightsQLParser::EnumValueContext::EnumValueContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
InsightsQLParser::StringContext* InsightsQLParser::EnumValueContext::string() {
return getRuleContext<InsightsQLParser::StringContext>(0);
}
tree::TerminalNode* InsightsQLParser::EnumValueContext::EQ_SINGLE() {
return getToken(InsightsQLParser::EQ_SINGLE, 0);
}
InsightsQLParser::NumberLiteralContext* InsightsQLParser::EnumValueContext::numberLiteral() {
return getRuleContext<InsightsQLParser::NumberLiteralContext>(0);
}
size_t InsightsQLParser::EnumValueContext::getRuleIndex() const {
return InsightsQLParser::RuleEnumValue;
}
std::any InsightsQLParser::EnumValueContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitEnumValue(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::EnumValueContext* InsightsQLParser::enumValue() {
EnumValueContext *_localctx = _tracker.createInstance<EnumValueContext>(_ctx, getState());
enterRule(_localctx, 224, InsightsQLParser::RuleEnumValue);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2049);
string();
setState(2050);
match(InsightsQLParser::EQ_SINGLE);
setState(2051);
numberLiteral();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- PlaceholderContext ------------------------------------------------------------------
InsightsQLParser::PlaceholderContext::PlaceholderContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::PlaceholderContext::LBRACE() {
return getToken(InsightsQLParser::LBRACE, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::PlaceholderContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::PlaceholderContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
size_t InsightsQLParser::PlaceholderContext::getRuleIndex() const {
return InsightsQLParser::RulePlaceholder;
}
std::any InsightsQLParser::PlaceholderContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitPlaceholder(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::PlaceholderContext* InsightsQLParser::placeholder() {
PlaceholderContext *_localctx = _tracker.createInstance<PlaceholderContext>(_ctx, getState());
enterRule(_localctx, 226, InsightsQLParser::RulePlaceholder);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2053);
match(InsightsQLParser::LBRACE);
setState(2054);
columnExpr(0);
setState(2055);
match(InsightsQLParser::RBRACE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- StringContext ------------------------------------------------------------------
InsightsQLParser::StringContext::StringContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::StringContext::STRING_LITERAL() {
return getToken(InsightsQLParser::STRING_LITERAL, 0);
}
InsightsQLParser::TemplateStringContext* InsightsQLParser::StringContext::templateString() {
return getRuleContext<InsightsQLParser::TemplateStringContext>(0);
}
size_t InsightsQLParser::StringContext::getRuleIndex() const {
return InsightsQLParser::RuleString;
}
std::any InsightsQLParser::StringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitString(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::StringContext* InsightsQLParser::string() {
StringContext *_localctx = _tracker.createInstance<StringContext>(_ctx, getState());
enterRule(_localctx, 228, InsightsQLParser::RuleString);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2059);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::STRING_LITERAL: {
enterOuterAlt(_localctx, 1);
setState(2057);
match(InsightsQLParser::STRING_LITERAL);
break;
}
case InsightsQLParser::QUOTE_SINGLE_TEMPLATE: {
enterOuterAlt(_localctx, 2);
setState(2058);
templateString();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- TemplateStringContext ------------------------------------------------------------------
InsightsQLParser::TemplateStringContext::TemplateStringContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::TemplateStringContext::QUOTE_SINGLE_TEMPLATE() {
return getToken(InsightsQLParser::QUOTE_SINGLE_TEMPLATE, 0);
}
tree::TerminalNode* InsightsQLParser::TemplateStringContext::QUOTE_SINGLE() {
return getToken(InsightsQLParser::QUOTE_SINGLE, 0);
}
std::vector<InsightsQLParser::StringContentsContext *> InsightsQLParser::TemplateStringContext::stringContents() {
return getRuleContexts<InsightsQLParser::StringContentsContext>();
}
InsightsQLParser::StringContentsContext* InsightsQLParser::TemplateStringContext::stringContents(size_t i) {
return getRuleContext<InsightsQLParser::StringContentsContext>(i);
}
size_t InsightsQLParser::TemplateStringContext::getRuleIndex() const {
return InsightsQLParser::RuleTemplateString;
}
std::any InsightsQLParser::TemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitTemplateString(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::TemplateStringContext* InsightsQLParser::templateString() {
TemplateStringContext *_localctx = _tracker.createInstance<TemplateStringContext>(_ctx, getState());
enterRule(_localctx, 230, InsightsQLParser::RuleTemplateString);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2061);
match(InsightsQLParser::QUOTE_SINGLE_TEMPLATE);
setState(2065);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::STRING_TEXT
|| _la == InsightsQLParser::STRING_ESCAPE_TRIGGER) {
setState(2062);
stringContents();
setState(2067);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2068);
match(InsightsQLParser::QUOTE_SINGLE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- StringContentsContext ------------------------------------------------------------------
InsightsQLParser::StringContentsContext::StringContentsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::StringContentsContext::STRING_ESCAPE_TRIGGER() {
return getToken(InsightsQLParser::STRING_ESCAPE_TRIGGER, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::StringContentsContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::StringContentsContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
tree::TerminalNode* InsightsQLParser::StringContentsContext::STRING_TEXT() {
return getToken(InsightsQLParser::STRING_TEXT, 0);
}
size_t InsightsQLParser::StringContentsContext::getRuleIndex() const {
return InsightsQLParser::RuleStringContents;
}
std::any InsightsQLParser::StringContentsContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitStringContents(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::StringContentsContext* InsightsQLParser::stringContents() {
StringContentsContext *_localctx = _tracker.createInstance<StringContentsContext>(_ctx, getState());
enterRule(_localctx, 232, InsightsQLParser::RuleStringContents);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2075);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::STRING_ESCAPE_TRIGGER: {
enterOuterAlt(_localctx, 1);
setState(2070);
match(InsightsQLParser::STRING_ESCAPE_TRIGGER);
setState(2071);
columnExpr(0);
setState(2072);
match(InsightsQLParser::RBRACE);
break;
}
case InsightsQLParser::STRING_TEXT: {
enterOuterAlt(_localctx, 2);
setState(2074);
match(InsightsQLParser::STRING_TEXT);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- FullTemplateStringContext ------------------------------------------------------------------
InsightsQLParser::FullTemplateStringContext::FullTemplateStringContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::FullTemplateStringContext::QUOTE_SINGLE_TEMPLATE_FULL() {
return getToken(InsightsQLParser::QUOTE_SINGLE_TEMPLATE_FULL, 0);
}
tree::TerminalNode* InsightsQLParser::FullTemplateStringContext::EOF() {
return getToken(InsightsQLParser::EOF, 0);
}
std::vector<InsightsQLParser::StringContentsFullContext *> InsightsQLParser::FullTemplateStringContext::stringContentsFull() {
return getRuleContexts<InsightsQLParser::StringContentsFullContext>();
}
InsightsQLParser::StringContentsFullContext* InsightsQLParser::FullTemplateStringContext::stringContentsFull(size_t i) {
return getRuleContext<InsightsQLParser::StringContentsFullContext>(i);
}
size_t InsightsQLParser::FullTemplateStringContext::getRuleIndex() const {
return InsightsQLParser::RuleFullTemplateString;
}
std::any InsightsQLParser::FullTemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitFullTemplateString(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::FullTemplateStringContext* InsightsQLParser::fullTemplateString() {
FullTemplateStringContext *_localctx = _tracker.createInstance<FullTemplateStringContext>(_ctx, getState());
enterRule(_localctx, 234, InsightsQLParser::RuleFullTemplateString);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2077);
match(InsightsQLParser::QUOTE_SINGLE_TEMPLATE_FULL);
setState(2081);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == InsightsQLParser::FULL_STRING_TEXT
|| _la == InsightsQLParser::FULL_STRING_ESCAPE_TRIGGER) {
setState(2078);
stringContentsFull();
setState(2083);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2084);
match(InsightsQLParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
//----------------- StringContentsFullContext ------------------------------------------------------------------
InsightsQLParser::StringContentsFullContext::StringContentsFullContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* InsightsQLParser::StringContentsFullContext::FULL_STRING_ESCAPE_TRIGGER() {
return getToken(InsightsQLParser::FULL_STRING_ESCAPE_TRIGGER, 0);
}
InsightsQLParser::ColumnExprContext* InsightsQLParser::StringContentsFullContext::columnExpr() {
return getRuleContext<InsightsQLParser::ColumnExprContext>(0);
}
tree::TerminalNode* InsightsQLParser::StringContentsFullContext::RBRACE() {
return getToken(InsightsQLParser::RBRACE, 0);
}
tree::TerminalNode* InsightsQLParser::StringContentsFullContext::FULL_STRING_TEXT() {
return getToken(InsightsQLParser::FULL_STRING_TEXT, 0);
}
size_t InsightsQLParser::StringContentsFullContext::getRuleIndex() const {
return InsightsQLParser::RuleStringContentsFull;
}
std::any InsightsQLParser::StringContentsFullContext::accept(tree::ParseTreeVisitor *visitor) {
if (auto parserVisitor = dynamic_cast<InsightsQLParserVisitor*>(visitor))
return parserVisitor->visitStringContentsFull(this);
else
return visitor->visitChildren(this);
}
InsightsQLParser::StringContentsFullContext* InsightsQLParser::stringContentsFull() {
StringContentsFullContext *_localctx = _tracker.createInstance<StringContentsFullContext>(_ctx, getState());
enterRule(_localctx, 236, InsightsQLParser::RuleStringContentsFull);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2091);
_errHandler->sync(this);
switch (_input->LA(1)) {
case InsightsQLParser::FULL_STRING_ESCAPE_TRIGGER: {
enterOuterAlt(_localctx, 1);
setState(2086);
match(InsightsQLParser::FULL_STRING_ESCAPE_TRIGGER);
setState(2087);
columnExpr(0);
setState(2088);
match(InsightsQLParser::RBRACE);
break;
}
case InsightsQLParser::FULL_STRING_TEXT: {
enterOuterAlt(_localctx, 2);
setState(2090);
match(InsightsQLParser::FULL_STRING_TEXT);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
bool InsightsQLParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
switch (ruleIndex) {
case 48: return joinExprSempred(antlrcpp::downCast<JoinExprContext *>(context), predicateIndex);
case 69: return columnTypeExprSempred(antlrcpp::downCast<ColumnTypeExprContext *>(context), predicateIndex);
case 77: return columnExprSempred(antlrcpp::downCast<ColumnExprContext *>(context), predicateIndex);
case 78: return columnExprValueSempred(antlrcpp::downCast<ColumnExprValueContext *>(context), predicateIndex);
case 91: return tableExprSempred(antlrcpp::downCast<TableExprContext *>(context), predicateIndex);
default:
break;
}
return true;
}
bool InsightsQLParser::joinExprSempred(JoinExprContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 0: return precpred(_ctx, 5);
case 1: return precpred(_ctx, 7);
case 2: return precpred(_ctx, 6);
case 3: return precpred(_ctx, 4);
case 4: return precpred(_ctx, 3);
default:
break;
}
return true;
}
bool InsightsQLParser::columnTypeExprSempred(ColumnTypeExprContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 5: return precpred(_ctx, 7);
default:
break;
}
return true;
}
bool InsightsQLParser::columnExprSempred(ColumnExprContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 6: return precpred(_ctx, 5);
case 7: return precpred(_ctx, 4);
case 8: return precpred(_ctx, 3);
case 9: return precpred(_ctx, 2);
default:
break;
}
return true;
}
bool InsightsQLParser::columnExprValueSempred(ColumnExprValueContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 10: return precpred(_ctx, 21);
case 11: return precpred(_ctx, 20);
case 12: return precpred(_ctx, 19);
case 13: return precpred(_ctx, 16);
case 14: return precpred(_ctx, 15);
case 15: return precpred(_ctx, 14);
case 16: return precpred(_ctx, 13);
case 17: return precpred(_ctx, 35);
case 18: return precpred(_ctx, 34);
case 19: return precpred(_ctx, 30);
case 20: return precpred(_ctx, 29);
case 21: return precpred(_ctx, 28);
case 22: return precpred(_ctx, 27);
case 23: return precpred(_ctx, 26);
case 24: return precpred(_ctx, 25);
case 25: return precpred(_ctx, 24);
case 26: return precpred(_ctx, 23);
case 27: return precpred(_ctx, 18);
case 28: return precpred(_ctx, 17);
default:
break;
}
return true;
}
bool InsightsQLParser::tableExprSempred(TableExprContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 29: return precpred(_ctx, 5);
case 30: return precpred(_ctx, 4);
case 31: return precpred(_ctx, 3);
default:
break;
}
return true;
}
void InsightsQLParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
insightsqlparserParserInitialize();
#else
::antlr4::internal::call_once(insightsqlparserParserOnceFlag, insightsqlparserParserInitialize);
#endif
}
Reference in New Issue View Git Blame Copy Permalink