mirror of
https://github.com/BillyOutlast/posthog.git
synced 2026-02-09 13:41:20 +01:00
10047 lines
313 KiB
C++
10047 lines
313 KiB
C++
|
|
// Generated from HogQLParser.g4 by ANTLR 4.13.1
|
|
|
|
|
|
#include "HogQLParserVisitor.h"
|
|
|
|
#include "HogQLParser.h"
|
|
|
|
|
|
using namespace antlrcpp;
|
|
|
|
using namespace antlr4;
|
|
|
|
namespace {
|
|
|
|
struct HogQLParserStaticData final {
|
|
HogQLParserStaticData(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) {}
|
|
|
|
HogQLParserStaticData(const HogQLParserStaticData&) = delete;
|
|
HogQLParserStaticData(HogQLParserStaticData&&) = delete;
|
|
HogQLParserStaticData& operator=(const HogQLParserStaticData&) = delete;
|
|
HogQLParserStaticData& operator=(HogQLParserStaticData&&) = 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 hogqlparserParserOnceFlag;
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
static thread_local
|
|
#endif
|
|
HogQLParserStaticData *hogqlparserParserStaticData = nullptr;
|
|
|
|
void hogqlparserParserInitialize() {
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
if (hogqlparserParserStaticData != nullptr) {
|
|
return;
|
|
}
|
|
#else
|
|
assert(hogqlparserParserStaticData == nullptr);
|
|
#endif
|
|
auto staticData = std::make_unique<HogQLParserStaticData>(
|
|
std::vector<std::string>{
|
|
"select", "selectUnionStmt", "selectStmtWithParens", "selectStmt",
|
|
"withClause", "topClause", "fromClause", "arrayJoinClause", "windowClause",
|
|
"prewhereClause", "whereClause", "groupByClause", "havingClause",
|
|
"orderByClause", "projectionOrderByClause", "limitAndOffsetClause",
|
|
"offsetOnlyClause", "settingsClause", "joinExpr", "joinOp", "joinOpCross",
|
|
"joinConstraintClause", "sampleClause", "orderExprList", "orderExpr",
|
|
"ratioExpr", "settingExprList", "settingExpr", "windowExpr", "winPartitionByClause",
|
|
"winOrderByClause", "winFrameClause", "winFrameExtend", "winFrameBound",
|
|
"expr", "columnTypeExpr", "columnExprList", "columnExpr", "columnArgList",
|
|
"columnArgExpr", "columnLambdaExpr", "hogqlxTagElement", "hogqlxTagAttribute",
|
|
"withExprList", "withExpr", "columnIdentifier", "nestedIdentifier",
|
|
"tableExpr", "tableFunctionExpr", "tableIdentifier", "tableArgList",
|
|
"databaseIdentifier", "floatingLiteral", "numberLiteral", "literal",
|
|
"interval", "keyword", "keywordForAlias", "alias", "identifier", "enumValue",
|
|
"placeholder"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "'false'", "'true'", "", "", "", "", "", "", "", "",
|
|
"'->'", "'*'", "'`'", "'\\'", "':'", "','", "'||'", "'-'", "'$'",
|
|
"'.'", "'=='", "'='", "'>='", "'>'", "'#'", "'~*'", "'=~*'", "'{'",
|
|
"'['", "'('", "'<='", "'<'", "", "'!~*'", "'!~'", "'\\u003F\\u003F'",
|
|
"'%'", "'+'", "'\\u003F'", "'\"'", "'''", "'~'", "'=~'", "'}'", "']'",
|
|
"')'", "';'", "'/'", "'_'"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "ADD", "AFTER", "ALIAS", "ALL", "ALTER", "AND", "ANTI", "ANY",
|
|
"ARRAY", "AS", "ASCENDING", "ASOF", "AST", "ASYNC", "ATTACH", "BETWEEN",
|
|
"BOTH", "BY", "CASE", "CAST", "CHECK", "CLEAR", "CLUSTER", "CODEC",
|
|
"COHORT", "COLLATE", "COLUMN", "COMMENT", "CONSTRAINT", "CREATE",
|
|
"CROSS", "CUBE", "CURRENT", "DATABASE", "DATABASES", "DATE", "DAY",
|
|
"DEDUPLICATE", "DEFAULT", "DELAY", "DELETE", "DESC", "DESCENDING",
|
|
"DESCRIBE", "DETACH", "DICTIONARIES", "DICTIONARY", "DISK", "DISTINCT",
|
|
"DISTRIBUTED", "DROP", "ELSE", "END", "ENGINE", "EVENTS", "EXISTS",
|
|
"EXPLAIN", "EXPRESSION", "EXTRACT", "FETCHES", "FINAL", "FIRST", "FLUSH",
|
|
"FOLLOWING", "FOR", "FORMAT", "FREEZE", "FROM", "FULL", "FUNCTION",
|
|
"GLOBAL", "GRANULARITY", "GROUP", "HAVING", "HIERARCHICAL", "HOUR",
|
|
"ID", "IF", "ILIKE", "IN", "INDEX", "INF", "INJECTIVE", "INNER", "INSERT",
|
|
"INTERVAL", "INTO", "IS", "IS_OBJECT_ID", "JOIN", "KEY", "KILL", "LAST",
|
|
"LAYOUT", "LEADING", "LEFT", "LIFETIME", "LIKE", "LIMIT", "LIVE",
|
|
"LOCAL", "LOGS", "MATERIALIZE", "MATERIALIZED", "MAX", "MERGES", "MIN",
|
|
"MINUTE", "MODIFY", "MONTH", "MOVE", "MUTATION", "NAN_SQL", "NO",
|
|
"NOT", "NULL_SQL", "NULLS", "OFFSET", "ON", "OPTIMIZE", "OR", "ORDER",
|
|
"OUTER", "OUTFILE", "OVER", "PARTITION", "POPULATE", "PRECEDING",
|
|
"PREWHERE", "PRIMARY", "PROJECTION", "QUARTER", "RANGE", "RELOAD",
|
|
"REMOVE", "RENAME", "REPLACE", "REPLICA", "REPLICATED", "RIGHT", "ROLLUP",
|
|
"ROW", "ROWS", "SAMPLE", "SECOND", "SELECT", "SEMI", "SENDS", "SET",
|
|
"SETTINGS", "SHOW", "SOURCE", "START", "STOP", "SUBSTRING", "SYNC",
|
|
"SYNTAX", "SYSTEM", "TABLE", "TABLES", "TEMPORARY", "TEST", "THEN",
|
|
"TIES", "TIMEOUT", "TIMESTAMP", "TO", "TOP", "TOTALS", "TRAILING",
|
|
"TRIM", "TRUNCATE", "TTL", "TYPE", "UNBOUNDED", "UNION", "UPDATE",
|
|
"USE", "USING", "UUID", "VALUES", "VIEW", "VOLUME", "WATCH", "WEEK",
|
|
"WHEN", "WHERE", "WINDOW", "WITH", "YEAR", "JSON_FALSE", "JSON_TRUE",
|
|
"ESCAPE_CHAR_SINGLE", "ESCAPE_CHAR_DOUBLE", "IDENTIFIER", "FLOATING_LITERAL",
|
|
"OCTAL_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "STRING_LITERAL",
|
|
"ARROW", "ASTERISK", "BACKQUOTE", "BACKSLASH", "COLON", "COMMA", "CONCAT",
|
|
"DASH", "DOLLAR", "DOT", "EQ_DOUBLE", "EQ_SINGLE", "GT_EQ", "GT",
|
|
"HASH", "IREGEX_SINGLE", "IREGEX_DOUBLE", "LBRACE", "LBRACKET", "LPAREN",
|
|
"LT_EQ", "LT", "NOT_EQ", "NOT_IREGEX", "NOT_REGEX", "NULLISH", "PERCENT",
|
|
"PLUS", "QUERY", "QUOTE_DOUBLE", "QUOTE_SINGLE", "REGEX_SINGLE", "REGEX_DOUBLE",
|
|
"RBRACE", "RBRACKET", "RPAREN", "SEMICOLON", "SLASH", "UNDERSCORE",
|
|
"MULTI_LINE_COMMENT", "SINGLE_LINE_COMMENT", "WHITESPACE"
|
|
}
|
|
);
|
|
static const int32_t serializedATNSegment[] = {
|
|
4,1,242,978,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,1,0,1,0,1,0,3,0,
|
|
128,8,0,1,0,1,0,1,1,1,1,1,1,1,1,5,1,136,8,1,10,1,12,1,139,9,1,1,2,1,2,
|
|
1,2,1,2,1,2,3,2,146,8,2,1,3,3,3,149,8,3,1,3,1,3,3,3,153,8,3,1,3,3,3,156,
|
|
8,3,1,3,1,3,3,3,160,8,3,1,3,3,3,163,8,3,1,3,3,3,166,8,3,1,3,3,3,169,8,
|
|
3,1,3,3,3,172,8,3,1,3,1,3,3,3,176,8,3,1,3,1,3,3,3,180,8,3,1,3,3,3,183,
|
|
8,3,1,3,3,3,186,8,3,1,3,3,3,189,8,3,1,3,1,3,3,3,193,8,3,1,3,3,3,196,8,
|
|
3,1,4,1,4,1,4,1,5,1,5,1,5,1,5,3,5,205,8,5,1,6,1,6,1,6,1,7,3,7,211,8,7,
|
|
1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,5,
|
|
8,230,8,8,10,8,12,8,233,9,8,1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11,1,11,
|
|
1,11,1,11,1,11,1,11,1,11,3,11,249,8,11,1,12,1,12,1,12,1,13,1,13,1,13,
|
|
1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,3,15,266,8,15,1,15,1,15,
|
|
1,15,1,15,3,15,272,8,15,1,15,1,15,1,15,1,15,3,15,278,8,15,1,15,1,15,1,
|
|
15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,289,8,15,3,15,291,8,15,1,16,1,16,
|
|
1,16,1,17,1,17,1,17,1,18,1,18,1,18,3,18,302,8,18,1,18,3,18,305,8,18,1,
|
|
18,1,18,1,18,1,18,3,18,311,8,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,319,
|
|
8,18,1,18,1,18,1,18,1,18,5,18,325,8,18,10,18,12,18,328,9,18,1,19,3,19,
|
|
331,8,19,1,19,1,19,1,19,3,19,336,8,19,1,19,3,19,339,8,19,1,19,3,19,342,
|
|
8,19,1,19,1,19,3,19,346,8,19,1,19,1,19,3,19,350,8,19,1,19,3,19,353,8,
|
|
19,3,19,355,8,19,1,19,3,19,358,8,19,1,19,1,19,3,19,362,8,19,1,19,1,19,
|
|
3,19,366,8,19,1,19,3,19,369,8,19,3,19,371,8,19,3,19,373,8,19,1,20,1,20,
|
|
1,20,3,20,378,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,3,21,
|
|
389,8,21,1,22,1,22,1,22,1,22,3,22,395,8,22,1,23,1,23,1,23,5,23,400,8,
|
|
23,10,23,12,23,403,9,23,1,24,1,24,3,24,407,8,24,1,24,1,24,3,24,411,8,
|
|
24,1,24,1,24,3,24,415,8,24,1,25,1,25,1,25,1,25,3,25,421,8,25,3,25,423,
|
|
8,25,1,26,1,26,1,26,5,26,428,8,26,10,26,12,26,431,9,26,1,27,1,27,1,27,
|
|
1,27,1,28,3,28,438,8,28,1,28,3,28,441,8,28,1,28,3,28,444,8,28,1,29,1,
|
|
29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,
|
|
32,1,32,3,32,463,8,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
|
|
33,1,33,1,33,3,33,477,8,33,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,
|
|
35,1,35,1,35,1,35,5,35,491,8,35,10,35,12,35,494,9,35,1,35,1,35,1,35,1,
|
|
35,1,35,1,35,1,35,5,35,503,8,35,10,35,12,35,506,9,35,1,35,1,35,1,35,1,
|
|
35,1,35,1,35,1,35,5,35,515,8,35,10,35,12,35,518,9,35,1,35,1,35,1,35,1,
|
|
35,1,35,3,35,525,8,35,1,35,1,35,3,35,529,8,35,1,36,1,36,1,36,5,36,534,
|
|
8,36,10,36,12,36,537,9,36,1,37,1,37,1,37,3,37,542,8,37,1,37,1,37,1,37,
|
|
1,37,1,37,4,37,549,8,37,11,37,12,37,550,1,37,1,37,3,37,555,8,37,1,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
3,37,586,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,1,37,1,37,3,37,603,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,1,37,3,37,615,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
3,37,625,8,37,1,37,3,37,628,8,37,1,37,1,37,3,37,632,8,37,1,37,3,37,635,
|
|
8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,648,
|
|
8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,3,37,665,8,37,1,37,1,37,3,37,669,8,37,1,37,1,37,1,37,1,37,3,
|
|
37,675,8,37,1,37,1,37,1,37,1,37,1,37,3,37,682,8,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,3,37,694,8,37,1,37,1,37,3,37,698,8,37,1,
|
|
37,3,37,701,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,710,8,37,1,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,724,8,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,751,8,37,
|
|
1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,760,8,37,5,37,762,8,37,10,37,
|
|
12,37,765,9,37,1,38,1,38,1,38,5,38,770,8,38,10,38,12,38,773,9,38,1,39,
|
|
1,39,3,39,777,8,39,1,40,1,40,1,40,1,40,5,40,783,8,40,10,40,12,40,786,
|
|
9,40,1,40,1,40,1,40,1,40,1,40,5,40,793,8,40,10,40,12,40,796,9,40,3,40,
|
|
798,8,40,1,40,1,40,1,40,1,41,1,41,1,41,5,41,806,8,41,10,41,12,41,809,
|
|
9,41,1,41,1,41,1,41,1,41,1,41,1,41,5,41,817,8,41,10,41,12,41,820,9,41,
|
|
1,41,1,41,3,41,824,8,41,1,41,1,41,1,41,1,41,1,41,3,41,831,8,41,1,42,1,
|
|
42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,844,8,42,1,43,1,
|
|
43,1,43,5,43,849,8,43,10,43,12,43,852,9,43,1,44,1,44,1,44,1,44,1,44,1,
|
|
44,1,44,1,44,1,44,1,44,3,44,864,8,44,1,45,1,45,1,45,1,45,3,45,870,8,45,
|
|
1,45,3,45,873,8,45,1,46,1,46,1,46,5,46,878,8,46,10,46,12,46,881,9,46,
|
|
1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,892,8,47,1,47,1,47,
|
|
1,47,1,47,3,47,898,8,47,5,47,900,8,47,10,47,12,47,903,9,47,1,48,1,48,
|
|
1,48,3,48,908,8,48,1,48,1,48,1,49,1,49,1,49,3,49,915,8,49,1,49,1,49,1,
|
|
50,1,50,1,50,5,50,922,8,50,10,50,12,50,925,9,50,1,51,1,51,1,52,1,52,1,
|
|
52,1,52,1,52,1,52,3,52,935,8,52,3,52,937,8,52,1,53,3,53,940,8,53,1,53,
|
|
1,53,1,53,1,53,1,53,1,53,3,53,948,8,53,1,54,1,54,1,54,3,54,953,8,54,1,
|
|
55,1,55,1,56,1,56,1,57,1,57,1,58,1,58,3,58,963,8,58,1,59,1,59,1,59,3,
|
|
59,968,8,59,1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,0,3,36,74,94,
|
|
62,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,0,16,2,0,32,
|
|
32,141,141,2,0,84,84,96,96,3,0,4,4,8,8,12,12,4,0,4,4,7,8,12,12,147,147,
|
|
2,0,96,96,140,140,2,0,4,4,8,8,2,0,11,11,42,43,2,0,62,62,93,93,2,0,133,
|
|
133,143,143,3,0,17,17,95,95,170,170,2,0,79,79,98,98,1,0,197,198,2,0,208,
|
|
208,228,228,8,0,37,37,76,76,108,108,110,110,132,132,145,145,185,185,190,
|
|
190,13,0,2,24,26,36,38,75,77,81,83,107,109,109,111,112,114,115,117,130,
|
|
133,144,146,184,186,189,191,192,4,0,36,36,62,62,77,77,91,91,1105,0,127,
|
|
1,0,0,0,2,131,1,0,0,0,4,145,1,0,0,0,6,148,1,0,0,0,8,197,1,0,0,0,10,200,
|
|
1,0,0,0,12,206,1,0,0,0,14,210,1,0,0,0,16,216,1,0,0,0,18,234,1,0,0,0,20,
|
|
237,1,0,0,0,22,240,1,0,0,0,24,250,1,0,0,0,26,253,1,0,0,0,28,257,1,0,0,
|
|
0,30,290,1,0,0,0,32,292,1,0,0,0,34,295,1,0,0,0,36,310,1,0,0,0,38,372,
|
|
1,0,0,0,40,377,1,0,0,0,42,388,1,0,0,0,44,390,1,0,0,0,46,396,1,0,0,0,48,
|
|
404,1,0,0,0,50,422,1,0,0,0,52,424,1,0,0,0,54,432,1,0,0,0,56,437,1,0,0,
|
|
0,58,445,1,0,0,0,60,449,1,0,0,0,62,453,1,0,0,0,64,462,1,0,0,0,66,476,
|
|
1,0,0,0,68,478,1,0,0,0,70,528,1,0,0,0,72,530,1,0,0,0,74,668,1,0,0,0,76,
|
|
766,1,0,0,0,78,776,1,0,0,0,80,797,1,0,0,0,82,830,1,0,0,0,84,843,1,0,0,
|
|
0,86,845,1,0,0,0,88,863,1,0,0,0,90,872,1,0,0,0,92,874,1,0,0,0,94,891,
|
|
1,0,0,0,96,904,1,0,0,0,98,914,1,0,0,0,100,918,1,0,0,0,102,926,1,0,0,0,
|
|
104,936,1,0,0,0,106,939,1,0,0,0,108,952,1,0,0,0,110,954,1,0,0,0,112,956,
|
|
1,0,0,0,114,958,1,0,0,0,116,962,1,0,0,0,118,967,1,0,0,0,120,969,1,0,0,
|
|
0,122,973,1,0,0,0,124,128,3,2,1,0,125,128,3,6,3,0,126,128,3,82,41,0,127,
|
|
124,1,0,0,0,127,125,1,0,0,0,127,126,1,0,0,0,128,129,1,0,0,0,129,130,5,
|
|
0,0,1,130,1,1,0,0,0,131,137,3,4,2,0,132,133,5,176,0,0,133,134,5,4,0,0,
|
|
134,136,3,4,2,0,135,132,1,0,0,0,136,139,1,0,0,0,137,135,1,0,0,0,137,138,
|
|
1,0,0,0,138,3,1,0,0,0,139,137,1,0,0,0,140,146,3,6,3,0,141,142,5,220,0,
|
|
0,142,143,3,2,1,0,143,144,5,236,0,0,144,146,1,0,0,0,145,140,1,0,0,0,145,
|
|
141,1,0,0,0,146,5,1,0,0,0,147,149,3,8,4,0,148,147,1,0,0,0,148,149,1,0,
|
|
0,0,149,150,1,0,0,0,150,152,5,146,0,0,151,153,5,49,0,0,152,151,1,0,0,
|
|
0,152,153,1,0,0,0,153,155,1,0,0,0,154,156,3,10,5,0,155,154,1,0,0,0,155,
|
|
156,1,0,0,0,156,157,1,0,0,0,157,159,3,72,36,0,158,160,3,12,6,0,159,158,
|
|
1,0,0,0,159,160,1,0,0,0,160,162,1,0,0,0,161,163,3,14,7,0,162,161,1,0,
|
|
0,0,162,163,1,0,0,0,163,165,1,0,0,0,164,166,3,18,9,0,165,164,1,0,0,0,
|
|
165,166,1,0,0,0,166,168,1,0,0,0,167,169,3,20,10,0,168,167,1,0,0,0,168,
|
|
169,1,0,0,0,169,171,1,0,0,0,170,172,3,22,11,0,171,170,1,0,0,0,171,172,
|
|
1,0,0,0,172,175,1,0,0,0,173,174,5,189,0,0,174,176,7,0,0,0,175,173,1,0,
|
|
0,0,175,176,1,0,0,0,176,179,1,0,0,0,177,178,5,189,0,0,178,180,5,169,0,
|
|
0,179,177,1,0,0,0,179,180,1,0,0,0,180,182,1,0,0,0,181,183,3,24,12,0,182,
|
|
181,1,0,0,0,182,183,1,0,0,0,183,185,1,0,0,0,184,186,3,16,8,0,185,184,
|
|
1,0,0,0,185,186,1,0,0,0,186,188,1,0,0,0,187,189,3,26,13,0,188,187,1,0,
|
|
0,0,188,189,1,0,0,0,189,192,1,0,0,0,190,193,3,30,15,0,191,193,3,32,16,
|
|
0,192,190,1,0,0,0,192,191,1,0,0,0,192,193,1,0,0,0,193,195,1,0,0,0,194,
|
|
196,3,34,17,0,195,194,1,0,0,0,195,196,1,0,0,0,196,7,1,0,0,0,197,198,5,
|
|
189,0,0,198,199,3,86,43,0,199,9,1,0,0,0,200,201,5,168,0,0,201,204,5,198,
|
|
0,0,202,203,5,189,0,0,203,205,5,164,0,0,204,202,1,0,0,0,204,205,1,0,0,
|
|
0,205,11,1,0,0,0,206,207,5,68,0,0,207,208,3,36,18,0,208,13,1,0,0,0,209,
|
|
211,7,1,0,0,210,209,1,0,0,0,210,211,1,0,0,0,211,212,1,0,0,0,212,213,5,
|
|
9,0,0,213,214,5,90,0,0,214,215,3,72,36,0,215,15,1,0,0,0,216,217,5,188,
|
|
0,0,217,218,3,118,59,0,218,219,5,10,0,0,219,220,5,220,0,0,220,221,3,56,
|
|
28,0,221,231,5,236,0,0,222,223,5,206,0,0,223,224,3,118,59,0,224,225,5,
|
|
10,0,0,225,226,5,220,0,0,226,227,3,56,28,0,227,228,5,236,0,0,228,230,
|
|
1,0,0,0,229,222,1,0,0,0,230,233,1,0,0,0,231,229,1,0,0,0,231,232,1,0,0,
|
|
0,232,17,1,0,0,0,233,231,1,0,0,0,234,235,5,129,0,0,235,236,3,74,37,0,
|
|
236,19,1,0,0,0,237,238,5,187,0,0,238,239,3,74,37,0,239,21,1,0,0,0,240,
|
|
241,5,73,0,0,241,248,5,18,0,0,242,243,7,0,0,0,243,244,5,220,0,0,244,245,
|
|
3,72,36,0,245,246,5,236,0,0,246,249,1,0,0,0,247,249,3,72,36,0,248,242,
|
|
1,0,0,0,248,247,1,0,0,0,249,23,1,0,0,0,250,251,5,74,0,0,251,252,3,74,
|
|
37,0,252,25,1,0,0,0,253,254,5,122,0,0,254,255,5,18,0,0,255,256,3,46,23,
|
|
0,256,27,1,0,0,0,257,258,5,122,0,0,258,259,5,18,0,0,259,260,3,72,36,0,
|
|
260,29,1,0,0,0,261,262,5,99,0,0,262,265,3,74,37,0,263,264,5,206,0,0,264,
|
|
266,3,74,37,0,265,263,1,0,0,0,265,266,1,0,0,0,266,271,1,0,0,0,267,268,
|
|
5,189,0,0,268,272,5,164,0,0,269,270,5,18,0,0,270,272,3,72,36,0,271,267,
|
|
1,0,0,0,271,269,1,0,0,0,271,272,1,0,0,0,272,291,1,0,0,0,273,274,5,99,
|
|
0,0,274,277,3,74,37,0,275,276,5,189,0,0,276,278,5,164,0,0,277,275,1,0,
|
|
0,0,277,278,1,0,0,0,278,279,1,0,0,0,279,280,5,118,0,0,280,281,3,74,37,
|
|
0,281,291,1,0,0,0,282,283,5,99,0,0,283,284,3,74,37,0,284,285,5,118,0,
|
|
0,285,288,3,74,37,0,286,287,5,18,0,0,287,289,3,72,36,0,288,286,1,0,0,
|
|
0,288,289,1,0,0,0,289,291,1,0,0,0,290,261,1,0,0,0,290,273,1,0,0,0,290,
|
|
282,1,0,0,0,291,31,1,0,0,0,292,293,5,118,0,0,293,294,3,74,37,0,294,33,
|
|
1,0,0,0,295,296,5,150,0,0,296,297,3,52,26,0,297,35,1,0,0,0,298,299,6,
|
|
18,-1,0,299,301,3,94,47,0,300,302,5,61,0,0,301,300,1,0,0,0,301,302,1,
|
|
0,0,0,302,304,1,0,0,0,303,305,3,44,22,0,304,303,1,0,0,0,304,305,1,0,0,
|
|
0,305,311,1,0,0,0,306,307,5,220,0,0,307,308,3,36,18,0,308,309,5,236,0,
|
|
0,309,311,1,0,0,0,310,298,1,0,0,0,310,306,1,0,0,0,311,326,1,0,0,0,312,
|
|
313,10,3,0,0,313,314,3,40,20,0,314,315,3,36,18,4,315,325,1,0,0,0,316,
|
|
318,10,4,0,0,317,319,3,38,19,0,318,317,1,0,0,0,318,319,1,0,0,0,319,320,
|
|
1,0,0,0,320,321,5,90,0,0,321,322,3,36,18,0,322,323,3,42,21,0,323,325,
|
|
1,0,0,0,324,312,1,0,0,0,324,316,1,0,0,0,325,328,1,0,0,0,326,324,1,0,0,
|
|
0,326,327,1,0,0,0,327,37,1,0,0,0,328,326,1,0,0,0,329,331,7,2,0,0,330,
|
|
329,1,0,0,0,330,331,1,0,0,0,331,332,1,0,0,0,332,339,5,84,0,0,333,335,
|
|
5,84,0,0,334,336,7,2,0,0,335,334,1,0,0,0,335,336,1,0,0,0,336,339,1,0,
|
|
0,0,337,339,7,2,0,0,338,330,1,0,0,0,338,333,1,0,0,0,338,337,1,0,0,0,339,
|
|
373,1,0,0,0,340,342,7,3,0,0,341,340,1,0,0,0,341,342,1,0,0,0,342,343,1,
|
|
0,0,0,343,345,7,4,0,0,344,346,5,123,0,0,345,344,1,0,0,0,345,346,1,0,0,
|
|
0,346,355,1,0,0,0,347,349,7,4,0,0,348,350,5,123,0,0,349,348,1,0,0,0,349,
|
|
350,1,0,0,0,350,352,1,0,0,0,351,353,7,3,0,0,352,351,1,0,0,0,352,353,1,
|
|
0,0,0,353,355,1,0,0,0,354,341,1,0,0,0,354,347,1,0,0,0,355,373,1,0,0,0,
|
|
356,358,7,5,0,0,357,356,1,0,0,0,357,358,1,0,0,0,358,359,1,0,0,0,359,361,
|
|
5,69,0,0,360,362,5,123,0,0,361,360,1,0,0,0,361,362,1,0,0,0,362,371,1,
|
|
0,0,0,363,365,5,69,0,0,364,366,5,123,0,0,365,364,1,0,0,0,365,366,1,0,
|
|
0,0,366,368,1,0,0,0,367,369,7,5,0,0,368,367,1,0,0,0,368,369,1,0,0,0,369,
|
|
371,1,0,0,0,370,357,1,0,0,0,370,363,1,0,0,0,371,373,1,0,0,0,372,338,1,
|
|
0,0,0,372,354,1,0,0,0,372,370,1,0,0,0,373,39,1,0,0,0,374,375,5,31,0,0,
|
|
375,378,5,90,0,0,376,378,5,206,0,0,377,374,1,0,0,0,377,376,1,0,0,0,378,
|
|
41,1,0,0,0,379,380,5,119,0,0,380,389,3,72,36,0,381,382,5,179,0,0,382,
|
|
383,5,220,0,0,383,384,3,72,36,0,384,385,5,236,0,0,385,389,1,0,0,0,386,
|
|
387,5,179,0,0,387,389,3,72,36,0,388,379,1,0,0,0,388,381,1,0,0,0,388,386,
|
|
1,0,0,0,389,43,1,0,0,0,390,391,5,144,0,0,391,394,3,50,25,0,392,393,5,
|
|
118,0,0,393,395,3,50,25,0,394,392,1,0,0,0,394,395,1,0,0,0,395,45,1,0,
|
|
0,0,396,401,3,48,24,0,397,398,5,206,0,0,398,400,3,48,24,0,399,397,1,0,
|
|
0,0,400,403,1,0,0,0,401,399,1,0,0,0,401,402,1,0,0,0,402,47,1,0,0,0,403,
|
|
401,1,0,0,0,404,406,3,74,37,0,405,407,7,6,0,0,406,405,1,0,0,0,406,407,
|
|
1,0,0,0,407,410,1,0,0,0,408,409,5,117,0,0,409,411,7,7,0,0,410,408,1,0,
|
|
0,0,410,411,1,0,0,0,411,414,1,0,0,0,412,413,5,26,0,0,413,415,5,200,0,
|
|
0,414,412,1,0,0,0,414,415,1,0,0,0,415,49,1,0,0,0,416,423,3,122,61,0,417,
|
|
420,3,106,53,0,418,419,5,238,0,0,419,421,3,106,53,0,420,418,1,0,0,0,420,
|
|
421,1,0,0,0,421,423,1,0,0,0,422,416,1,0,0,0,422,417,1,0,0,0,423,51,1,
|
|
0,0,0,424,429,3,54,27,0,425,426,5,206,0,0,426,428,3,54,27,0,427,425,1,
|
|
0,0,0,428,431,1,0,0,0,429,427,1,0,0,0,429,430,1,0,0,0,430,53,1,0,0,0,
|
|
431,429,1,0,0,0,432,433,3,118,59,0,433,434,5,212,0,0,434,435,3,108,54,
|
|
0,435,55,1,0,0,0,436,438,3,58,29,0,437,436,1,0,0,0,437,438,1,0,0,0,438,
|
|
440,1,0,0,0,439,441,3,60,30,0,440,439,1,0,0,0,440,441,1,0,0,0,441,443,
|
|
1,0,0,0,442,444,3,62,31,0,443,442,1,0,0,0,443,444,1,0,0,0,444,57,1,0,
|
|
0,0,445,446,5,126,0,0,446,447,5,18,0,0,447,448,3,72,36,0,448,59,1,0,0,
|
|
0,449,450,5,122,0,0,450,451,5,18,0,0,451,452,3,46,23,0,452,61,1,0,0,0,
|
|
453,454,7,8,0,0,454,455,3,64,32,0,455,63,1,0,0,0,456,463,3,66,33,0,457,
|
|
458,5,16,0,0,458,459,3,66,33,0,459,460,5,6,0,0,460,461,3,66,33,0,461,
|
|
463,1,0,0,0,462,456,1,0,0,0,462,457,1,0,0,0,463,65,1,0,0,0,464,465,5,
|
|
33,0,0,465,477,5,142,0,0,466,467,5,175,0,0,467,477,5,128,0,0,468,469,
|
|
5,175,0,0,469,477,5,64,0,0,470,471,3,106,53,0,471,472,5,128,0,0,472,477,
|
|
1,0,0,0,473,474,3,106,53,0,474,475,5,64,0,0,475,477,1,0,0,0,476,464,1,
|
|
0,0,0,476,466,1,0,0,0,476,468,1,0,0,0,476,470,1,0,0,0,476,473,1,0,0,0,
|
|
477,67,1,0,0,0,478,479,3,74,37,0,479,480,5,0,0,1,480,69,1,0,0,0,481,529,
|
|
3,118,59,0,482,483,3,118,59,0,483,484,5,220,0,0,484,485,3,118,59,0,485,
|
|
492,3,70,35,0,486,487,5,206,0,0,487,488,3,118,59,0,488,489,3,70,35,0,
|
|
489,491,1,0,0,0,490,486,1,0,0,0,491,494,1,0,0,0,492,490,1,0,0,0,492,493,
|
|
1,0,0,0,493,495,1,0,0,0,494,492,1,0,0,0,495,496,5,236,0,0,496,529,1,0,
|
|
0,0,497,498,3,118,59,0,498,499,5,220,0,0,499,504,3,120,60,0,500,501,5,
|
|
206,0,0,501,503,3,120,60,0,502,500,1,0,0,0,503,506,1,0,0,0,504,502,1,
|
|
0,0,0,504,505,1,0,0,0,505,507,1,0,0,0,506,504,1,0,0,0,507,508,5,236,0,
|
|
0,508,529,1,0,0,0,509,510,3,118,59,0,510,511,5,220,0,0,511,516,3,70,35,
|
|
0,512,513,5,206,0,0,513,515,3,70,35,0,514,512,1,0,0,0,515,518,1,0,0,0,
|
|
516,514,1,0,0,0,516,517,1,0,0,0,517,519,1,0,0,0,518,516,1,0,0,0,519,520,
|
|
5,236,0,0,520,529,1,0,0,0,521,522,3,118,59,0,522,524,5,220,0,0,523,525,
|
|
3,72,36,0,524,523,1,0,0,0,524,525,1,0,0,0,525,526,1,0,0,0,526,527,5,236,
|
|
0,0,527,529,1,0,0,0,528,481,1,0,0,0,528,482,1,0,0,0,528,497,1,0,0,0,528,
|
|
509,1,0,0,0,528,521,1,0,0,0,529,71,1,0,0,0,530,535,3,74,37,0,531,532,
|
|
5,206,0,0,532,534,3,74,37,0,533,531,1,0,0,0,534,537,1,0,0,0,535,533,1,
|
|
0,0,0,535,536,1,0,0,0,536,73,1,0,0,0,537,535,1,0,0,0,538,539,6,37,-1,
|
|
0,539,541,5,19,0,0,540,542,3,74,37,0,541,540,1,0,0,0,541,542,1,0,0,0,
|
|
542,548,1,0,0,0,543,544,5,186,0,0,544,545,3,74,37,0,545,546,5,163,0,0,
|
|
546,547,3,74,37,0,547,549,1,0,0,0,548,543,1,0,0,0,549,550,1,0,0,0,550,
|
|
548,1,0,0,0,550,551,1,0,0,0,551,554,1,0,0,0,552,553,5,52,0,0,553,555,
|
|
3,74,37,0,554,552,1,0,0,0,554,555,1,0,0,0,555,556,1,0,0,0,556,557,5,53,
|
|
0,0,557,669,1,0,0,0,558,559,5,20,0,0,559,560,5,220,0,0,560,561,3,74,37,
|
|
0,561,562,5,10,0,0,562,563,3,70,35,0,563,564,5,236,0,0,564,669,1,0,0,
|
|
0,565,566,5,36,0,0,566,669,5,200,0,0,567,568,5,59,0,0,568,569,5,220,0,
|
|
0,569,570,3,110,55,0,570,571,5,68,0,0,571,572,3,74,37,0,572,573,5,236,
|
|
0,0,573,669,1,0,0,0,574,575,5,86,0,0,575,576,3,74,37,0,576,577,3,110,
|
|
55,0,577,669,1,0,0,0,578,579,5,155,0,0,579,580,5,220,0,0,580,581,3,74,
|
|
37,0,581,582,5,68,0,0,582,585,3,74,37,0,583,584,5,65,0,0,584,586,3,74,
|
|
37,0,585,583,1,0,0,0,585,586,1,0,0,0,586,587,1,0,0,0,587,588,5,236,0,
|
|
0,588,669,1,0,0,0,589,590,5,166,0,0,590,669,5,200,0,0,591,592,5,171,0,
|
|
0,592,593,5,220,0,0,593,594,7,9,0,0,594,595,5,200,0,0,595,596,5,68,0,
|
|
0,596,597,3,74,37,0,597,598,5,236,0,0,598,669,1,0,0,0,599,600,3,118,59,
|
|
0,600,602,5,220,0,0,601,603,3,72,36,0,602,601,1,0,0,0,602,603,1,0,0,0,
|
|
603,604,1,0,0,0,604,605,5,236,0,0,605,606,1,0,0,0,606,607,5,125,0,0,607,
|
|
608,5,220,0,0,608,609,3,56,28,0,609,610,5,236,0,0,610,669,1,0,0,0,611,
|
|
612,3,118,59,0,612,614,5,220,0,0,613,615,3,72,36,0,614,613,1,0,0,0,614,
|
|
615,1,0,0,0,615,616,1,0,0,0,616,617,5,236,0,0,617,618,1,0,0,0,618,619,
|
|
5,125,0,0,619,620,3,118,59,0,620,669,1,0,0,0,621,627,3,118,59,0,622,624,
|
|
5,220,0,0,623,625,3,72,36,0,624,623,1,0,0,0,624,625,1,0,0,0,625,626,1,
|
|
0,0,0,626,628,5,236,0,0,627,622,1,0,0,0,627,628,1,0,0,0,628,629,1,0,0,
|
|
0,629,631,5,220,0,0,630,632,5,49,0,0,631,630,1,0,0,0,631,632,1,0,0,0,
|
|
632,634,1,0,0,0,633,635,3,76,38,0,634,633,1,0,0,0,634,635,1,0,0,0,635,
|
|
636,1,0,0,0,636,637,5,236,0,0,637,669,1,0,0,0,638,669,3,82,41,0,639,669,
|
|
3,108,54,0,640,641,5,208,0,0,641,669,3,74,37,18,642,643,5,115,0,0,643,
|
|
669,3,74,37,12,644,645,3,98,49,0,645,646,5,210,0,0,646,648,1,0,0,0,647,
|
|
644,1,0,0,0,647,648,1,0,0,0,648,649,1,0,0,0,649,669,5,202,0,0,650,651,
|
|
5,220,0,0,651,652,3,2,1,0,652,653,5,236,0,0,653,669,1,0,0,0,654,655,5,
|
|
220,0,0,655,656,3,74,37,0,656,657,5,236,0,0,657,669,1,0,0,0,658,659,5,
|
|
220,0,0,659,660,3,72,36,0,660,661,5,236,0,0,661,669,1,0,0,0,662,664,5,
|
|
219,0,0,663,665,3,72,36,0,664,663,1,0,0,0,664,665,1,0,0,0,665,666,1,0,
|
|
0,0,666,669,5,235,0,0,667,669,3,90,45,0,668,538,1,0,0,0,668,558,1,0,0,
|
|
0,668,565,1,0,0,0,668,567,1,0,0,0,668,574,1,0,0,0,668,578,1,0,0,0,668,
|
|
589,1,0,0,0,668,591,1,0,0,0,668,599,1,0,0,0,668,611,1,0,0,0,668,621,1,
|
|
0,0,0,668,638,1,0,0,0,668,639,1,0,0,0,668,640,1,0,0,0,668,642,1,0,0,0,
|
|
668,647,1,0,0,0,668,650,1,0,0,0,668,654,1,0,0,0,668,658,1,0,0,0,668,662,
|
|
1,0,0,0,668,667,1,0,0,0,669,763,1,0,0,0,670,674,10,17,0,0,671,675,5,202,
|
|
0,0,672,675,5,238,0,0,673,675,5,227,0,0,674,671,1,0,0,0,674,672,1,0,0,
|
|
0,674,673,1,0,0,0,675,676,1,0,0,0,676,762,3,74,37,18,677,681,10,16,0,
|
|
0,678,682,5,228,0,0,679,682,5,208,0,0,680,682,5,207,0,0,681,678,1,0,0,
|
|
0,681,679,1,0,0,0,681,680,1,0,0,0,682,683,1,0,0,0,683,762,3,74,37,17,
|
|
684,709,10,15,0,0,685,710,5,211,0,0,686,710,5,212,0,0,687,710,5,223,0,
|
|
0,688,710,5,221,0,0,689,710,5,222,0,0,690,710,5,213,0,0,691,710,5,214,
|
|
0,0,692,694,5,115,0,0,693,692,1,0,0,0,693,694,1,0,0,0,694,695,1,0,0,0,
|
|
695,697,5,80,0,0,696,698,5,25,0,0,697,696,1,0,0,0,697,698,1,0,0,0,698,
|
|
710,1,0,0,0,699,701,5,115,0,0,700,699,1,0,0,0,700,701,1,0,0,0,701,702,
|
|
1,0,0,0,702,710,7,10,0,0,703,710,5,232,0,0,704,710,5,233,0,0,705,710,
|
|
5,225,0,0,706,710,5,216,0,0,707,710,5,217,0,0,708,710,5,224,0,0,709,685,
|
|
1,0,0,0,709,686,1,0,0,0,709,687,1,0,0,0,709,688,1,0,0,0,709,689,1,0,0,
|
|
0,709,690,1,0,0,0,709,691,1,0,0,0,709,693,1,0,0,0,709,700,1,0,0,0,709,
|
|
703,1,0,0,0,709,704,1,0,0,0,709,705,1,0,0,0,709,706,1,0,0,0,709,707,1,
|
|
0,0,0,709,708,1,0,0,0,710,711,1,0,0,0,711,762,3,74,37,16,712,713,10,13,
|
|
0,0,713,714,5,226,0,0,714,762,3,74,37,14,715,716,10,11,0,0,716,717,5,
|
|
6,0,0,717,762,3,74,37,12,718,719,10,10,0,0,719,720,5,121,0,0,720,762,
|
|
3,74,37,11,721,723,10,9,0,0,722,724,5,115,0,0,723,722,1,0,0,0,723,724,
|
|
1,0,0,0,724,725,1,0,0,0,725,726,5,16,0,0,726,727,3,74,37,0,727,728,5,
|
|
6,0,0,728,729,3,74,37,10,729,762,1,0,0,0,730,731,10,8,0,0,731,732,5,229,
|
|
0,0,732,733,3,74,37,0,733,734,5,205,0,0,734,735,3,74,37,8,735,762,1,0,
|
|
0,0,736,737,10,21,0,0,737,738,5,219,0,0,738,739,3,74,37,0,739,740,5,235,
|
|
0,0,740,762,1,0,0,0,741,742,10,20,0,0,742,743,5,210,0,0,743,762,5,198,
|
|
0,0,744,745,10,19,0,0,745,746,5,210,0,0,746,762,3,118,59,0,747,748,10,
|
|
14,0,0,748,750,5,88,0,0,749,751,5,115,0,0,750,749,1,0,0,0,750,751,1,0,
|
|
0,0,751,752,1,0,0,0,752,762,5,116,0,0,753,759,10,7,0,0,754,760,3,116,
|
|
58,0,755,756,5,10,0,0,756,760,3,118,59,0,757,758,5,10,0,0,758,760,5,200,
|
|
0,0,759,754,1,0,0,0,759,755,1,0,0,0,759,757,1,0,0,0,760,762,1,0,0,0,761,
|
|
670,1,0,0,0,761,677,1,0,0,0,761,684,1,0,0,0,761,712,1,0,0,0,761,715,1,
|
|
0,0,0,761,718,1,0,0,0,761,721,1,0,0,0,761,730,1,0,0,0,761,736,1,0,0,0,
|
|
761,741,1,0,0,0,761,744,1,0,0,0,761,747,1,0,0,0,761,753,1,0,0,0,762,765,
|
|
1,0,0,0,763,761,1,0,0,0,763,764,1,0,0,0,764,75,1,0,0,0,765,763,1,0,0,
|
|
0,766,771,3,78,39,0,767,768,5,206,0,0,768,770,3,78,39,0,769,767,1,0,0,
|
|
0,770,773,1,0,0,0,771,769,1,0,0,0,771,772,1,0,0,0,772,77,1,0,0,0,773,
|
|
771,1,0,0,0,774,777,3,80,40,0,775,777,3,74,37,0,776,774,1,0,0,0,776,775,
|
|
1,0,0,0,777,79,1,0,0,0,778,779,5,220,0,0,779,784,3,118,59,0,780,781,5,
|
|
206,0,0,781,783,3,118,59,0,782,780,1,0,0,0,783,786,1,0,0,0,784,782,1,
|
|
0,0,0,784,785,1,0,0,0,785,787,1,0,0,0,786,784,1,0,0,0,787,788,5,236,0,
|
|
0,788,798,1,0,0,0,789,794,3,118,59,0,790,791,5,206,0,0,791,793,3,118,
|
|
59,0,792,790,1,0,0,0,793,796,1,0,0,0,794,792,1,0,0,0,794,795,1,0,0,0,
|
|
795,798,1,0,0,0,796,794,1,0,0,0,797,778,1,0,0,0,797,789,1,0,0,0,798,799,
|
|
1,0,0,0,799,800,5,201,0,0,800,801,3,74,37,0,801,81,1,0,0,0,802,803,5,
|
|
222,0,0,803,807,3,118,59,0,804,806,3,84,42,0,805,804,1,0,0,0,806,809,
|
|
1,0,0,0,807,805,1,0,0,0,807,808,1,0,0,0,808,810,1,0,0,0,809,807,1,0,0,
|
|
0,810,811,5,238,0,0,811,812,5,214,0,0,812,831,1,0,0,0,813,814,5,222,0,
|
|
0,814,818,3,118,59,0,815,817,3,84,42,0,816,815,1,0,0,0,817,820,1,0,0,
|
|
0,818,816,1,0,0,0,818,819,1,0,0,0,819,821,1,0,0,0,820,818,1,0,0,0,821,
|
|
823,5,214,0,0,822,824,3,82,41,0,823,822,1,0,0,0,823,824,1,0,0,0,824,825,
|
|
1,0,0,0,825,826,5,222,0,0,826,827,5,238,0,0,827,828,3,118,59,0,828,829,
|
|
5,214,0,0,829,831,1,0,0,0,830,802,1,0,0,0,830,813,1,0,0,0,831,83,1,0,
|
|
0,0,832,833,3,118,59,0,833,834,5,212,0,0,834,835,5,200,0,0,835,844,1,
|
|
0,0,0,836,837,3,118,59,0,837,838,5,212,0,0,838,839,5,218,0,0,839,840,
|
|
3,74,37,0,840,841,5,234,0,0,841,844,1,0,0,0,842,844,3,118,59,0,843,832,
|
|
1,0,0,0,843,836,1,0,0,0,843,842,1,0,0,0,844,85,1,0,0,0,845,850,3,88,44,
|
|
0,846,847,5,206,0,0,847,849,3,88,44,0,848,846,1,0,0,0,849,852,1,0,0,0,
|
|
850,848,1,0,0,0,850,851,1,0,0,0,851,87,1,0,0,0,852,850,1,0,0,0,853,854,
|
|
3,118,59,0,854,855,5,10,0,0,855,856,5,220,0,0,856,857,3,2,1,0,857,858,
|
|
5,236,0,0,858,864,1,0,0,0,859,860,3,74,37,0,860,861,5,10,0,0,861,862,
|
|
3,118,59,0,862,864,1,0,0,0,863,853,1,0,0,0,863,859,1,0,0,0,864,89,1,0,
|
|
0,0,865,873,3,122,61,0,866,867,3,98,49,0,867,868,5,210,0,0,868,870,1,
|
|
0,0,0,869,866,1,0,0,0,869,870,1,0,0,0,870,871,1,0,0,0,871,873,3,92,46,
|
|
0,872,865,1,0,0,0,872,869,1,0,0,0,873,91,1,0,0,0,874,879,3,118,59,0,875,
|
|
876,5,210,0,0,876,878,3,118,59,0,877,875,1,0,0,0,878,881,1,0,0,0,879,
|
|
877,1,0,0,0,879,880,1,0,0,0,880,93,1,0,0,0,881,879,1,0,0,0,882,883,6,
|
|
47,-1,0,883,892,3,98,49,0,884,892,3,96,48,0,885,886,5,220,0,0,886,887,
|
|
3,2,1,0,887,888,5,236,0,0,888,892,1,0,0,0,889,892,3,82,41,0,890,892,3,
|
|
122,61,0,891,882,1,0,0,0,891,884,1,0,0,0,891,885,1,0,0,0,891,889,1,0,
|
|
0,0,891,890,1,0,0,0,892,901,1,0,0,0,893,897,10,3,0,0,894,898,3,116,58,
|
|
0,895,896,5,10,0,0,896,898,3,118,59,0,897,894,1,0,0,0,897,895,1,0,0,0,
|
|
898,900,1,0,0,0,899,893,1,0,0,0,900,903,1,0,0,0,901,899,1,0,0,0,901,902,
|
|
1,0,0,0,902,95,1,0,0,0,903,901,1,0,0,0,904,905,3,118,59,0,905,907,5,220,
|
|
0,0,906,908,3,100,50,0,907,906,1,0,0,0,907,908,1,0,0,0,908,909,1,0,0,
|
|
0,909,910,5,236,0,0,910,97,1,0,0,0,911,912,3,102,51,0,912,913,5,210,0,
|
|
0,913,915,1,0,0,0,914,911,1,0,0,0,914,915,1,0,0,0,915,916,1,0,0,0,916,
|
|
917,3,118,59,0,917,99,1,0,0,0,918,923,3,74,37,0,919,920,5,206,0,0,920,
|
|
922,3,74,37,0,921,919,1,0,0,0,922,925,1,0,0,0,923,921,1,0,0,0,923,924,
|
|
1,0,0,0,924,101,1,0,0,0,925,923,1,0,0,0,926,927,3,118,59,0,927,103,1,
|
|
0,0,0,928,937,5,196,0,0,929,930,5,210,0,0,930,937,7,11,0,0,931,932,5,
|
|
198,0,0,932,934,5,210,0,0,933,935,7,11,0,0,934,933,1,0,0,0,934,935,1,
|
|
0,0,0,935,937,1,0,0,0,936,928,1,0,0,0,936,929,1,0,0,0,936,931,1,0,0,0,
|
|
937,105,1,0,0,0,938,940,7,12,0,0,939,938,1,0,0,0,939,940,1,0,0,0,940,
|
|
947,1,0,0,0,941,948,3,104,52,0,942,948,5,197,0,0,943,948,5,198,0,0,944,
|
|
948,5,199,0,0,945,948,5,82,0,0,946,948,5,113,0,0,947,941,1,0,0,0,947,
|
|
942,1,0,0,0,947,943,1,0,0,0,947,944,1,0,0,0,947,945,1,0,0,0,947,946,1,
|
|
0,0,0,948,107,1,0,0,0,949,953,3,106,53,0,950,953,5,200,0,0,951,953,5,
|
|
116,0,0,952,949,1,0,0,0,952,950,1,0,0,0,952,951,1,0,0,0,953,109,1,0,0,
|
|
0,954,955,7,13,0,0,955,111,1,0,0,0,956,957,7,14,0,0,957,113,1,0,0,0,958,
|
|
959,7,15,0,0,959,115,1,0,0,0,960,963,5,195,0,0,961,963,3,114,57,0,962,
|
|
960,1,0,0,0,962,961,1,0,0,0,963,117,1,0,0,0,964,968,5,195,0,0,965,968,
|
|
3,110,55,0,966,968,3,112,56,0,967,964,1,0,0,0,967,965,1,0,0,0,967,966,
|
|
1,0,0,0,968,119,1,0,0,0,969,970,5,200,0,0,970,971,5,212,0,0,971,972,3,
|
|
106,53,0,972,121,1,0,0,0,973,974,5,218,0,0,974,975,3,118,59,0,975,976,
|
|
5,234,0,0,976,123,1,0,0,0,120,127,137,145,148,152,155,159,162,165,168,
|
|
171,175,179,182,185,188,192,195,204,210,231,248,265,271,277,288,290,301,
|
|
304,310,318,324,326,330,335,338,341,345,349,352,354,357,361,365,368,370,
|
|
372,377,388,394,401,406,410,414,420,422,429,437,440,443,462,476,492,504,
|
|
516,524,528,535,541,550,554,585,602,614,624,627,631,634,647,664,668,674,
|
|
681,693,697,700,709,723,750,759,761,763,771,776,784,794,797,807,818,823,
|
|
830,843,850,863,869,872,879,891,897,901,907,914,923,934,936,939,947,952,
|
|
962,967
|
|
};
|
|
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);
|
|
}
|
|
hogqlparserParserStaticData = staticData.release();
|
|
}
|
|
|
|
}
|
|
|
|
HogQLParser::HogQLParser(TokenStream *input) : HogQLParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
|
|
|
|
HogQLParser::HogQLParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
|
|
HogQLParser::initialize();
|
|
_interpreter = new atn::ParserATNSimulator(this, *hogqlparserParserStaticData->atn, hogqlparserParserStaticData->decisionToDFA, hogqlparserParserStaticData->sharedContextCache, options);
|
|
}
|
|
|
|
HogQLParser::~HogQLParser() {
|
|
delete _interpreter;
|
|
}
|
|
|
|
const atn::ATN& HogQLParser::getATN() const {
|
|
return *hogqlparserParserStaticData->atn;
|
|
}
|
|
|
|
std::string HogQLParser::getGrammarFileName() const {
|
|
return "HogQLParser.g4";
|
|
}
|
|
|
|
const std::vector<std::string>& HogQLParser::getRuleNames() const {
|
|
return hogqlparserParserStaticData->ruleNames;
|
|
}
|
|
|
|
const dfa::Vocabulary& HogQLParser::getVocabulary() const {
|
|
return hogqlparserParserStaticData->vocabulary;
|
|
}
|
|
|
|
antlr4::atn::SerializedATNView HogQLParser::getSerializedATN() const {
|
|
return hogqlparserParserStaticData->serializedATN;
|
|
}
|
|
|
|
|
|
//----------------- SelectContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectContext::SelectContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectContext::EOF() {
|
|
return getToken(HogQLParser::EOF, 0);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::SelectContext::selectUnionStmt() {
|
|
return getRuleContext<HogQLParser::SelectUnionStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::SelectStmtContext* HogQLParser::SelectContext::selectStmt() {
|
|
return getRuleContext<HogQLParser::SelectStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::HogqlxTagElementContext* HogQLParser::SelectContext::hogqlxTagElement() {
|
|
return getRuleContext<HogQLParser::HogqlxTagElementContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SelectContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSelect;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SelectContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSelect(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SelectContext* HogQLParser::select() {
|
|
SelectContext *_localctx = _tracker.createInstance<SelectContext>(_ctx, getState());
|
|
enterRule(_localctx, 0, HogQLParser::RuleSelect);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(127);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 0, _ctx)) {
|
|
case 1: {
|
|
setState(124);
|
|
selectUnionStmt();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(125);
|
|
selectStmt();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(126);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(129);
|
|
match(HogQLParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SelectUnionStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectUnionStmtContext::SelectUnionStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::SelectStmtWithParensContext *> HogQLParser::SelectUnionStmtContext::selectStmtWithParens() {
|
|
return getRuleContexts<HogQLParser::SelectStmtWithParensContext>();
|
|
}
|
|
|
|
HogQLParser::SelectStmtWithParensContext* HogQLParser::SelectUnionStmtContext::selectStmtWithParens(size_t i) {
|
|
return getRuleContext<HogQLParser::SelectStmtWithParensContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::SelectUnionStmtContext::UNION() {
|
|
return getTokens(HogQLParser::UNION);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectUnionStmtContext::UNION(size_t i) {
|
|
return getToken(HogQLParser::UNION, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::SelectUnionStmtContext::ALL() {
|
|
return getTokens(HogQLParser::ALL);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectUnionStmtContext::ALL(size_t i) {
|
|
return getToken(HogQLParser::ALL, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SelectUnionStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSelectUnionStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SelectUnionStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSelectUnionStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::selectUnionStmt() {
|
|
SelectUnionStmtContext *_localctx = _tracker.createInstance<SelectUnionStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 2, HogQLParser::RuleSelectUnionStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(131);
|
|
selectStmtWithParens();
|
|
setState(137);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::UNION) {
|
|
setState(132);
|
|
match(HogQLParser::UNION);
|
|
setState(133);
|
|
match(HogQLParser::ALL);
|
|
setState(134);
|
|
selectStmtWithParens();
|
|
setState(139);
|
|
_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;
|
|
}
|
|
|
|
//----------------- SelectStmtWithParensContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectStmtWithParensContext::SelectStmtWithParensContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::SelectStmtContext* HogQLParser::SelectStmtWithParensContext::selectStmt() {
|
|
return getRuleContext<HogQLParser::SelectStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtWithParensContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::SelectStmtWithParensContext::selectUnionStmt() {
|
|
return getRuleContext<HogQLParser::SelectUnionStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtWithParensContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SelectStmtWithParensContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSelectStmtWithParens;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SelectStmtWithParensContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSelectStmtWithParens(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SelectStmtWithParensContext* HogQLParser::selectStmtWithParens() {
|
|
SelectStmtWithParensContext *_localctx = _tracker.createInstance<SelectStmtWithParensContext>(_ctx, getState());
|
|
enterRule(_localctx, 4, HogQLParser::RuleSelectStmtWithParens);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(145);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::WITH: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(140);
|
|
selectStmt();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::LPAREN: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(141);
|
|
match(HogQLParser::LPAREN);
|
|
setState(142);
|
|
selectUnionStmt();
|
|
setState(143);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SelectStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectStmtContext::SelectStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::SELECT() {
|
|
return getToken(HogQLParser::SELECT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::SelectStmtContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 0);
|
|
}
|
|
|
|
HogQLParser::TopClauseContext* HogQLParser::SelectStmtContext::topClause() {
|
|
return getRuleContext<HogQLParser::TopClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::ArrayJoinClauseContext* HogQLParser::SelectStmtContext::arrayJoinClause() {
|
|
return getRuleContext<HogQLParser::ArrayJoinClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::PrewhereClauseContext* HogQLParser::SelectStmtContext::prewhereClause() {
|
|
return getRuleContext<HogQLParser::PrewhereClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::GroupByClauseContext* HogQLParser::SelectStmtContext::groupByClause() {
|
|
return getRuleContext<HogQLParser::GroupByClauseContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::SelectStmtContext::WITH() {
|
|
return getTokens(HogQLParser::WITH);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::WITH(size_t i) {
|
|
return getToken(HogQLParser::WITH, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::TOTALS() {
|
|
return getToken(HogQLParser::TOTALS, 0);
|
|
}
|
|
|
|
HogQLParser::HavingClauseContext* HogQLParser::SelectStmtContext::havingClause() {
|
|
return getRuleContext<HogQLParser::HavingClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::WindowClauseContext* HogQLParser::SelectStmtContext::windowClause() {
|
|
return getRuleContext<HogQLParser::WindowClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::OrderByClauseContext* HogQLParser::SelectStmtContext::orderByClause() {
|
|
return getRuleContext<HogQLParser::OrderByClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::LimitAndOffsetClauseContext* HogQLParser::SelectStmtContext::limitAndOffsetClause() {
|
|
return getRuleContext<HogQLParser::LimitAndOffsetClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::OffsetOnlyClauseContext* HogQLParser::SelectStmtContext::offsetOnlyClause() {
|
|
return getRuleContext<HogQLParser::OffsetOnlyClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::SettingsClauseContext* HogQLParser::SelectStmtContext::settingsClause() {
|
|
return getRuleContext<HogQLParser::SettingsClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::WithClauseContext* HogQLParser::SelectStmtContext::withClause() {
|
|
return getRuleContext<HogQLParser::WithClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::FromClauseContext* HogQLParser::SelectStmtContext::fromClause() {
|
|
return getRuleContext<HogQLParser::FromClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::WhereClauseContext* HogQLParser::SelectStmtContext::whereClause() {
|
|
return getRuleContext<HogQLParser::WhereClauseContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::CUBE() {
|
|
return getToken(HogQLParser::CUBE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtContext::ROLLUP() {
|
|
return getToken(HogQLParser::ROLLUP, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SelectStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSelectStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SelectStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSelectStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SelectStmtContext* HogQLParser::selectStmt() {
|
|
SelectStmtContext *_localctx = _tracker.createInstance<SelectStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 6, HogQLParser::RuleSelectStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(148);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(147);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->with = withClause();
|
|
}
|
|
setState(150);
|
|
match(HogQLParser::SELECT);
|
|
setState(152);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx)) {
|
|
case 1: {
|
|
setState(151);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(155);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
|
|
case 1: {
|
|
setState(154);
|
|
topClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(157);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->columns = columnExprList();
|
|
setState(159);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::FROM) {
|
|
setState(158);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->from = fromClause();
|
|
}
|
|
setState(162);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ARRAY || _la == HogQLParser::INNER
|
|
|
|
|| _la == HogQLParser::LEFT) {
|
|
setState(161);
|
|
arrayJoinClause();
|
|
}
|
|
setState(165);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::PREWHERE) {
|
|
setState(164);
|
|
prewhereClause();
|
|
}
|
|
setState(168);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WHERE) {
|
|
setState(167);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->where = whereClause();
|
|
}
|
|
setState(171);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::GROUP) {
|
|
setState(170);
|
|
groupByClause();
|
|
}
|
|
setState(175);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
|
|
case 1: {
|
|
setState(173);
|
|
match(HogQLParser::WITH);
|
|
setState(174);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::CUBE || _la == HogQLParser::ROLLUP)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(179);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(177);
|
|
match(HogQLParser::WITH);
|
|
setState(178);
|
|
match(HogQLParser::TOTALS);
|
|
}
|
|
setState(182);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::HAVING) {
|
|
setState(181);
|
|
havingClause();
|
|
}
|
|
setState(185);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WINDOW) {
|
|
setState(184);
|
|
windowClause();
|
|
}
|
|
setState(188);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ORDER) {
|
|
setState(187);
|
|
orderByClause();
|
|
}
|
|
setState(192);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LIMIT: {
|
|
setState(190);
|
|
limitAndOffsetClause();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::OFFSET: {
|
|
setState(191);
|
|
offsetOnlyClause();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::EOF:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::RPAREN: {
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(195);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::SETTINGS) {
|
|
setState(194);
|
|
settingsClause();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WithClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WithClauseContext::WithClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithClauseContext::WITH() {
|
|
return getToken(HogQLParser::WITH, 0);
|
|
}
|
|
|
|
HogQLParser::WithExprListContext* HogQLParser::WithClauseContext::withExprList() {
|
|
return getRuleContext<HogQLParser::WithExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WithClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWithClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WithClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWithClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WithClauseContext* HogQLParser::withClause() {
|
|
WithClauseContext *_localctx = _tracker.createInstance<WithClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 8, HogQLParser::RuleWithClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(197);
|
|
match(HogQLParser::WITH);
|
|
setState(198);
|
|
withExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TopClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TopClauseContext::TopClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TopClauseContext::TOP() {
|
|
return getToken(HogQLParser::TOP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TopClauseContext::DECIMAL_LITERAL() {
|
|
return getToken(HogQLParser::DECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TopClauseContext::WITH() {
|
|
return getToken(HogQLParser::WITH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TopClauseContext::TIES() {
|
|
return getToken(HogQLParser::TIES, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TopClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTopClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TopClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTopClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TopClauseContext* HogQLParser::topClause() {
|
|
TopClauseContext *_localctx = _tracker.createInstance<TopClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 10, HogQLParser::RuleTopClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(200);
|
|
match(HogQLParser::TOP);
|
|
setState(201);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
setState(204);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
|
|
case 1: {
|
|
setState(202);
|
|
match(HogQLParser::WITH);
|
|
setState(203);
|
|
match(HogQLParser::TIES);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FromClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::FromClauseContext::FromClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FromClauseContext::FROM() {
|
|
return getToken(HogQLParser::FROM, 0);
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::FromClauseContext::joinExpr() {
|
|
return getRuleContext<HogQLParser::JoinExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::FromClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleFromClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::FromClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFromClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::FromClauseContext* HogQLParser::fromClause() {
|
|
FromClauseContext *_localctx = _tracker.createInstance<FromClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 12, HogQLParser::RuleFromClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(206);
|
|
match(HogQLParser::FROM);
|
|
setState(207);
|
|
joinExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ArrayJoinClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ArrayJoinClauseContext::ArrayJoinClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ArrayJoinClauseContext::ARRAY() {
|
|
return getToken(HogQLParser::ARRAY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ArrayJoinClauseContext::JOIN() {
|
|
return getToken(HogQLParser::JOIN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ArrayJoinClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ArrayJoinClauseContext::LEFT() {
|
|
return getToken(HogQLParser::LEFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ArrayJoinClauseContext::INNER() {
|
|
return getToken(HogQLParser::INNER, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ArrayJoinClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleArrayJoinClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ArrayJoinClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitArrayJoinClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ArrayJoinClauseContext* HogQLParser::arrayJoinClause() {
|
|
ArrayJoinClauseContext *_localctx = _tracker.createInstance<ArrayJoinClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 14, HogQLParser::RuleArrayJoinClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(210);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::INNER
|
|
|
|
|| _la == HogQLParser::LEFT) {
|
|
setState(209);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::INNER
|
|
|
|
|| _la == HogQLParser::LEFT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(212);
|
|
match(HogQLParser::ARRAY);
|
|
setState(213);
|
|
match(HogQLParser::JOIN);
|
|
setState(214);
|
|
columnExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WindowClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WindowClauseContext::WindowClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WindowClauseContext::WINDOW() {
|
|
return getToken(HogQLParser::WINDOW, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::WindowClauseContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::WindowClauseContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::WindowClauseContext::AS() {
|
|
return getTokens(HogQLParser::AS);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WindowClauseContext::AS(size_t i) {
|
|
return getToken(HogQLParser::AS, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::WindowClauseContext::LPAREN() {
|
|
return getTokens(HogQLParser::LPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WindowClauseContext::LPAREN(size_t i) {
|
|
return getToken(HogQLParser::LPAREN, i);
|
|
}
|
|
|
|
std::vector<HogQLParser::WindowExprContext *> HogQLParser::WindowClauseContext::windowExpr() {
|
|
return getRuleContexts<HogQLParser::WindowExprContext>();
|
|
}
|
|
|
|
HogQLParser::WindowExprContext* HogQLParser::WindowClauseContext::windowExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::WindowExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::WindowClauseContext::RPAREN() {
|
|
return getTokens(HogQLParser::RPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WindowClauseContext::RPAREN(size_t i) {
|
|
return getToken(HogQLParser::RPAREN, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::WindowClauseContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WindowClauseContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WindowClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWindowClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WindowClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWindowClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WindowClauseContext* HogQLParser::windowClause() {
|
|
WindowClauseContext *_localctx = _tracker.createInstance<WindowClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 16, HogQLParser::RuleWindowClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(216);
|
|
match(HogQLParser::WINDOW);
|
|
setState(217);
|
|
identifier();
|
|
setState(218);
|
|
match(HogQLParser::AS);
|
|
setState(219);
|
|
match(HogQLParser::LPAREN);
|
|
setState(220);
|
|
windowExpr();
|
|
setState(221);
|
|
match(HogQLParser::RPAREN);
|
|
setState(231);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(222);
|
|
match(HogQLParser::COMMA);
|
|
setState(223);
|
|
identifier();
|
|
setState(224);
|
|
match(HogQLParser::AS);
|
|
setState(225);
|
|
match(HogQLParser::LPAREN);
|
|
setState(226);
|
|
windowExpr();
|
|
setState(227);
|
|
match(HogQLParser::RPAREN);
|
|
setState(233);
|
|
_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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::PrewhereClauseContext::PrewhereClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::PrewhereClauseContext::PREWHERE() {
|
|
return getToken(HogQLParser::PREWHERE, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::PrewhereClauseContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::PrewhereClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RulePrewhereClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::PrewhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitPrewhereClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::PrewhereClauseContext* HogQLParser::prewhereClause() {
|
|
PrewhereClauseContext *_localctx = _tracker.createInstance<PrewhereClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 18, HogQLParser::RulePrewhereClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(234);
|
|
match(HogQLParser::PREWHERE);
|
|
setState(235);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WhereClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WhereClauseContext::WhereClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WhereClauseContext::WHERE() {
|
|
return getToken(HogQLParser::WHERE, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::WhereClauseContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WhereClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWhereClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWhereClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WhereClauseContext* HogQLParser::whereClause() {
|
|
WhereClauseContext *_localctx = _tracker.createInstance<WhereClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 20, HogQLParser::RuleWhereClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(237);
|
|
match(HogQLParser::WHERE);
|
|
setState(238);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- GroupByClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::GroupByClauseContext::GroupByClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::GROUP() {
|
|
return getToken(HogQLParser::GROUP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::GroupByClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::CUBE() {
|
|
return getToken(HogQLParser::CUBE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::GroupByClauseContext::ROLLUP() {
|
|
return getToken(HogQLParser::ROLLUP, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::GroupByClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleGroupByClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::GroupByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitGroupByClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::GroupByClauseContext* HogQLParser::groupByClause() {
|
|
GroupByClauseContext *_localctx = _tracker.createInstance<GroupByClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 22, HogQLParser::RuleGroupByClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(240);
|
|
match(HogQLParser::GROUP);
|
|
setState(241);
|
|
match(HogQLParser::BY);
|
|
setState(248);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {
|
|
case 1: {
|
|
setState(242);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::CUBE || _la == HogQLParser::ROLLUP)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(243);
|
|
match(HogQLParser::LPAREN);
|
|
setState(244);
|
|
columnExprList();
|
|
setState(245);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(247);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- HavingClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::HavingClauseContext::HavingClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HavingClauseContext::HAVING() {
|
|
return getToken(HogQLParser::HAVING, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::HavingClauseContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::HavingClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleHavingClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::HavingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitHavingClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::HavingClauseContext* HogQLParser::havingClause() {
|
|
HavingClauseContext *_localctx = _tracker.createInstance<HavingClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 24, HogQLParser::RuleHavingClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(250);
|
|
match(HogQLParser::HAVING);
|
|
setState(251);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- OrderByClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::OrderByClauseContext::OrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderByClauseContext::ORDER() {
|
|
return getToken(HogQLParser::ORDER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderByClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
HogQLParser::OrderExprListContext* HogQLParser::OrderByClauseContext::orderExprList() {
|
|
return getRuleContext<HogQLParser::OrderExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::OrderByClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleOrderByClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::OrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitOrderByClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::OrderByClauseContext* HogQLParser::orderByClause() {
|
|
OrderByClauseContext *_localctx = _tracker.createInstance<OrderByClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 26, HogQLParser::RuleOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(253);
|
|
match(HogQLParser::ORDER);
|
|
setState(254);
|
|
match(HogQLParser::BY);
|
|
setState(255);
|
|
orderExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ProjectionOrderByClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ProjectionOrderByClauseContext::ProjectionOrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ProjectionOrderByClauseContext::ORDER() {
|
|
return getToken(HogQLParser::ORDER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ProjectionOrderByClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ProjectionOrderByClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ProjectionOrderByClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleProjectionOrderByClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ProjectionOrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitProjectionOrderByClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ProjectionOrderByClauseContext* HogQLParser::projectionOrderByClause() {
|
|
ProjectionOrderByClauseContext *_localctx = _tracker.createInstance<ProjectionOrderByClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 28, HogQLParser::RuleProjectionOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(257);
|
|
match(HogQLParser::ORDER);
|
|
setState(258);
|
|
match(HogQLParser::BY);
|
|
setState(259);
|
|
columnExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- LimitAndOffsetClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::LimitAndOffsetClauseContext::LimitAndOffsetClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::LIMIT() {
|
|
return getToken(HogQLParser::LIMIT, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::LimitAndOffsetClauseContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::LimitAndOffsetClauseContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::COMMA() {
|
|
return getToken(HogQLParser::COMMA, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::LimitAndOffsetClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::WITH() {
|
|
return getToken(HogQLParser::WITH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::TIES() {
|
|
return getToken(HogQLParser::TIES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LimitAndOffsetClauseContext::OFFSET() {
|
|
return getToken(HogQLParser::OFFSET, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::LimitAndOffsetClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleLimitAndOffsetClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::LimitAndOffsetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitLimitAndOffsetClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::LimitAndOffsetClauseContext* HogQLParser::limitAndOffsetClause() {
|
|
LimitAndOffsetClauseContext *_localctx = _tracker.createInstance<LimitAndOffsetClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 30, HogQLParser::RuleLimitAndOffsetClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(290);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(261);
|
|
match(HogQLParser::LIMIT);
|
|
setState(262);
|
|
columnExpr(0);
|
|
setState(265);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(263);
|
|
match(HogQLParser::COMMA);
|
|
setState(264);
|
|
columnExpr(0);
|
|
}
|
|
setState(271);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::WITH: {
|
|
setState(267);
|
|
match(HogQLParser::WITH);
|
|
setState(268);
|
|
match(HogQLParser::TIES);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::BY: {
|
|
setState(269);
|
|
match(HogQLParser::BY);
|
|
setState(270);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::EOF:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::RPAREN: {
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(273);
|
|
match(HogQLParser::LIMIT);
|
|
setState(274);
|
|
columnExpr(0);
|
|
setState(277);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(275);
|
|
match(HogQLParser::WITH);
|
|
setState(276);
|
|
match(HogQLParser::TIES);
|
|
}
|
|
setState(279);
|
|
match(HogQLParser::OFFSET);
|
|
setState(280);
|
|
columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(282);
|
|
match(HogQLParser::LIMIT);
|
|
setState(283);
|
|
columnExpr(0);
|
|
setState(284);
|
|
match(HogQLParser::OFFSET);
|
|
setState(285);
|
|
columnExpr(0);
|
|
setState(288);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::BY) {
|
|
setState(286);
|
|
match(HogQLParser::BY);
|
|
setState(287);
|
|
columnExprList();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- OffsetOnlyClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::OffsetOnlyClauseContext::OffsetOnlyClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OffsetOnlyClauseContext::OFFSET() {
|
|
return getToken(HogQLParser::OFFSET, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::OffsetOnlyClauseContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::OffsetOnlyClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleOffsetOnlyClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::OffsetOnlyClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitOffsetOnlyClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::OffsetOnlyClauseContext* HogQLParser::offsetOnlyClause() {
|
|
OffsetOnlyClauseContext *_localctx = _tracker.createInstance<OffsetOnlyClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 32, HogQLParser::RuleOffsetOnlyClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(292);
|
|
match(HogQLParser::OFFSET);
|
|
setState(293);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SettingsClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SettingsClauseContext::SettingsClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SettingsClauseContext::SETTINGS() {
|
|
return getToken(HogQLParser::SETTINGS, 0);
|
|
}
|
|
|
|
HogQLParser::SettingExprListContext* HogQLParser::SettingsClauseContext::settingExprList() {
|
|
return getRuleContext<HogQLParser::SettingExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SettingsClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSettingsClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SettingsClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSettingsClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SettingsClauseContext* HogQLParser::settingsClause() {
|
|
SettingsClauseContext *_localctx = _tracker.createInstance<SettingsClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 34, HogQLParser::RuleSettingsClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(295);
|
|
match(HogQLParser::SETTINGS);
|
|
setState(296);
|
|
settingExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- JoinExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::JoinExprContext::JoinExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::JoinExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleJoinExpr;
|
|
}
|
|
|
|
void HogQLParser::JoinExprContext::copyFrom(JoinExprContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- JoinExprOpContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::JoinExprContext *> HogQLParser::JoinExprOpContext::joinExpr() {
|
|
return getRuleContexts<HogQLParser::JoinExprContext>();
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::JoinExprOpContext::joinExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::JoinExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinExprOpContext::JOIN() {
|
|
return getToken(HogQLParser::JOIN, 0);
|
|
}
|
|
|
|
HogQLParser::JoinConstraintClauseContext* HogQLParser::JoinExprOpContext::joinConstraintClause() {
|
|
return getRuleContext<HogQLParser::JoinConstraintClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::JoinOpContext* HogQLParser::JoinExprOpContext::joinOp() {
|
|
return getRuleContext<HogQLParser::JoinOpContext>(0);
|
|
}
|
|
|
|
HogQLParser::JoinExprOpContext::JoinExprOpContext(JoinExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinExprOpContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinExprOp(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- JoinExprTableContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableExprContext* HogQLParser::JoinExprTableContext::tableExpr() {
|
|
return getRuleContext<HogQLParser::TableExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinExprTableContext::FINAL() {
|
|
return getToken(HogQLParser::FINAL, 0);
|
|
}
|
|
|
|
HogQLParser::SampleClauseContext* HogQLParser::JoinExprTableContext::sampleClause() {
|
|
return getRuleContext<HogQLParser::SampleClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::JoinExprTableContext::JoinExprTableContext(JoinExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinExprTableContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinExprTable(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- JoinExprParensContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::JoinExprParensContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::JoinExprParensContext::joinExpr() {
|
|
return getRuleContext<HogQLParser::JoinExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinExprParensContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::JoinExprParensContext::JoinExprParensContext(JoinExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinExprParensContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinExprParens(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- JoinExprCrossOpContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::JoinExprContext *> HogQLParser::JoinExprCrossOpContext::joinExpr() {
|
|
return getRuleContexts<HogQLParser::JoinExprContext>();
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::JoinExprCrossOpContext::joinExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::JoinExprContext>(i);
|
|
}
|
|
|
|
HogQLParser::JoinOpCrossContext* HogQLParser::JoinExprCrossOpContext::joinOpCross() {
|
|
return getRuleContext<HogQLParser::JoinOpCrossContext>(0);
|
|
}
|
|
|
|
HogQLParser::JoinExprCrossOpContext::JoinExprCrossOpContext(JoinExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinExprCrossOpContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinExprCrossOp(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::joinExpr() {
|
|
return joinExpr(0);
|
|
}
|
|
|
|
HogQLParser::JoinExprContext* HogQLParser::joinExpr(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
HogQLParser::JoinExprContext *_localctx = _tracker.createInstance<JoinExprContext>(_ctx, parentState);
|
|
HogQLParser::JoinExprContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 36;
|
|
enterRecursionRule(_localctx, 36, HogQLParser::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(310);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<JoinExprTableContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(299);
|
|
tableExpr(0);
|
|
setState(301);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
|
|
case 1: {
|
|
setState(300);
|
|
match(HogQLParser::FINAL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(304);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
|
|
case 1: {
|
|
setState(303);
|
|
sampleClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<JoinExprParensContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(306);
|
|
match(HogQLParser::LPAREN);
|
|
setState(307);
|
|
joinExpr(0);
|
|
setState(308);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(326);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(324);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx)) {
|
|
case 1: {
|
|
auto newContext = _tracker.createInstance<JoinExprCrossOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
|
|
setState(312);
|
|
|
|
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(313);
|
|
joinOpCross();
|
|
setState(314);
|
|
joinExpr(4);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
auto newContext = _tracker.createInstance<JoinExprOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
|
|
setState(316);
|
|
|
|
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(318);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4496) != 0) || ((((_la - 69) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 69)) & 134250497) != 0) || _la == HogQLParser::RIGHT
|
|
|
|
|| _la == HogQLParser::SEMI) {
|
|
setState(317);
|
|
joinOp();
|
|
}
|
|
setState(320);
|
|
match(HogQLParser::JOIN);
|
|
setState(321);
|
|
joinExpr(0);
|
|
setState(322);
|
|
joinConstraintClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
setState(328);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- JoinOpContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::JoinOpContext::JoinOpContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::JoinOpContext::getRuleIndex() const {
|
|
return HogQLParser::RuleJoinOp;
|
|
}
|
|
|
|
void HogQLParser::JoinOpContext::copyFrom(JoinOpContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- JoinOpFullContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpFullContext::FULL() {
|
|
return getToken(HogQLParser::FULL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpFullContext::OUTER() {
|
|
return getToken(HogQLParser::OUTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpFullContext::ALL() {
|
|
return getToken(HogQLParser::ALL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpFullContext::ANY() {
|
|
return getToken(HogQLParser::ANY, 0);
|
|
}
|
|
|
|
HogQLParser::JoinOpFullContext::JoinOpFullContext(JoinOpContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinOpFullContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinOpFull(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- JoinOpInnerContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpInnerContext::INNER() {
|
|
return getToken(HogQLParser::INNER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpInnerContext::ALL() {
|
|
return getToken(HogQLParser::ALL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpInnerContext::ANY() {
|
|
return getToken(HogQLParser::ANY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpInnerContext::ASOF() {
|
|
return getToken(HogQLParser::ASOF, 0);
|
|
}
|
|
|
|
HogQLParser::JoinOpInnerContext::JoinOpInnerContext(JoinOpContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinOpInnerContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinOpInner(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- JoinOpLeftRightContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::LEFT() {
|
|
return getToken(HogQLParser::LEFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::RIGHT() {
|
|
return getToken(HogQLParser::RIGHT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::OUTER() {
|
|
return getToken(HogQLParser::OUTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::SEMI() {
|
|
return getToken(HogQLParser::SEMI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::ALL() {
|
|
return getToken(HogQLParser::ALL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::ANTI() {
|
|
return getToken(HogQLParser::ANTI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::ANY() {
|
|
return getToken(HogQLParser::ANY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpLeftRightContext::ASOF() {
|
|
return getToken(HogQLParser::ASOF, 0);
|
|
}
|
|
|
|
HogQLParser::JoinOpLeftRightContext::JoinOpLeftRightContext(JoinOpContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::JoinOpLeftRightContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinOpLeftRight(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
HogQLParser::JoinOpContext* HogQLParser::joinOp() {
|
|
JoinOpContext *_localctx = _tracker.createInstance<JoinOpContext>(_ctx, getState());
|
|
enterRule(_localctx, 38, HogQLParser::RuleJoinOp);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(372);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::JoinOpInnerContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(338);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx)) {
|
|
case 1: {
|
|
setState(330);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4368) != 0)) {
|
|
setState(329);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4368) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(332);
|
|
match(HogQLParser::INNER);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(333);
|
|
match(HogQLParser::INNER);
|
|
setState(335);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4368) != 0)) {
|
|
setState(334);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4368) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(337);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4368) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::JoinOpLeftRightContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(354);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx)) {
|
|
case 1: {
|
|
setState(341);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI) {
|
|
setState(340);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(343);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::LEFT
|
|
|
|
|| _la == HogQLParser::RIGHT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(345);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(344);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(347);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::LEFT
|
|
|
|
|| _la == HogQLParser::RIGHT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(349);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(348);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
setState(352);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI) {
|
|
setState(351);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<HogQLParser::JoinOpFullContext>(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(370);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx)) {
|
|
case 1: {
|
|
setState(357);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY) {
|
|
setState(356);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(359);
|
|
match(HogQLParser::FULL);
|
|
setState(361);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(360);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(363);
|
|
match(HogQLParser::FULL);
|
|
setState(365);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(364);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
setState(368);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY) {
|
|
setState(367);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY)) {
|
|
_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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::JoinOpCrossContext::JoinOpCrossContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpCrossContext::CROSS() {
|
|
return getToken(HogQLParser::CROSS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpCrossContext::JOIN() {
|
|
return getToken(HogQLParser::JOIN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinOpCrossContext::COMMA() {
|
|
return getToken(HogQLParser::COMMA, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::JoinOpCrossContext::getRuleIndex() const {
|
|
return HogQLParser::RuleJoinOpCross;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::JoinOpCrossContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinOpCross(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::JoinOpCrossContext* HogQLParser::joinOpCross() {
|
|
JoinOpCrossContext *_localctx = _tracker.createInstance<JoinOpCrossContext>(_ctx, getState());
|
|
enterRule(_localctx, 40, HogQLParser::RuleJoinOpCross);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(377);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::CROSS: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(374);
|
|
match(HogQLParser::CROSS);
|
|
setState(375);
|
|
match(HogQLParser::JOIN);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::COMMA: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(376);
|
|
match(HogQLParser::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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::JoinConstraintClauseContext::JoinConstraintClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinConstraintClauseContext::ON() {
|
|
return getToken(HogQLParser::ON, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::JoinConstraintClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinConstraintClauseContext::USING() {
|
|
return getToken(HogQLParser::USING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinConstraintClauseContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::JoinConstraintClauseContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::JoinConstraintClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleJoinConstraintClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::JoinConstraintClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitJoinConstraintClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::JoinConstraintClauseContext* HogQLParser::joinConstraintClause() {
|
|
JoinConstraintClauseContext *_localctx = _tracker.createInstance<JoinConstraintClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 42, HogQLParser::RuleJoinConstraintClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(388);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(379);
|
|
match(HogQLParser::ON);
|
|
setState(380);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(381);
|
|
match(HogQLParser::USING);
|
|
setState(382);
|
|
match(HogQLParser::LPAREN);
|
|
setState(383);
|
|
columnExprList();
|
|
setState(384);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(386);
|
|
match(HogQLParser::USING);
|
|
setState(387);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SampleClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SampleClauseContext::SampleClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SampleClauseContext::SAMPLE() {
|
|
return getToken(HogQLParser::SAMPLE, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::RatioExprContext *> HogQLParser::SampleClauseContext::ratioExpr() {
|
|
return getRuleContexts<HogQLParser::RatioExprContext>();
|
|
}
|
|
|
|
HogQLParser::RatioExprContext* HogQLParser::SampleClauseContext::ratioExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::RatioExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SampleClauseContext::OFFSET() {
|
|
return getToken(HogQLParser::OFFSET, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SampleClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSampleClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SampleClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSampleClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SampleClauseContext* HogQLParser::sampleClause() {
|
|
SampleClauseContext *_localctx = _tracker.createInstance<SampleClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 44, HogQLParser::RuleSampleClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(390);
|
|
match(HogQLParser::SAMPLE);
|
|
setState(391);
|
|
ratioExpr();
|
|
setState(394);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
|
|
case 1: {
|
|
setState(392);
|
|
match(HogQLParser::OFFSET);
|
|
setState(393);
|
|
ratioExpr();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- OrderExprListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::OrderExprListContext::OrderExprListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::OrderExprContext *> HogQLParser::OrderExprListContext::orderExpr() {
|
|
return getRuleContexts<HogQLParser::OrderExprContext>();
|
|
}
|
|
|
|
HogQLParser::OrderExprContext* HogQLParser::OrderExprListContext::orderExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::OrderExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::OrderExprListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::OrderExprListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleOrderExprList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::OrderExprListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitOrderExprList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::OrderExprListContext* HogQLParser::orderExprList() {
|
|
OrderExprListContext *_localctx = _tracker.createInstance<OrderExprListContext>(_ctx, getState());
|
|
enterRule(_localctx, 46, HogQLParser::RuleOrderExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(396);
|
|
orderExpr();
|
|
setState(401);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(397);
|
|
match(HogQLParser::COMMA);
|
|
setState(398);
|
|
orderExpr();
|
|
setState(403);
|
|
_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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::OrderExprContext::OrderExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::OrderExprContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::NULLS() {
|
|
return getToken(HogQLParser::NULLS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::COLLATE() {
|
|
return getToken(HogQLParser::COLLATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::ASCENDING() {
|
|
return getToken(HogQLParser::ASCENDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::DESCENDING() {
|
|
return getToken(HogQLParser::DESCENDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::DESC() {
|
|
return getToken(HogQLParser::DESC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::FIRST() {
|
|
return getToken(HogQLParser::FIRST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::OrderExprContext::LAST() {
|
|
return getToken(HogQLParser::LAST, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::OrderExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleOrderExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::OrderExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitOrderExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::OrderExprContext* HogQLParser::orderExpr() {
|
|
OrderExprContext *_localctx = _tracker.createInstance<OrderExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 48, HogQLParser::RuleOrderExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(404);
|
|
columnExpr(0);
|
|
setState(406);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 13194139535360) != 0)) {
|
|
setState(405);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 13194139535360) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(410);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NULLS) {
|
|
setState(408);
|
|
match(HogQLParser::NULLS);
|
|
setState(409);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::FIRST
|
|
|
|
|| _la == HogQLParser::LAST)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(414);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COLLATE) {
|
|
setState(412);
|
|
match(HogQLParser::COLLATE);
|
|
setState(413);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- RatioExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::RatioExprContext::RatioExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::PlaceholderContext* HogQLParser::RatioExprContext::placeholder() {
|
|
return getRuleContext<HogQLParser::PlaceholderContext>(0);
|
|
}
|
|
|
|
std::vector<HogQLParser::NumberLiteralContext *> HogQLParser::RatioExprContext::numberLiteral() {
|
|
return getRuleContexts<HogQLParser::NumberLiteralContext>();
|
|
}
|
|
|
|
HogQLParser::NumberLiteralContext* HogQLParser::RatioExprContext::numberLiteral(size_t i) {
|
|
return getRuleContext<HogQLParser::NumberLiteralContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::RatioExprContext::SLASH() {
|
|
return getToken(HogQLParser::SLASH, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::RatioExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleRatioExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::RatioExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitRatioExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::RatioExprContext* HogQLParser::ratioExpr() {
|
|
RatioExprContext *_localctx = _tracker.createInstance<RatioExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 50, HogQLParser::RuleRatioExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(422);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(416);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::INF:
|
|
case HogQLParser::NAN_SQL:
|
|
case HogQLParser::FLOATING_LITERAL:
|
|
case HogQLParser::OCTAL_LITERAL:
|
|
case HogQLParser::DECIMAL_LITERAL:
|
|
case HogQLParser::HEXADECIMAL_LITERAL:
|
|
case HogQLParser::DASH:
|
|
case HogQLParser::DOT:
|
|
case HogQLParser::PLUS: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(417);
|
|
numberLiteral();
|
|
setState(420);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
|
|
case 1: {
|
|
setState(418);
|
|
match(HogQLParser::SLASH);
|
|
setState(419);
|
|
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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::SettingExprListContext::SettingExprListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::SettingExprContext *> HogQLParser::SettingExprListContext::settingExpr() {
|
|
return getRuleContexts<HogQLParser::SettingExprContext>();
|
|
}
|
|
|
|
HogQLParser::SettingExprContext* HogQLParser::SettingExprListContext::settingExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::SettingExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::SettingExprListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SettingExprListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SettingExprListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSettingExprList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SettingExprListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSettingExprList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SettingExprListContext* HogQLParser::settingExprList() {
|
|
SettingExprListContext *_localctx = _tracker.createInstance<SettingExprListContext>(_ctx, getState());
|
|
enterRule(_localctx, 52, HogQLParser::RuleSettingExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(424);
|
|
settingExpr();
|
|
setState(429);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(425);
|
|
match(HogQLParser::COMMA);
|
|
setState(426);
|
|
settingExpr();
|
|
setState(431);
|
|
_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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::SettingExprContext::SettingExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::SettingExprContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SettingExprContext::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
HogQLParser::LiteralContext* HogQLParser::SettingExprContext::literal() {
|
|
return getRuleContext<HogQLParser::LiteralContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SettingExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSettingExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SettingExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSettingExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SettingExprContext* HogQLParser::settingExpr() {
|
|
SettingExprContext *_localctx = _tracker.createInstance<SettingExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 54, HogQLParser::RuleSettingExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(432);
|
|
identifier();
|
|
setState(433);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(434);
|
|
literal();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WindowExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WindowExprContext::WindowExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::WinPartitionByClauseContext* HogQLParser::WindowExprContext::winPartitionByClause() {
|
|
return getRuleContext<HogQLParser::WinPartitionByClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::WinOrderByClauseContext* HogQLParser::WindowExprContext::winOrderByClause() {
|
|
return getRuleContext<HogQLParser::WinOrderByClauseContext>(0);
|
|
}
|
|
|
|
HogQLParser::WinFrameClauseContext* HogQLParser::WindowExprContext::winFrameClause() {
|
|
return getRuleContext<HogQLParser::WinFrameClauseContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WindowExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWindowExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WindowExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWindowExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WindowExprContext* HogQLParser::windowExpr() {
|
|
WindowExprContext *_localctx = _tracker.createInstance<WindowExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 56, HogQLParser::RuleWindowExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(437);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::PARTITION) {
|
|
setState(436);
|
|
winPartitionByClause();
|
|
}
|
|
setState(440);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ORDER) {
|
|
setState(439);
|
|
winOrderByClause();
|
|
}
|
|
setState(443);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::RANGE
|
|
|
|
|| _la == HogQLParser::ROWS) {
|
|
setState(442);
|
|
winFrameClause();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WinPartitionByClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinPartitionByClauseContext::WinPartitionByClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinPartitionByClauseContext::PARTITION() {
|
|
return getToken(HogQLParser::PARTITION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinPartitionByClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::WinPartitionByClauseContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WinPartitionByClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWinPartitionByClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WinPartitionByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWinPartitionByClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WinPartitionByClauseContext* HogQLParser::winPartitionByClause() {
|
|
WinPartitionByClauseContext *_localctx = _tracker.createInstance<WinPartitionByClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 58, HogQLParser::RuleWinPartitionByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(445);
|
|
match(HogQLParser::PARTITION);
|
|
setState(446);
|
|
match(HogQLParser::BY);
|
|
setState(447);
|
|
columnExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WinOrderByClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinOrderByClauseContext::WinOrderByClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinOrderByClauseContext::ORDER() {
|
|
return getToken(HogQLParser::ORDER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinOrderByClauseContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
HogQLParser::OrderExprListContext* HogQLParser::WinOrderByClauseContext::orderExprList() {
|
|
return getRuleContext<HogQLParser::OrderExprListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WinOrderByClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWinOrderByClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WinOrderByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWinOrderByClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WinOrderByClauseContext* HogQLParser::winOrderByClause() {
|
|
WinOrderByClauseContext *_localctx = _tracker.createInstance<WinOrderByClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 60, HogQLParser::RuleWinOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(449);
|
|
match(HogQLParser::ORDER);
|
|
setState(450);
|
|
match(HogQLParser::BY);
|
|
setState(451);
|
|
orderExprList();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WinFrameClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinFrameClauseContext::WinFrameClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::WinFrameExtendContext* HogQLParser::WinFrameClauseContext::winFrameExtend() {
|
|
return getRuleContext<HogQLParser::WinFrameExtendContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameClauseContext::ROWS() {
|
|
return getToken(HogQLParser::ROWS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameClauseContext::RANGE() {
|
|
return getToken(HogQLParser::RANGE, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WinFrameClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWinFrameClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WinFrameClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWinFrameClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WinFrameClauseContext* HogQLParser::winFrameClause() {
|
|
WinFrameClauseContext *_localctx = _tracker.createInstance<WinFrameClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 62, HogQLParser::RuleWinFrameClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(453);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::RANGE
|
|
|
|
|| _la == HogQLParser::ROWS)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(454);
|
|
winFrameExtend();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WinFrameExtendContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinFrameExtendContext::WinFrameExtendContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WinFrameExtendContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWinFrameExtend;
|
|
}
|
|
|
|
void HogQLParser::WinFrameExtendContext::copyFrom(WinFrameExtendContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- FrameStartContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinFrameBoundContext* HogQLParser::FrameStartContext::winFrameBound() {
|
|
return getRuleContext<HogQLParser::WinFrameBoundContext>(0);
|
|
}
|
|
|
|
HogQLParser::FrameStartContext::FrameStartContext(WinFrameExtendContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::FrameStartContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFrameStart(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- FrameBetweenContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::FrameBetweenContext::BETWEEN() {
|
|
return getToken(HogQLParser::BETWEEN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::WinFrameBoundContext *> HogQLParser::FrameBetweenContext::winFrameBound() {
|
|
return getRuleContexts<HogQLParser::WinFrameBoundContext>();
|
|
}
|
|
|
|
HogQLParser::WinFrameBoundContext* HogQLParser::FrameBetweenContext::winFrameBound(size_t i) {
|
|
return getRuleContext<HogQLParser::WinFrameBoundContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FrameBetweenContext::AND() {
|
|
return getToken(HogQLParser::AND, 0);
|
|
}
|
|
|
|
HogQLParser::FrameBetweenContext::FrameBetweenContext(WinFrameExtendContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::FrameBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFrameBetween(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
HogQLParser::WinFrameExtendContext* HogQLParser::winFrameExtend() {
|
|
WinFrameExtendContext *_localctx = _tracker.createInstance<WinFrameExtendContext>(_ctx, getState());
|
|
enterRule(_localctx, 64, HogQLParser::RuleWinFrameExtend);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(462);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::INF:
|
|
case HogQLParser::NAN_SQL:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::FLOATING_LITERAL:
|
|
case HogQLParser::OCTAL_LITERAL:
|
|
case HogQLParser::DECIMAL_LITERAL:
|
|
case HogQLParser::HEXADECIMAL_LITERAL:
|
|
case HogQLParser::DASH:
|
|
case HogQLParser::DOT:
|
|
case HogQLParser::PLUS: {
|
|
_localctx = _tracker.createInstance<HogQLParser::FrameStartContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(456);
|
|
winFrameBound();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::BETWEEN: {
|
|
_localctx = _tracker.createInstance<HogQLParser::FrameBetweenContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(457);
|
|
match(HogQLParser::BETWEEN);
|
|
setState(458);
|
|
winFrameBound();
|
|
setState(459);
|
|
match(HogQLParser::AND);
|
|
setState(460);
|
|
winFrameBound();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WinFrameBoundContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WinFrameBoundContext::WinFrameBoundContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameBoundContext::CURRENT() {
|
|
return getToken(HogQLParser::CURRENT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameBoundContext::ROW() {
|
|
return getToken(HogQLParser::ROW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameBoundContext::UNBOUNDED() {
|
|
return getToken(HogQLParser::UNBOUNDED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameBoundContext::PRECEDING() {
|
|
return getToken(HogQLParser::PRECEDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WinFrameBoundContext::FOLLOWING() {
|
|
return getToken(HogQLParser::FOLLOWING, 0);
|
|
}
|
|
|
|
HogQLParser::NumberLiteralContext* HogQLParser::WinFrameBoundContext::numberLiteral() {
|
|
return getRuleContext<HogQLParser::NumberLiteralContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WinFrameBoundContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWinFrameBound;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WinFrameBoundContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWinFrameBound(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WinFrameBoundContext* HogQLParser::winFrameBound() {
|
|
WinFrameBoundContext *_localctx = _tracker.createInstance<WinFrameBoundContext>(_ctx, getState());
|
|
enterRule(_localctx, 66, HogQLParser::RuleWinFrameBound);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(476);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
|
|
case 1: {
|
|
setState(464);
|
|
match(HogQLParser::CURRENT);
|
|
setState(465);
|
|
match(HogQLParser::ROW);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(466);
|
|
match(HogQLParser::UNBOUNDED);
|
|
setState(467);
|
|
match(HogQLParser::PRECEDING);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(468);
|
|
match(HogQLParser::UNBOUNDED);
|
|
setState(469);
|
|
match(HogQLParser::FOLLOWING);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(470);
|
|
numberLiteral();
|
|
setState(471);
|
|
match(HogQLParser::PRECEDING);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(473);
|
|
numberLiteral();
|
|
setState(474);
|
|
match(HogQLParser::FOLLOWING);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ExprContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ExprContext::EOF() {
|
|
return getToken(HogQLParser::EOF, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ExprContext* HogQLParser::expr() {
|
|
ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 68, HogQLParser::RuleExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(478);
|
|
columnExpr(0);
|
|
setState(479);
|
|
match(HogQLParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnTypeExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnTypeExprContext::ColumnTypeExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnTypeExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnTypeExpr;
|
|
}
|
|
|
|
void HogQLParser::ColumnTypeExprContext::copyFrom(ColumnTypeExprContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- ColumnTypeExprNestedContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::ColumnTypeExprNestedContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnTypeExprNestedContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprNestedContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnTypeExprContext *> HogQLParser::ColumnTypeExprNestedContext::columnTypeExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnTypeExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprContext* HogQLParser::ColumnTypeExprNestedContext::columnTypeExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnTypeExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprNestedContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnTypeExprNestedContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprNestedContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprNestedContext::ColumnTypeExprNestedContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnTypeExprNestedContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnTypeExprNested(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnTypeExprParamContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnTypeExprParamContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprParamContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprParamContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnTypeExprParamContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprParamContext::ColumnTypeExprParamContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnTypeExprParamContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnTypeExprParam(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnTypeExprSimpleContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnTypeExprSimpleContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprSimpleContext::ColumnTypeExprSimpleContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnTypeExprSimpleContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnTypeExprSimple(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnTypeExprComplexContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnTypeExprComplexContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprComplexContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnTypeExprContext *> HogQLParser::ColumnTypeExprComplexContext::columnTypeExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnTypeExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprContext* HogQLParser::ColumnTypeExprComplexContext::columnTypeExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnTypeExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprComplexContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnTypeExprComplexContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprComplexContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprComplexContext::ColumnTypeExprComplexContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnTypeExprComplexContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnTypeExprComplex(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnTypeExprEnumContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnTypeExprEnumContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprEnumContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::EnumValueContext *> HogQLParser::ColumnTypeExprEnumContext::enumValue() {
|
|
return getRuleContexts<HogQLParser::EnumValueContext>();
|
|
}
|
|
|
|
HogQLParser::EnumValueContext* HogQLParser::ColumnTypeExprEnumContext::enumValue(size_t i) {
|
|
return getRuleContext<HogQLParser::EnumValueContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprEnumContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnTypeExprEnumContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnTypeExprEnumContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprEnumContext::ColumnTypeExprEnumContext(ColumnTypeExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnTypeExprEnumContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnTypeExprEnum(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
HogQLParser::ColumnTypeExprContext* HogQLParser::columnTypeExpr() {
|
|
ColumnTypeExprContext *_localctx = _tracker.createInstance<ColumnTypeExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 70, HogQLParser::RuleColumnTypeExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(528);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprSimpleContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(481);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprNestedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(482);
|
|
identifier();
|
|
setState(483);
|
|
match(HogQLParser::LPAREN);
|
|
setState(484);
|
|
identifier();
|
|
setState(485);
|
|
columnTypeExpr();
|
|
setState(492);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(486);
|
|
match(HogQLParser::COMMA);
|
|
setState(487);
|
|
identifier();
|
|
setState(488);
|
|
columnTypeExpr();
|
|
setState(494);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(495);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprEnumContext>(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(497);
|
|
identifier();
|
|
setState(498);
|
|
match(HogQLParser::LPAREN);
|
|
setState(499);
|
|
enumValue();
|
|
setState(504);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(500);
|
|
match(HogQLParser::COMMA);
|
|
setState(501);
|
|
enumValue();
|
|
setState(506);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(507);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprComplexContext>(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(509);
|
|
identifier();
|
|
setState(510);
|
|
match(HogQLParser::LPAREN);
|
|
setState(511);
|
|
columnTypeExpr();
|
|
setState(516);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(512);
|
|
match(HogQLParser::COMMA);
|
|
setState(513);
|
|
columnTypeExpr();
|
|
setState(518);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(519);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprParamContext>(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(521);
|
|
identifier();
|
|
setState(522);
|
|
match(HogQLParser::LPAREN);
|
|
setState(524);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(523);
|
|
columnExprList();
|
|
}
|
|
setState(526);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnExprListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprListContext::ColumnExprListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprListContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprListContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnExprListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnExprList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ColumnExprListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::columnExprList() {
|
|
ColumnExprListContext *_localctx = _tracker.createInstance<ColumnExprListContext>(_ctx, getState());
|
|
enterRule(_localctx, 72, HogQLParser::RuleColumnExprList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(530);
|
|
columnExpr(0);
|
|
setState(535);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(531);
|
|
match(HogQLParser::COMMA);
|
|
setState(532);
|
|
columnExpr(0);
|
|
}
|
|
setState(537);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext::ColumnExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnExpr;
|
|
}
|
|
|
|
void HogQLParser::ColumnExprContext::copyFrom(ColumnExprContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- ColumnExprTernaryOpContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprTernaryOpContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprTernaryOpContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTernaryOpContext::QUERY() {
|
|
return getToken(HogQLParser::QUERY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTernaryOpContext::COLON() {
|
|
return getToken(HogQLParser::COLON, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTernaryOpContext::ColumnExprTernaryOpContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTernaryOpContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTernaryOp(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprAliasContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprAliasContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::AliasContext* HogQLParser::ColumnExprAliasContext::alias() {
|
|
return getRuleContext<HogQLParser::AliasContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprAliasContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprAliasContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprAliasContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprAliasContext::ColumnExprAliasContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprAliasContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprAlias(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprExtractContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprExtractContext::EXTRACT() {
|
|
return getToken(HogQLParser::EXTRACT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprExtractContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::IntervalContext* HogQLParser::ColumnExprExtractContext::interval() {
|
|
return getRuleContext<HogQLParser::IntervalContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprExtractContext::FROM() {
|
|
return getToken(HogQLParser::FROM, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprExtractContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprExtractContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprExtractContext::ColumnExprExtractContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprExtractContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprExtract(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprNegateContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNegateContext::DASH() {
|
|
return getToken(HogQLParser::DASH, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNegateContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNegateContext::ColumnExprNegateContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNegateContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNegate(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprSubqueryContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubqueryContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::ColumnExprSubqueryContext::selectUnionStmt() {
|
|
return getRuleContext<HogQLParser::SelectUnionStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubqueryContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprSubqueryContext::ColumnExprSubqueryContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprSubquery(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprLiteralContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::LiteralContext* HogQLParser::ColumnExprLiteralContext::literal() {
|
|
return getRuleContext<HogQLParser::LiteralContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprLiteralContext::ColumnExprLiteralContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprArrayContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprArrayContext::LBRACKET() {
|
|
return getToken(HogQLParser::LBRACKET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprArrayContext::RBRACKET() {
|
|
return getToken(HogQLParser::RBRACKET, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprArrayContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprArrayContext::ColumnExprArrayContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprArrayContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprArray(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprSubstringContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubstringContext::SUBSTRING() {
|
|
return getToken(HogQLParser::SUBSTRING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubstringContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprSubstringContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprSubstringContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubstringContext::FROM() {
|
|
return getToken(HogQLParser::FROM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubstringContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubstringContext::FOR() {
|
|
return getToken(HogQLParser::FOR, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprSubstringContext::ColumnExprSubstringContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprSubstringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprSubstring(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprCastContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCastContext::CAST() {
|
|
return getToken(HogQLParser::CAST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCastContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprCastContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCastContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnTypeExprContext* HogQLParser::ColumnExprCastContext::columnTypeExpr() {
|
|
return getRuleContext<HogQLParser::ColumnTypeExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCastContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprCastContext::ColumnExprCastContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprCastContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprCast(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprOrContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprOrContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprOrContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprOrContext::OR() {
|
|
return getToken(HogQLParser::OR, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprOrContext::ColumnExprOrContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprOrContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprOr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprPrecedence1Context ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprPrecedence1Context::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprPrecedence1Context::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence1Context::ASTERISK() {
|
|
return getToken(HogQLParser::ASTERISK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence1Context::SLASH() {
|
|
return getToken(HogQLParser::SLASH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence1Context::PERCENT() {
|
|
return getToken(HogQLParser::PERCENT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprPrecedence1Context::ColumnExprPrecedence1Context(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprPrecedence1Context::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprPrecedence1(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprPrecedence2Context ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprPrecedence2Context::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprPrecedence2Context::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence2Context::PLUS() {
|
|
return getToken(HogQLParser::PLUS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence2Context::DASH() {
|
|
return getToken(HogQLParser::DASH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence2Context::CONCAT() {
|
|
return getToken(HogQLParser::CONCAT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprPrecedence2Context::ColumnExprPrecedence2Context(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprPrecedence2Context::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprPrecedence2(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprPrecedence3Context ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprPrecedence3Context::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprPrecedence3Context::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::IN() {
|
|
return getToken(HogQLParser::IN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::EQ_DOUBLE() {
|
|
return getToken(HogQLParser::EQ_DOUBLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::NOT_EQ() {
|
|
return getToken(HogQLParser::NOT_EQ, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::LT_EQ() {
|
|
return getToken(HogQLParser::LT_EQ, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::LT() {
|
|
return getToken(HogQLParser::LT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::GT_EQ() {
|
|
return getToken(HogQLParser::GT_EQ, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::GT() {
|
|
return getToken(HogQLParser::GT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::LIKE() {
|
|
return getToken(HogQLParser::LIKE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::ILIKE() {
|
|
return getToken(HogQLParser::ILIKE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::REGEX_SINGLE() {
|
|
return getToken(HogQLParser::REGEX_SINGLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::REGEX_DOUBLE() {
|
|
return getToken(HogQLParser::REGEX_DOUBLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::NOT_REGEX() {
|
|
return getToken(HogQLParser::NOT_REGEX, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::IREGEX_SINGLE() {
|
|
return getToken(HogQLParser::IREGEX_SINGLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::IREGEX_DOUBLE() {
|
|
return getToken(HogQLParser::IREGEX_DOUBLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::NOT_IREGEX() {
|
|
return getToken(HogQLParser::NOT_IREGEX, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::COHORT() {
|
|
return getToken(HogQLParser::COHORT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPrecedence3Context::NOT() {
|
|
return getToken(HogQLParser::NOT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprPrecedence3Context::ColumnExprPrecedence3Context(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprPrecedence3Context::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprPrecedence3(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprIntervalContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIntervalContext::INTERVAL() {
|
|
return getToken(HogQLParser::INTERVAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprIntervalContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::IntervalContext* HogQLParser::ColumnExprIntervalContext::interval() {
|
|
return getRuleContext<HogQLParser::IntervalContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprIntervalContext::ColumnExprIntervalContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprInterval(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprIsNullContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprIsNullContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIsNullContext::IS() {
|
|
return getToken(HogQLParser::IS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIsNullContext::NULL_SQL() {
|
|
return getToken(HogQLParser::NULL_SQL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIsNullContext::NOT() {
|
|
return getToken(HogQLParser::NOT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprIsNullContext::ColumnExprIsNullContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprIsNullContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprIsNull(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprWinFunctionTargetContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::ColumnExprWinFunctionTargetContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprWinFunctionTargetContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::OVER() {
|
|
return getToken(HogQLParser::OVER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionTargetContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprWinFunctionTargetContext::ColumnExprWinFunctionTargetContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprWinFunctionTargetContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprWinFunctionTarget(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprTrimContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::TRIM() {
|
|
return getToken(HogQLParser::TRIM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::FROM() {
|
|
return getToken(HogQLParser::FROM, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprTrimContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::BOTH() {
|
|
return getToken(HogQLParser::BOTH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::LEADING() {
|
|
return getToken(HogQLParser::LEADING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTrimContext::TRAILING() {
|
|
return getToken(HogQLParser::TRAILING, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTrimContext::ColumnExprTrimContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTrimContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTrim(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprTagElementContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::HogqlxTagElementContext* HogQLParser::ColumnExprTagElementContext::hogqlxTagElement() {
|
|
return getRuleContext<HogQLParser::HogqlxTagElementContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTagElementContext::ColumnExprTagElementContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTagElementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTagElement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprTupleContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTupleContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprTupleContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTupleContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTupleContext::ColumnExprTupleContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTupleContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTuple(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprArrayAccessContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprArrayAccessContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprArrayAccessContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprArrayAccessContext::LBRACKET() {
|
|
return getToken(HogQLParser::LBRACKET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprArrayAccessContext::RBRACKET() {
|
|
return getToken(HogQLParser::RBRACKET, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprArrayAccessContext::ColumnExprArrayAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprArrayAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprArrayAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprBetweenContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprBetweenContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprBetweenContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprBetweenContext::BETWEEN() {
|
|
return getToken(HogQLParser::BETWEEN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprBetweenContext::AND() {
|
|
return getToken(HogQLParser::AND, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprBetweenContext::NOT() {
|
|
return getToken(HogQLParser::NOT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprBetweenContext::ColumnExprBetweenContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprBetween(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprPropertyAccessContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprPropertyAccessContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprPropertyAccessContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprPropertyAccessContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprPropertyAccessContext::ColumnExprPropertyAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprPropertyAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprPropertyAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprParensContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprParensContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprParensContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprParensContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprParensContext::ColumnExprParensContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprParensContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprParens(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprTimestampContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTimestampContext::TIMESTAMP() {
|
|
return getToken(HogQLParser::TIMESTAMP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTimestampContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTimestampContext::ColumnExprTimestampContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTimestampContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTimestamp(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprNullishContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprNullishContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNullishContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullishContext::NULLISH() {
|
|
return getToken(HogQLParser::NULLISH, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNullishContext::ColumnExprNullishContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNullishContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNullish(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprAndContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprAndContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprAndContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprAndContext::AND() {
|
|
return getToken(HogQLParser::AND, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprAndContext::ColumnExprAndContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprAndContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprAnd(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprTupleAccessContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprTupleAccessContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTupleAccessContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprTupleAccessContext::DECIMAL_LITERAL() {
|
|
return getToken(HogQLParser::DECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTupleAccessContext::ColumnExprTupleAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTupleAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTupleAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprCaseContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCaseContext::CASE() {
|
|
return getToken(HogQLParser::CASE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCaseContext::END() {
|
|
return getToken(HogQLParser::END, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprCaseContext::WHEN() {
|
|
return getTokens(HogQLParser::WHEN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCaseContext::WHEN(size_t i) {
|
|
return getToken(HogQLParser::WHEN, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprCaseContext::THEN() {
|
|
return getTokens(HogQLParser::THEN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCaseContext::THEN(size_t i) {
|
|
return getToken(HogQLParser::THEN, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCaseContext::ELSE() {
|
|
return getToken(HogQLParser::ELSE, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprCaseContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprCaseContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
HogQLParser::ColumnExprCaseContext::ColumnExprCaseContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprCaseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprCase(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprDateContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprDateContext::DATE() {
|
|
return getToken(HogQLParser::DATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprDateContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprDateContext::ColumnExprDateContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprDateContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprDate(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprNotContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNotContext::NOT() {
|
|
return getToken(HogQLParser::NOT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNotContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNotContext::ColumnExprNotContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNotContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNot(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprWinFunctionContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprWinFunctionContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionContext::OVER() {
|
|
return getToken(HogQLParser::OVER, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprWinFunctionContext::LPAREN() {
|
|
return getTokens(HogQLParser::LPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionContext::LPAREN(size_t i) {
|
|
return getToken(HogQLParser::LPAREN, i);
|
|
}
|
|
|
|
HogQLParser::WindowExprContext* HogQLParser::ColumnExprWinFunctionContext::windowExpr() {
|
|
return getRuleContext<HogQLParser::WindowExprContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprWinFunctionContext::RPAREN() {
|
|
return getTokens(HogQLParser::RPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionContext::RPAREN(size_t i) {
|
|
return getToken(HogQLParser::RPAREN, i);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprWinFunctionContext::ColumnExprWinFunctionContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprWinFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprWinFunction(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprIdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnIdentifierContext* HogQLParser::ColumnExprIdentifierContext::columnIdentifier() {
|
|
return getRuleContext<HogQLParser::ColumnIdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprIdentifierContext::ColumnExprIdentifierContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprFunctionContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprFunctionContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprFunctionContext::LPAREN() {
|
|
return getTokens(HogQLParser::LPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprFunctionContext::LPAREN(size_t i) {
|
|
return getToken(HogQLParser::LPAREN, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprFunctionContext::RPAREN() {
|
|
return getTokens(HogQLParser::RPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprFunctionContext::RPAREN(size_t i) {
|
|
return getToken(HogQLParser::RPAREN, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprFunctionContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnArgListContext* HogQLParser::ColumnExprFunctionContext::columnArgList() {
|
|
return getRuleContext<HogQLParser::ColumnArgListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprFunctionContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprFunctionContext::ColumnExprFunctionContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprFunction(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprAsteriskContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprAsteriskContext::ASTERISK() {
|
|
return getToken(HogQLParser::ASTERISK, 0);
|
|
}
|
|
|
|
HogQLParser::TableIdentifierContext* HogQLParser::ColumnExprAsteriskContext::tableIdentifier() {
|
|
return getRuleContext<HogQLParser::TableIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprAsteriskContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprAsteriskContext::ColumnExprAsteriskContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprAsteriskContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprAsterisk(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::columnExpr() {
|
|
return columnExpr(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::columnExpr(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
HogQLParser::ColumnExprContext *_localctx = _tracker.createInstance<ColumnExprContext>(_ctx, parentState);
|
|
HogQLParser::ColumnExprContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 74;
|
|
enterRecursionRule(_localctx, 74, HogQLParser::RuleColumnExpr, 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(668);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<ColumnExprCaseContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(539);
|
|
match(HogQLParser::CASE);
|
|
setState(541);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
|
|
case 1: {
|
|
setState(540);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->caseExpr = columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(548);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(543);
|
|
match(HogQLParser::WHEN);
|
|
setState(544);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->whenExpr = columnExpr(0);
|
|
setState(545);
|
|
match(HogQLParser::THEN);
|
|
setState(546);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->thenExpr = columnExpr(0);
|
|
setState(550);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == HogQLParser::WHEN);
|
|
setState(554);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ELSE) {
|
|
setState(552);
|
|
match(HogQLParser::ELSE);
|
|
setState(553);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->elseExpr = columnExpr(0);
|
|
}
|
|
setState(556);
|
|
match(HogQLParser::END);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<ColumnExprCastContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(558);
|
|
match(HogQLParser::CAST);
|
|
setState(559);
|
|
match(HogQLParser::LPAREN);
|
|
setState(560);
|
|
columnExpr(0);
|
|
setState(561);
|
|
match(HogQLParser::AS);
|
|
setState(562);
|
|
columnTypeExpr();
|
|
setState(563);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<ColumnExprDateContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(565);
|
|
match(HogQLParser::DATE);
|
|
setState(566);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<ColumnExprExtractContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(567);
|
|
match(HogQLParser::EXTRACT);
|
|
setState(568);
|
|
match(HogQLParser::LPAREN);
|
|
setState(569);
|
|
interval();
|
|
setState(570);
|
|
match(HogQLParser::FROM);
|
|
setState(571);
|
|
columnExpr(0);
|
|
setState(572);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<ColumnExprIntervalContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(574);
|
|
match(HogQLParser::INTERVAL);
|
|
setState(575);
|
|
columnExpr(0);
|
|
setState(576);
|
|
interval();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
_localctx = _tracker.createInstance<ColumnExprSubstringContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(578);
|
|
match(HogQLParser::SUBSTRING);
|
|
setState(579);
|
|
match(HogQLParser::LPAREN);
|
|
setState(580);
|
|
columnExpr(0);
|
|
setState(581);
|
|
match(HogQLParser::FROM);
|
|
setState(582);
|
|
columnExpr(0);
|
|
setState(585);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::FOR) {
|
|
setState(583);
|
|
match(HogQLParser::FOR);
|
|
setState(584);
|
|
columnExpr(0);
|
|
}
|
|
setState(587);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
_localctx = _tracker.createInstance<ColumnExprTimestampContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(589);
|
|
match(HogQLParser::TIMESTAMP);
|
|
setState(590);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
_localctx = _tracker.createInstance<ColumnExprTrimContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(591);
|
|
match(HogQLParser::TRIM);
|
|
setState(592);
|
|
match(HogQLParser::LPAREN);
|
|
setState(593);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::BOTH || _la == HogQLParser::LEADING || _la == HogQLParser::TRAILING)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(594);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
setState(595);
|
|
match(HogQLParser::FROM);
|
|
setState(596);
|
|
columnExpr(0);
|
|
setState(597);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
_localctx = _tracker.createInstance<ColumnExprWinFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(599);
|
|
identifier();
|
|
|
|
setState(600);
|
|
match(HogQLParser::LPAREN);
|
|
setState(602);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(601);
|
|
columnExprList();
|
|
}
|
|
setState(604);
|
|
match(HogQLParser::RPAREN);
|
|
setState(606);
|
|
match(HogQLParser::OVER);
|
|
setState(607);
|
|
match(HogQLParser::LPAREN);
|
|
setState(608);
|
|
windowExpr();
|
|
setState(609);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
_localctx = _tracker.createInstance<ColumnExprWinFunctionTargetContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(611);
|
|
identifier();
|
|
|
|
setState(612);
|
|
match(HogQLParser::LPAREN);
|
|
setState(614);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(613);
|
|
columnExprList();
|
|
}
|
|
setState(616);
|
|
match(HogQLParser::RPAREN);
|
|
setState(618);
|
|
match(HogQLParser::OVER);
|
|
setState(619);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
_localctx = _tracker.createInstance<ColumnExprFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(621);
|
|
identifier();
|
|
setState(627);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
|
|
case 1: {
|
|
setState(622);
|
|
match(HogQLParser::LPAREN);
|
|
setState(624);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(623);
|
|
columnExprList();
|
|
}
|
|
setState(626);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(629);
|
|
match(HogQLParser::LPAREN);
|
|
setState(631);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
|
|
case 1: {
|
|
setState(630);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(634);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(633);
|
|
columnArgList();
|
|
}
|
|
setState(636);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
_localctx = _tracker.createInstance<ColumnExprTagElementContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(638);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
_localctx = _tracker.createInstance<ColumnExprLiteralContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(639);
|
|
literal();
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
_localctx = _tracker.createInstance<ColumnExprNegateContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(640);
|
|
match(HogQLParser::DASH);
|
|
setState(641);
|
|
columnExpr(18);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
_localctx = _tracker.createInstance<ColumnExprNotContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(642);
|
|
match(HogQLParser::NOT);
|
|
setState(643);
|
|
columnExpr(12);
|
|
break;
|
|
}
|
|
|
|
case 16: {
|
|
_localctx = _tracker.createInstance<ColumnExprAsteriskContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(647);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE
|
|
|
|
|| _la == HogQLParser::IDENTIFIER) {
|
|
setState(644);
|
|
tableIdentifier();
|
|
setState(645);
|
|
match(HogQLParser::DOT);
|
|
}
|
|
setState(649);
|
|
match(HogQLParser::ASTERISK);
|
|
break;
|
|
}
|
|
|
|
case 17: {
|
|
_localctx = _tracker.createInstance<ColumnExprSubqueryContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(650);
|
|
match(HogQLParser::LPAREN);
|
|
setState(651);
|
|
selectUnionStmt();
|
|
setState(652);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 18: {
|
|
_localctx = _tracker.createInstance<ColumnExprParensContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(654);
|
|
match(HogQLParser::LPAREN);
|
|
setState(655);
|
|
columnExpr(0);
|
|
setState(656);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 19: {
|
|
_localctx = _tracker.createInstance<ColumnExprTupleContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(658);
|
|
match(HogQLParser::LPAREN);
|
|
setState(659);
|
|
columnExprList();
|
|
setState(660);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 20: {
|
|
_localctx = _tracker.createInstance<ColumnExprArrayContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(662);
|
|
match(HogQLParser::LBRACKET);
|
|
setState(664);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(663);
|
|
columnExprList();
|
|
}
|
|
setState(666);
|
|
match(HogQLParser::RBRACKET);
|
|
break;
|
|
}
|
|
|
|
case 21: {
|
|
_localctx = _tracker.createInstance<ColumnExprIdentifierContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(667);
|
|
columnIdentifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(763);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(761);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
|
|
case 1: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence1Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(670);
|
|
|
|
if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)");
|
|
setState(674);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::ASTERISK: {
|
|
setState(671);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::ASTERISK);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::SLASH: {
|
|
setState(672);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::SLASH);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::PERCENT: {
|
|
setState(673);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::PERCENT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(676);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->right = columnExpr(18);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence2Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(677);
|
|
|
|
if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
|
|
setState(681);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::PLUS: {
|
|
setState(678);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::PLUS);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DASH: {
|
|
setState(679);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::DASH);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::CONCAT: {
|
|
setState(680);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::CONCAT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(683);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->right = columnExpr(17);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence3Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(684);
|
|
|
|
if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)");
|
|
setState(709);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
|
|
case 1: {
|
|
setState(685);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::EQ_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(686);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::EQ_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(687);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(688);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::LT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(689);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::LT);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
setState(690);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::GT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
setState(691);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::GT);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
setState(693);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(692);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT);
|
|
}
|
|
setState(695);
|
|
match(HogQLParser::IN);
|
|
setState(697);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COHORT) {
|
|
setState(696);
|
|
match(HogQLParser::COHORT);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
setState(700);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(699);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT);
|
|
}
|
|
setState(702);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::ILIKE
|
|
|
|
|| _la == HogQLParser::LIKE)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
setState(703);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::REGEX_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
setState(704);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::REGEX_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
setState(705);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_REGEX);
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
setState(706);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::IREGEX_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
setState(707);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::IREGEX_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
setState(708);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_IREGEX);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(711);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->right = columnExpr(16);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
auto newContext = _tracker.createInstance<ColumnExprNullishContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(712);
|
|
|
|
if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
|
|
setState(713);
|
|
match(HogQLParser::NULLISH);
|
|
setState(714);
|
|
columnExpr(14);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
auto newContext = _tracker.createInstance<ColumnExprAndContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(715);
|
|
|
|
if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)");
|
|
setState(716);
|
|
match(HogQLParser::AND);
|
|
setState(717);
|
|
columnExpr(12);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
auto newContext = _tracker.createInstance<ColumnExprOrContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(718);
|
|
|
|
if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(719);
|
|
match(HogQLParser::OR);
|
|
setState(720);
|
|
columnExpr(11);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
auto newContext = _tracker.createInstance<ColumnExprBetweenContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(721);
|
|
|
|
if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)");
|
|
setState(723);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(722);
|
|
match(HogQLParser::NOT);
|
|
}
|
|
setState(725);
|
|
match(HogQLParser::BETWEEN);
|
|
setState(726);
|
|
columnExpr(0);
|
|
setState(727);
|
|
match(HogQLParser::AND);
|
|
setState(728);
|
|
columnExpr(10);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
auto newContext = _tracker.createInstance<ColumnExprTernaryOpContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(730);
|
|
|
|
if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
|
|
setState(731);
|
|
match(HogQLParser::QUERY);
|
|
setState(732);
|
|
columnExpr(0);
|
|
setState(733);
|
|
match(HogQLParser::COLON);
|
|
setState(734);
|
|
columnExpr(8);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
auto newContext = _tracker.createInstance<ColumnExprArrayAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(736);
|
|
|
|
if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)");
|
|
setState(737);
|
|
match(HogQLParser::LBRACKET);
|
|
setState(738);
|
|
columnExpr(0);
|
|
setState(739);
|
|
match(HogQLParser::RBRACKET);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
auto newContext = _tracker.createInstance<ColumnExprTupleAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(741);
|
|
|
|
if (!(precpred(_ctx, 20))) throw FailedPredicateException(this, "precpred(_ctx, 20)");
|
|
setState(742);
|
|
match(HogQLParser::DOT);
|
|
setState(743);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPropertyAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(744);
|
|
|
|
if (!(precpred(_ctx, 19))) throw FailedPredicateException(this, "precpred(_ctx, 19)");
|
|
setState(745);
|
|
match(HogQLParser::DOT);
|
|
setState(746);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
auto newContext = _tracker.createInstance<ColumnExprIsNullContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(747);
|
|
|
|
if (!(precpred(_ctx, 14))) throw FailedPredicateException(this, "precpred(_ctx, 14)");
|
|
setState(748);
|
|
match(HogQLParser::IS);
|
|
setState(750);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(749);
|
|
match(HogQLParser::NOT);
|
|
}
|
|
setState(752);
|
|
match(HogQLParser::NULL_SQL);
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
auto newContext = _tracker.createInstance<ColumnExprAliasContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(753);
|
|
|
|
if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(759);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
|
|
case 1: {
|
|
setState(754);
|
|
alias();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(755);
|
|
match(HogQLParser::AS);
|
|
setState(756);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(757);
|
|
match(HogQLParser::AS);
|
|
setState(758);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
setState(765);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnArgListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnArgListContext::ColumnArgListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnArgExprContext *> HogQLParser::ColumnArgListContext::columnArgExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnArgExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnArgExprContext* HogQLParser::ColumnArgListContext::columnArgExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnArgExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnArgListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnArgListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnArgListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnArgList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ColumnArgListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnArgList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnArgListContext* HogQLParser::columnArgList() {
|
|
ColumnArgListContext *_localctx = _tracker.createInstance<ColumnArgListContext>(_ctx, getState());
|
|
enterRule(_localctx, 76, HogQLParser::RuleColumnArgList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(766);
|
|
columnArgExpr();
|
|
setState(771);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(767);
|
|
match(HogQLParser::COMMA);
|
|
setState(768);
|
|
columnArgExpr();
|
|
setState(773);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ColumnArgExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnArgExprContext::ColumnArgExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ColumnLambdaExprContext* HogQLParser::ColumnArgExprContext::columnLambdaExpr() {
|
|
return getRuleContext<HogQLParser::ColumnLambdaExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnArgExprContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnArgExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnArgExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ColumnArgExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnArgExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnArgExprContext* HogQLParser::columnArgExpr() {
|
|
ColumnArgExprContext *_localctx = _tracker.createInstance<ColumnArgExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 78, HogQLParser::RuleColumnArgExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(776);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(774);
|
|
columnLambdaExpr();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(775);
|
|
columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnLambdaExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnLambdaExprContext::ColumnLambdaExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnLambdaExprContext::ARROW() {
|
|
return getToken(HogQLParser::ARROW, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnLambdaExprContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnLambdaExprContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::ColumnLambdaExprContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnLambdaExprContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnLambdaExprContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnLambdaExprContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnLambdaExprContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnLambdaExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnLambdaExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ColumnLambdaExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnLambdaExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnLambdaExprContext* HogQLParser::columnLambdaExpr() {
|
|
ColumnLambdaExprContext *_localctx = _tracker.createInstance<ColumnLambdaExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 80, HogQLParser::RuleColumnLambdaExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(797);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LPAREN: {
|
|
setState(778);
|
|
match(HogQLParser::LPAREN);
|
|
setState(779);
|
|
identifier();
|
|
setState(784);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(780);
|
|
match(HogQLParser::COMMA);
|
|
setState(781);
|
|
identifier();
|
|
setState(786);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(787);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::AFTER:
|
|
case HogQLParser::ALIAS:
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::ALTER:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::AST:
|
|
case HogQLParser::ASYNC:
|
|
case HogQLParser::ATTACH:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::CHECK:
|
|
case HogQLParser::CLEAR:
|
|
case HogQLParser::CLUSTER:
|
|
case HogQLParser::CODEC:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::COLUMN:
|
|
case HogQLParser::COMMENT:
|
|
case HogQLParser::CONSTRAINT:
|
|
case HogQLParser::CREATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATABASE:
|
|
case HogQLParser::DATABASES:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DAY:
|
|
case HogQLParser::DEDUPLICATE:
|
|
case HogQLParser::DEFAULT:
|
|
case HogQLParser::DELAY:
|
|
case HogQLParser::DELETE:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DESCRIBE:
|
|
case HogQLParser::DETACH:
|
|
case HogQLParser::DICTIONARIES:
|
|
case HogQLParser::DICTIONARY:
|
|
case HogQLParser::DISK:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::DISTRIBUTED:
|
|
case HogQLParser::DROP:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::ENGINE:
|
|
case HogQLParser::EVENTS:
|
|
case HogQLParser::EXISTS:
|
|
case HogQLParser::EXPLAIN:
|
|
case HogQLParser::EXPRESSION:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FETCHES:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FLUSH:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FORMAT:
|
|
case HogQLParser::FREEZE:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::FUNCTION:
|
|
case HogQLParser::GLOBAL:
|
|
case HogQLParser::GRANULARITY:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::HIERARCHICAL:
|
|
case HogQLParser::HOUR:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INDEX:
|
|
case HogQLParser::INJECTIVE:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INSERT:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::INTO:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::IS_OBJECT_ID:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::KILL:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LAYOUT:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIFETIME:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::LIVE:
|
|
case HogQLParser::LOCAL:
|
|
case HogQLParser::LOGS:
|
|
case HogQLParser::MATERIALIZE:
|
|
case HogQLParser::MATERIALIZED:
|
|
case HogQLParser::MAX:
|
|
case HogQLParser::MERGES:
|
|
case HogQLParser::MIN:
|
|
case HogQLParser::MINUTE:
|
|
case HogQLParser::MODIFY:
|
|
case HogQLParser::MONTH:
|
|
case HogQLParser::MOVE:
|
|
case HogQLParser::MUTATION:
|
|
case HogQLParser::NO:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OPTIMIZE:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OUTFILE:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::POPULATE:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::PRIMARY:
|
|
case HogQLParser::QUARTER:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RELOAD:
|
|
case HogQLParser::REMOVE:
|
|
case HogQLParser::RENAME:
|
|
case HogQLParser::REPLACE:
|
|
case HogQLParser::REPLICA:
|
|
case HogQLParser::REPLICATED:
|
|
case HogQLParser::RIGHT:
|
|
case HogQLParser::ROLLUP:
|
|
case HogQLParser::ROW:
|
|
case HogQLParser::ROWS:
|
|
case HogQLParser::SAMPLE:
|
|
case HogQLParser::SECOND:
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::SEMI:
|
|
case HogQLParser::SENDS:
|
|
case HogQLParser::SET:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::SHOW:
|
|
case HogQLParser::SOURCE:
|
|
case HogQLParser::START:
|
|
case HogQLParser::STOP:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::SYNC:
|
|
case HogQLParser::SYNTAX:
|
|
case HogQLParser::SYSTEM:
|
|
case HogQLParser::TABLE:
|
|
case HogQLParser::TABLES:
|
|
case HogQLParser::TEMPORARY:
|
|
case HogQLParser::TEST:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMEOUT:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::TTL:
|
|
case HogQLParser::TYPE:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::UPDATE:
|
|
case HogQLParser::USE:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::UUID:
|
|
case HogQLParser::VALUES:
|
|
case HogQLParser::VIEW:
|
|
case HogQLParser::VOLUME:
|
|
case HogQLParser::WATCH:
|
|
case HogQLParser::WEEK:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH:
|
|
case HogQLParser::YEAR:
|
|
case HogQLParser::JSON_FALSE:
|
|
case HogQLParser::JSON_TRUE:
|
|
case HogQLParser::IDENTIFIER: {
|
|
setState(789);
|
|
identifier();
|
|
setState(794);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(790);
|
|
match(HogQLParser::COMMA);
|
|
setState(791);
|
|
identifier();
|
|
setState(796);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(799);
|
|
match(HogQLParser::ARROW);
|
|
setState(800);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- HogqlxTagElementContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::HogqlxTagElementContext::HogqlxTagElementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::HogqlxTagElementContext::getRuleIndex() const {
|
|
return HogQLParser::RuleHogqlxTagElement;
|
|
}
|
|
|
|
void HogQLParser::HogqlxTagElementContext::copyFrom(HogqlxTagElementContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- HogqlxTagElementClosedContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::LT() {
|
|
return getToken(HogQLParser::LT, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::HogqlxTagElementClosedContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::SLASH() {
|
|
return getToken(HogQLParser::SLASH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::GT() {
|
|
return getToken(HogQLParser::GT, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::HogqlxTagAttributeContext *> HogQLParser::HogqlxTagElementClosedContext::hogqlxTagAttribute() {
|
|
return getRuleContexts<HogQLParser::HogqlxTagAttributeContext>();
|
|
}
|
|
|
|
HogQLParser::HogqlxTagAttributeContext* HogQLParser::HogqlxTagElementClosedContext::hogqlxTagAttribute(size_t i) {
|
|
return getRuleContext<HogQLParser::HogqlxTagAttributeContext>(i);
|
|
}
|
|
|
|
HogQLParser::HogqlxTagElementClosedContext::HogqlxTagElementClosedContext(HogqlxTagElementContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::HogqlxTagElementClosedContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitHogqlxTagElementClosed(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- HogqlxTagElementNestedContext ------------------------------------------------------------------
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::HogqlxTagElementNestedContext::LT() {
|
|
return getTokens(HogQLParser::LT);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::LT(size_t i) {
|
|
return getToken(HogQLParser::LT, i);
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::HogqlxTagElementNestedContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::HogqlxTagElementNestedContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::HogqlxTagElementNestedContext::GT() {
|
|
return getTokens(HogQLParser::GT);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::GT(size_t i) {
|
|
return getToken(HogQLParser::GT, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::SLASH() {
|
|
return getToken(HogQLParser::SLASH, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::HogqlxTagAttributeContext *> HogQLParser::HogqlxTagElementNestedContext::hogqlxTagAttribute() {
|
|
return getRuleContexts<HogQLParser::HogqlxTagAttributeContext>();
|
|
}
|
|
|
|
HogQLParser::HogqlxTagAttributeContext* HogQLParser::HogqlxTagElementNestedContext::hogqlxTagAttribute(size_t i) {
|
|
return getRuleContext<HogQLParser::HogqlxTagAttributeContext>(i);
|
|
}
|
|
|
|
HogQLParser::HogqlxTagElementContext* HogQLParser::HogqlxTagElementNestedContext::hogqlxTagElement() {
|
|
return getRuleContext<HogQLParser::HogqlxTagElementContext>(0);
|
|
}
|
|
|
|
HogQLParser::HogqlxTagElementNestedContext::HogqlxTagElementNestedContext(HogqlxTagElementContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::HogqlxTagElementNestedContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitHogqlxTagElementNested(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
HogQLParser::HogqlxTagElementContext* HogQLParser::hogqlxTagElement() {
|
|
HogqlxTagElementContext *_localctx = _tracker.createInstance<HogqlxTagElementContext>(_ctx, getState());
|
|
enterRule(_localctx, 82, HogQLParser::RuleHogqlxTagElement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(830);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::HogqlxTagElementClosedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(802);
|
|
match(HogQLParser::LT);
|
|
setState(803);
|
|
identifier();
|
|
setState(807);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE
|
|
|
|
|| _la == HogQLParser::IDENTIFIER) {
|
|
setState(804);
|
|
hogqlxTagAttribute();
|
|
setState(809);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(810);
|
|
match(HogQLParser::SLASH);
|
|
setState(811);
|
|
match(HogQLParser::GT);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::HogqlxTagElementNestedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(813);
|
|
match(HogQLParser::LT);
|
|
setState(814);
|
|
identifier();
|
|
setState(818);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE
|
|
|
|
|| _la == HogQLParser::IDENTIFIER) {
|
|
setState(815);
|
|
hogqlxTagAttribute();
|
|
setState(820);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(821);
|
|
match(HogQLParser::GT);
|
|
setState(823);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx)) {
|
|
case 1: {
|
|
setState(822);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(825);
|
|
match(HogQLParser::LT);
|
|
setState(826);
|
|
match(HogQLParser::SLASH);
|
|
setState(827);
|
|
identifier();
|
|
setState(828);
|
|
match(HogQLParser::GT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- HogqlxTagAttributeContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::HogqlxTagAttributeContext::HogqlxTagAttributeContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::HogqlxTagAttributeContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::LBRACE() {
|
|
return getToken(HogQLParser::LBRACE, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::HogqlxTagAttributeContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::HogqlxTagAttributeContext::getRuleIndex() const {
|
|
return HogQLParser::RuleHogqlxTagAttribute;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::HogqlxTagAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitHogqlxTagAttribute(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::HogqlxTagAttributeContext* HogQLParser::hogqlxTagAttribute() {
|
|
HogqlxTagAttributeContext *_localctx = _tracker.createInstance<HogqlxTagAttributeContext>(_ctx, getState());
|
|
enterRule(_localctx, 84, HogQLParser::RuleHogqlxTagAttribute);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(843);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(832);
|
|
identifier();
|
|
setState(833);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(834);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(836);
|
|
identifier();
|
|
setState(837);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(838);
|
|
match(HogQLParser::LBRACE);
|
|
setState(839);
|
|
columnExpr(0);
|
|
setState(840);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(842);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WithExprListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WithExprListContext::WithExprListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::WithExprContext *> HogQLParser::WithExprListContext::withExpr() {
|
|
return getRuleContexts<HogQLParser::WithExprContext>();
|
|
}
|
|
|
|
HogQLParser::WithExprContext* HogQLParser::WithExprListContext::withExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::WithExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::WithExprListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithExprListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WithExprListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWithExprList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WithExprListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWithExprList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WithExprListContext* HogQLParser::withExprList() {
|
|
WithExprListContext *_localctx = _tracker.createInstance<WithExprListContext>(_ctx, getState());
|
|
enterRule(_localctx, 86, HogQLParser::RuleWithExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(845);
|
|
withExpr();
|
|
setState(850);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(846);
|
|
match(HogQLParser::COMMA);
|
|
setState(847);
|
|
withExpr();
|
|
setState(852);
|
|
_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;
|
|
}
|
|
|
|
//----------------- WithExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WithExprContext::WithExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WithExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWithExpr;
|
|
}
|
|
|
|
void HogQLParser::WithExprContext::copyFrom(WithExprContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- WithExprColumnContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::WithExprColumnContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithExprColumnContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::WithExprColumnContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::WithExprColumnContext::WithExprColumnContext(WithExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::WithExprColumnContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWithExprColumn(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- WithExprSubqueryContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::WithExprSubqueryContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithExprSubqueryContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithExprSubqueryContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::WithExprSubqueryContext::selectUnionStmt() {
|
|
return getRuleContext<HogQLParser::SelectUnionStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WithExprSubqueryContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::WithExprSubqueryContext::WithExprSubqueryContext(WithExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::WithExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWithExprSubquery(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
HogQLParser::WithExprContext* HogQLParser::withExpr() {
|
|
WithExprContext *_localctx = _tracker.createInstance<WithExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 88, HogQLParser::RuleWithExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(863);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::WithExprSubqueryContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(853);
|
|
identifier();
|
|
setState(854);
|
|
match(HogQLParser::AS);
|
|
setState(855);
|
|
match(HogQLParser::LPAREN);
|
|
setState(856);
|
|
selectUnionStmt();
|
|
setState(857);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::WithExprColumnContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(859);
|
|
columnExpr(0);
|
|
setState(860);
|
|
match(HogQLParser::AS);
|
|
setState(861);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ColumnIdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnIdentifierContext::ColumnIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::PlaceholderContext* HogQLParser::ColumnIdentifierContext::placeholder() {
|
|
return getRuleContext<HogQLParser::PlaceholderContext>(0);
|
|
}
|
|
|
|
HogQLParser::NestedIdentifierContext* HogQLParser::ColumnIdentifierContext::nestedIdentifier() {
|
|
return getRuleContext<HogQLParser::NestedIdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableIdentifierContext* HogQLParser::ColumnIdentifierContext::tableIdentifier() {
|
|
return getRuleContext<HogQLParser::TableIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnIdentifierContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ColumnIdentifierContext::getRuleIndex() const {
|
|
return HogQLParser::RuleColumnIdentifier;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ColumnIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ColumnIdentifierContext* HogQLParser::columnIdentifier() {
|
|
ColumnIdentifierContext *_localctx = _tracker.createInstance<ColumnIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 90, HogQLParser::RuleColumnIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(872);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(865);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::AFTER:
|
|
case HogQLParser::ALIAS:
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::ALTER:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::AST:
|
|
case HogQLParser::ASYNC:
|
|
case HogQLParser::ATTACH:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::CHECK:
|
|
case HogQLParser::CLEAR:
|
|
case HogQLParser::CLUSTER:
|
|
case HogQLParser::CODEC:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::COLUMN:
|
|
case HogQLParser::COMMENT:
|
|
case HogQLParser::CONSTRAINT:
|
|
case HogQLParser::CREATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATABASE:
|
|
case HogQLParser::DATABASES:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DAY:
|
|
case HogQLParser::DEDUPLICATE:
|
|
case HogQLParser::DEFAULT:
|
|
case HogQLParser::DELAY:
|
|
case HogQLParser::DELETE:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DESCRIBE:
|
|
case HogQLParser::DETACH:
|
|
case HogQLParser::DICTIONARIES:
|
|
case HogQLParser::DICTIONARY:
|
|
case HogQLParser::DISK:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::DISTRIBUTED:
|
|
case HogQLParser::DROP:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::ENGINE:
|
|
case HogQLParser::EVENTS:
|
|
case HogQLParser::EXISTS:
|
|
case HogQLParser::EXPLAIN:
|
|
case HogQLParser::EXPRESSION:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FETCHES:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FLUSH:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FORMAT:
|
|
case HogQLParser::FREEZE:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::FUNCTION:
|
|
case HogQLParser::GLOBAL:
|
|
case HogQLParser::GRANULARITY:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::HIERARCHICAL:
|
|
case HogQLParser::HOUR:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INDEX:
|
|
case HogQLParser::INJECTIVE:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INSERT:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::INTO:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::IS_OBJECT_ID:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::KILL:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LAYOUT:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIFETIME:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::LIVE:
|
|
case HogQLParser::LOCAL:
|
|
case HogQLParser::LOGS:
|
|
case HogQLParser::MATERIALIZE:
|
|
case HogQLParser::MATERIALIZED:
|
|
case HogQLParser::MAX:
|
|
case HogQLParser::MERGES:
|
|
case HogQLParser::MIN:
|
|
case HogQLParser::MINUTE:
|
|
case HogQLParser::MODIFY:
|
|
case HogQLParser::MONTH:
|
|
case HogQLParser::MOVE:
|
|
case HogQLParser::MUTATION:
|
|
case HogQLParser::NO:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OPTIMIZE:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OUTFILE:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::POPULATE:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::PRIMARY:
|
|
case HogQLParser::QUARTER:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RELOAD:
|
|
case HogQLParser::REMOVE:
|
|
case HogQLParser::RENAME:
|
|
case HogQLParser::REPLACE:
|
|
case HogQLParser::REPLICA:
|
|
case HogQLParser::REPLICATED:
|
|
case HogQLParser::RIGHT:
|
|
case HogQLParser::ROLLUP:
|
|
case HogQLParser::ROW:
|
|
case HogQLParser::ROWS:
|
|
case HogQLParser::SAMPLE:
|
|
case HogQLParser::SECOND:
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::SEMI:
|
|
case HogQLParser::SENDS:
|
|
case HogQLParser::SET:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::SHOW:
|
|
case HogQLParser::SOURCE:
|
|
case HogQLParser::START:
|
|
case HogQLParser::STOP:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::SYNC:
|
|
case HogQLParser::SYNTAX:
|
|
case HogQLParser::SYSTEM:
|
|
case HogQLParser::TABLE:
|
|
case HogQLParser::TABLES:
|
|
case HogQLParser::TEMPORARY:
|
|
case HogQLParser::TEST:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMEOUT:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::TTL:
|
|
case HogQLParser::TYPE:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::UPDATE:
|
|
case HogQLParser::USE:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::UUID:
|
|
case HogQLParser::VALUES:
|
|
case HogQLParser::VIEW:
|
|
case HogQLParser::VOLUME:
|
|
case HogQLParser::WATCH:
|
|
case HogQLParser::WEEK:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH:
|
|
case HogQLParser::YEAR:
|
|
case HogQLParser::JSON_FALSE:
|
|
case HogQLParser::JSON_TRUE:
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(869);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx)) {
|
|
case 1: {
|
|
setState(866);
|
|
tableIdentifier();
|
|
setState(867);
|
|
match(HogQLParser::DOT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(871);
|
|
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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::NestedIdentifierContext::NestedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::NestedIdentifierContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::NestedIdentifierContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::NestedIdentifierContext::DOT() {
|
|
return getTokens(HogQLParser::DOT);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NestedIdentifierContext::DOT(size_t i) {
|
|
return getToken(HogQLParser::DOT, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::NestedIdentifierContext::getRuleIndex() const {
|
|
return HogQLParser::RuleNestedIdentifier;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::NestedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitNestedIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::NestedIdentifierContext* HogQLParser::nestedIdentifier() {
|
|
NestedIdentifierContext *_localctx = _tracker.createInstance<NestedIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 92, HogQLParser::RuleNestedIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(874);
|
|
identifier();
|
|
setState(879);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(875);
|
|
match(HogQLParser::DOT);
|
|
setState(876);
|
|
identifier();
|
|
}
|
|
setState(881);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TableExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableExprContext::TableExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TableExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTableExpr;
|
|
}
|
|
|
|
void HogQLParser::TableExprContext::copyFrom(TableExprContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- TableExprTagContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::HogqlxTagElementContext* HogQLParser::TableExprTagContext::hogqlxTagElement() {
|
|
return getRuleContext<HogQLParser::HogqlxTagElementContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableExprTagContext::TableExprTagContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprTagContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprTag(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TableExprIdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableIdentifierContext* HogQLParser::TableExprIdentifierContext::tableIdentifier() {
|
|
return getRuleContext<HogQLParser::TableIdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableExprIdentifierContext::TableExprIdentifierContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TableExprPlaceholderContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::PlaceholderContext* HogQLParser::TableExprPlaceholderContext::placeholder() {
|
|
return getRuleContext<HogQLParser::PlaceholderContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableExprPlaceholderContext::TableExprPlaceholderContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprPlaceholderContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprPlaceholder(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TableExprSubqueryContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::TableExprSubqueryContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::SelectUnionStmtContext* HogQLParser::TableExprSubqueryContext::selectUnionStmt() {
|
|
return getRuleContext<HogQLParser::SelectUnionStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableExprSubqueryContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::TableExprSubqueryContext::TableExprSubqueryContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprSubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprSubquery(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TableExprAliasContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableExprContext* HogQLParser::TableExprAliasContext::tableExpr() {
|
|
return getRuleContext<HogQLParser::TableExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::AliasContext* HogQLParser::TableExprAliasContext::alias() {
|
|
return getRuleContext<HogQLParser::AliasContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableExprAliasContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::TableExprAliasContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableExprAliasContext::TableExprAliasContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprAliasContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprAlias(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TableExprFunctionContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableFunctionExprContext* HogQLParser::TableExprFunctionContext::tableFunctionExpr() {
|
|
return getRuleContext<HogQLParser::TableFunctionExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::TableExprFunctionContext::TableExprFunctionContext(TableExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::TableExprFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableExprFunction(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TableExprContext* HogQLParser::tableExpr() {
|
|
return tableExpr(0);
|
|
}
|
|
|
|
HogQLParser::TableExprContext* HogQLParser::tableExpr(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
HogQLParser::TableExprContext *_localctx = _tracker.createInstance<TableExprContext>(_ctx, parentState);
|
|
HogQLParser::TableExprContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 94;
|
|
enterRecursionRule(_localctx, 94, HogQLParser::RuleTableExpr, precedence);
|
|
|
|
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
unrollRecursionContexts(parentContext);
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(891);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<TableExprIdentifierContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(883);
|
|
tableIdentifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<TableExprFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(884);
|
|
tableFunctionExpr();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<TableExprSubqueryContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(885);
|
|
match(HogQLParser::LPAREN);
|
|
setState(886);
|
|
selectUnionStmt();
|
|
setState(887);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<TableExprTagContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(889);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<TableExprPlaceholderContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(890);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(901);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
auto newContext = _tracker.createInstance<TableExprAliasContext>(_tracker.createInstance<TableExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleTableExpr);
|
|
setState(893);
|
|
|
|
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(897);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::IDENTIFIER: {
|
|
setState(894);
|
|
alias();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::AS: {
|
|
setState(895);
|
|
match(HogQLParser::AS);
|
|
setState(896);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
}
|
|
setState(903);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TableFunctionExprContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableFunctionExprContext::TableFunctionExprContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::TableFunctionExprContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableFunctionExprContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableFunctionExprContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::TableArgListContext* HogQLParser::TableFunctionExprContext::tableArgList() {
|
|
return getRuleContext<HogQLParser::TableArgListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TableFunctionExprContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTableFunctionExpr;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TableFunctionExprContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableFunctionExpr(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TableFunctionExprContext* HogQLParser::tableFunctionExpr() {
|
|
TableFunctionExprContext *_localctx = _tracker.createInstance<TableFunctionExprContext>(_ctx, getState());
|
|
enterRule(_localctx, 96, HogQLParser::RuleTableFunctionExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(904);
|
|
identifier();
|
|
setState(905);
|
|
match(HogQLParser::LPAREN);
|
|
setState(907);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 192)) & 70263309817) != 0)) {
|
|
setState(906);
|
|
tableArgList();
|
|
}
|
|
setState(909);
|
|
match(HogQLParser::RPAREN);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TableIdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableIdentifierContext::TableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::TableIdentifierContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::DatabaseIdentifierContext* HogQLParser::TableIdentifierContext::databaseIdentifier() {
|
|
return getRuleContext<HogQLParser::DatabaseIdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableIdentifierContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TableIdentifierContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTableIdentifier;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TableIdentifierContext* HogQLParser::tableIdentifier() {
|
|
TableIdentifierContext *_localctx = _tracker.createInstance<TableIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 98, HogQLParser::RuleTableIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(914);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx)) {
|
|
case 1: {
|
|
setState(911);
|
|
databaseIdentifier();
|
|
setState(912);
|
|
match(HogQLParser::DOT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(916);
|
|
identifier();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TableArgListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TableArgListContext::TableArgListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::TableArgListContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::TableArgListContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::TableArgListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TableArgListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TableArgListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTableArgList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TableArgListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTableArgList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TableArgListContext* HogQLParser::tableArgList() {
|
|
TableArgListContext *_localctx = _tracker.createInstance<TableArgListContext>(_ctx, getState());
|
|
enterRule(_localctx, 100, HogQLParser::RuleTableArgList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(918);
|
|
columnExpr(0);
|
|
setState(923);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(919);
|
|
match(HogQLParser::COMMA);
|
|
setState(920);
|
|
columnExpr(0);
|
|
setState(925);
|
|
_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;
|
|
}
|
|
|
|
//----------------- DatabaseIdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::DatabaseIdentifierContext::DatabaseIdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::DatabaseIdentifierContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::DatabaseIdentifierContext::getRuleIndex() const {
|
|
return HogQLParser::RuleDatabaseIdentifier;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::DatabaseIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitDatabaseIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::DatabaseIdentifierContext* HogQLParser::databaseIdentifier() {
|
|
DatabaseIdentifierContext *_localctx = _tracker.createInstance<DatabaseIdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 102, HogQLParser::RuleDatabaseIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(926);
|
|
identifier();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FloatingLiteralContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::FloatingLiteralContext::FloatingLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FloatingLiteralContext::FLOATING_LITERAL() {
|
|
return getToken(HogQLParser::FLOATING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FloatingLiteralContext::DOT() {
|
|
return getToken(HogQLParser::DOT, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::FloatingLiteralContext::DECIMAL_LITERAL() {
|
|
return getTokens(HogQLParser::DECIMAL_LITERAL);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FloatingLiteralContext::DECIMAL_LITERAL(size_t i) {
|
|
return getToken(HogQLParser::DECIMAL_LITERAL, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FloatingLiteralContext::OCTAL_LITERAL() {
|
|
return getToken(HogQLParser::OCTAL_LITERAL, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::FloatingLiteralContext::getRuleIndex() const {
|
|
return HogQLParser::RuleFloatingLiteral;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::FloatingLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFloatingLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::FloatingLiteralContext* HogQLParser::floatingLiteral() {
|
|
FloatingLiteralContext *_localctx = _tracker.createInstance<FloatingLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 104, HogQLParser::RuleFloatingLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(936);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::FLOATING_LITERAL: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(928);
|
|
match(HogQLParser::FLOATING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DOT: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(929);
|
|
match(HogQLParser::DOT);
|
|
setState(930);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::OCTAL_LITERAL
|
|
|
|
|| _la == HogQLParser::DECIMAL_LITERAL)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DECIMAL_LITERAL: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(931);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
setState(932);
|
|
match(HogQLParser::DOT);
|
|
setState(934);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
|
|
case 1: {
|
|
setState(933);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::OCTAL_LITERAL
|
|
|
|
|| _la == HogQLParser::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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::FloatingLiteralContext* HogQLParser::NumberLiteralContext::floatingLiteral() {
|
|
return getRuleContext<HogQLParser::FloatingLiteralContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::OCTAL_LITERAL() {
|
|
return getToken(HogQLParser::OCTAL_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::DECIMAL_LITERAL() {
|
|
return getToken(HogQLParser::DECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::HEXADECIMAL_LITERAL() {
|
|
return getToken(HogQLParser::HEXADECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::INF() {
|
|
return getToken(HogQLParser::INF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::NAN_SQL() {
|
|
return getToken(HogQLParser::NAN_SQL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::PLUS() {
|
|
return getToken(HogQLParser::PLUS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::NumberLiteralContext::DASH() {
|
|
return getToken(HogQLParser::DASH, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::NumberLiteralContext::getRuleIndex() const {
|
|
return HogQLParser::RuleNumberLiteral;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitNumberLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::NumberLiteralContext* HogQLParser::numberLiteral() {
|
|
NumberLiteralContext *_localctx = _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 106, HogQLParser::RuleNumberLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(939);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::DASH
|
|
|
|
|| _la == HogQLParser::PLUS) {
|
|
setState(938);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::DASH
|
|
|
|
|| _la == HogQLParser::PLUS)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(947);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) {
|
|
case 1: {
|
|
setState(941);
|
|
floatingLiteral();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(942);
|
|
match(HogQLParser::OCTAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(943);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(944);
|
|
match(HogQLParser::HEXADECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(945);
|
|
match(HogQLParser::INF);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
setState(946);
|
|
match(HogQLParser::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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::NumberLiteralContext* HogQLParser::LiteralContext::numberLiteral() {
|
|
return getRuleContext<HogQLParser::NumberLiteralContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LiteralContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::LiteralContext::NULL_SQL() {
|
|
return getToken(HogQLParser::NULL_SQL, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::LiteralContext::getRuleIndex() const {
|
|
return HogQLParser::RuleLiteral;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::LiteralContext* HogQLParser::literal() {
|
|
LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 108, HogQLParser::RuleLiteral);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(952);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::INF:
|
|
case HogQLParser::NAN_SQL:
|
|
case HogQLParser::FLOATING_LITERAL:
|
|
case HogQLParser::OCTAL_LITERAL:
|
|
case HogQLParser::DECIMAL_LITERAL:
|
|
case HogQLParser::HEXADECIMAL_LITERAL:
|
|
case HogQLParser::DASH:
|
|
case HogQLParser::DOT:
|
|
case HogQLParser::PLUS: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(949);
|
|
numberLiteral();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::STRING_LITERAL: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(950);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::NULL_SQL: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(951);
|
|
match(HogQLParser::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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::IntervalContext::IntervalContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::SECOND() {
|
|
return getToken(HogQLParser::SECOND, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::MINUTE() {
|
|
return getToken(HogQLParser::MINUTE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::HOUR() {
|
|
return getToken(HogQLParser::HOUR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::DAY() {
|
|
return getToken(HogQLParser::DAY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::WEEK() {
|
|
return getToken(HogQLParser::WEEK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::MONTH() {
|
|
return getToken(HogQLParser::MONTH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::QUARTER() {
|
|
return getToken(HogQLParser::QUARTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IntervalContext::YEAR() {
|
|
return getToken(HogQLParser::YEAR, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::IntervalContext::getRuleIndex() const {
|
|
return HogQLParser::RuleInterval;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::IntervalContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitInterval(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::IntervalContext* HogQLParser::interval() {
|
|
IntervalContext *_localctx = _tracker.createInstance<IntervalContext>(_ctx, getState());
|
|
enterRule(_localctx, 110, HogQLParser::RuleInterval);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(954);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::DAY || ((((_la - 76) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 76)) & 72057615512764417) != 0) || ((((_la - 145) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 145)) & 36283883716609) != 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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::KeywordContext::KeywordContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::AFTER() {
|
|
return getToken(HogQLParser::AFTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ALIAS() {
|
|
return getToken(HogQLParser::ALIAS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ALL() {
|
|
return getToken(HogQLParser::ALL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ALTER() {
|
|
return getToken(HogQLParser::ALTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::AND() {
|
|
return getToken(HogQLParser::AND, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ANTI() {
|
|
return getToken(HogQLParser::ANTI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ANY() {
|
|
return getToken(HogQLParser::ANY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ARRAY() {
|
|
return getToken(HogQLParser::ARRAY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::AS() {
|
|
return getToken(HogQLParser::AS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ASCENDING() {
|
|
return getToken(HogQLParser::ASCENDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ASOF() {
|
|
return getToken(HogQLParser::ASOF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::AST() {
|
|
return getToken(HogQLParser::AST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ASYNC() {
|
|
return getToken(HogQLParser::ASYNC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ATTACH() {
|
|
return getToken(HogQLParser::ATTACH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::BETWEEN() {
|
|
return getToken(HogQLParser::BETWEEN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::BOTH() {
|
|
return getToken(HogQLParser::BOTH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::BY() {
|
|
return getToken(HogQLParser::BY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CASE() {
|
|
return getToken(HogQLParser::CASE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CAST() {
|
|
return getToken(HogQLParser::CAST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CHECK() {
|
|
return getToken(HogQLParser::CHECK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CLEAR() {
|
|
return getToken(HogQLParser::CLEAR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CLUSTER() {
|
|
return getToken(HogQLParser::CLUSTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CODEC() {
|
|
return getToken(HogQLParser::CODEC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::COLLATE() {
|
|
return getToken(HogQLParser::COLLATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::COLUMN() {
|
|
return getToken(HogQLParser::COLUMN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::COMMENT() {
|
|
return getToken(HogQLParser::COMMENT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CONSTRAINT() {
|
|
return getToken(HogQLParser::CONSTRAINT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CREATE() {
|
|
return getToken(HogQLParser::CREATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CROSS() {
|
|
return getToken(HogQLParser::CROSS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CUBE() {
|
|
return getToken(HogQLParser::CUBE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::CURRENT() {
|
|
return getToken(HogQLParser::CURRENT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DATABASE() {
|
|
return getToken(HogQLParser::DATABASE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DATABASES() {
|
|
return getToken(HogQLParser::DATABASES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DATE() {
|
|
return getToken(HogQLParser::DATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DEDUPLICATE() {
|
|
return getToken(HogQLParser::DEDUPLICATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DEFAULT() {
|
|
return getToken(HogQLParser::DEFAULT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DELAY() {
|
|
return getToken(HogQLParser::DELAY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DELETE() {
|
|
return getToken(HogQLParser::DELETE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DESCRIBE() {
|
|
return getToken(HogQLParser::DESCRIBE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DESC() {
|
|
return getToken(HogQLParser::DESC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DESCENDING() {
|
|
return getToken(HogQLParser::DESCENDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DETACH() {
|
|
return getToken(HogQLParser::DETACH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DICTIONARIES() {
|
|
return getToken(HogQLParser::DICTIONARIES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DICTIONARY() {
|
|
return getToken(HogQLParser::DICTIONARY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DISK() {
|
|
return getToken(HogQLParser::DISK, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DISTRIBUTED() {
|
|
return getToken(HogQLParser::DISTRIBUTED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::DROP() {
|
|
return getToken(HogQLParser::DROP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ELSE() {
|
|
return getToken(HogQLParser::ELSE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::END() {
|
|
return getToken(HogQLParser::END, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ENGINE() {
|
|
return getToken(HogQLParser::ENGINE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::EVENTS() {
|
|
return getToken(HogQLParser::EVENTS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::EXISTS() {
|
|
return getToken(HogQLParser::EXISTS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::EXPLAIN() {
|
|
return getToken(HogQLParser::EXPLAIN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::EXPRESSION() {
|
|
return getToken(HogQLParser::EXPRESSION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::EXTRACT() {
|
|
return getToken(HogQLParser::EXTRACT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FETCHES() {
|
|
return getToken(HogQLParser::FETCHES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FINAL() {
|
|
return getToken(HogQLParser::FINAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FIRST() {
|
|
return getToken(HogQLParser::FIRST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FLUSH() {
|
|
return getToken(HogQLParser::FLUSH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FOR() {
|
|
return getToken(HogQLParser::FOR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FOLLOWING() {
|
|
return getToken(HogQLParser::FOLLOWING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FORMAT() {
|
|
return getToken(HogQLParser::FORMAT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FREEZE() {
|
|
return getToken(HogQLParser::FREEZE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FROM() {
|
|
return getToken(HogQLParser::FROM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FULL() {
|
|
return getToken(HogQLParser::FULL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FUNCTION() {
|
|
return getToken(HogQLParser::FUNCTION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::GLOBAL() {
|
|
return getToken(HogQLParser::GLOBAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::GRANULARITY() {
|
|
return getToken(HogQLParser::GRANULARITY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::GROUP() {
|
|
return getToken(HogQLParser::GROUP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::HAVING() {
|
|
return getToken(HogQLParser::HAVING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::HIERARCHICAL() {
|
|
return getToken(HogQLParser::HIERARCHICAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ID() {
|
|
return getToken(HogQLParser::ID, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::IF() {
|
|
return getToken(HogQLParser::IF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ILIKE() {
|
|
return getToken(HogQLParser::ILIKE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::IN() {
|
|
return getToken(HogQLParser::IN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INDEX() {
|
|
return getToken(HogQLParser::INDEX, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INJECTIVE() {
|
|
return getToken(HogQLParser::INJECTIVE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INNER() {
|
|
return getToken(HogQLParser::INNER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INSERT() {
|
|
return getToken(HogQLParser::INSERT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INTERVAL() {
|
|
return getToken(HogQLParser::INTERVAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INTO() {
|
|
return getToken(HogQLParser::INTO, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::IS() {
|
|
return getToken(HogQLParser::IS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::IS_OBJECT_ID() {
|
|
return getToken(HogQLParser::IS_OBJECT_ID, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::JOIN() {
|
|
return getToken(HogQLParser::JOIN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::JSON_FALSE() {
|
|
return getToken(HogQLParser::JSON_FALSE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::JSON_TRUE() {
|
|
return getToken(HogQLParser::JSON_TRUE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::KEY() {
|
|
return getToken(HogQLParser::KEY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::KILL() {
|
|
return getToken(HogQLParser::KILL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LAST() {
|
|
return getToken(HogQLParser::LAST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LAYOUT() {
|
|
return getToken(HogQLParser::LAYOUT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LEADING() {
|
|
return getToken(HogQLParser::LEADING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LEFT() {
|
|
return getToken(HogQLParser::LEFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LIFETIME() {
|
|
return getToken(HogQLParser::LIFETIME, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LIKE() {
|
|
return getToken(HogQLParser::LIKE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LIMIT() {
|
|
return getToken(HogQLParser::LIMIT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LIVE() {
|
|
return getToken(HogQLParser::LIVE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LOCAL() {
|
|
return getToken(HogQLParser::LOCAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LOGS() {
|
|
return getToken(HogQLParser::LOGS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MATERIALIZE() {
|
|
return getToken(HogQLParser::MATERIALIZE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MATERIALIZED() {
|
|
return getToken(HogQLParser::MATERIALIZED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MAX() {
|
|
return getToken(HogQLParser::MAX, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MERGES() {
|
|
return getToken(HogQLParser::MERGES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MIN() {
|
|
return getToken(HogQLParser::MIN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MODIFY() {
|
|
return getToken(HogQLParser::MODIFY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MOVE() {
|
|
return getToken(HogQLParser::MOVE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::MUTATION() {
|
|
return getToken(HogQLParser::MUTATION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::NO() {
|
|
return getToken(HogQLParser::NO, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::NOT() {
|
|
return getToken(HogQLParser::NOT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::NULLS() {
|
|
return getToken(HogQLParser::NULLS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OFFSET() {
|
|
return getToken(HogQLParser::OFFSET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ON() {
|
|
return getToken(HogQLParser::ON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OPTIMIZE() {
|
|
return getToken(HogQLParser::OPTIMIZE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OR() {
|
|
return getToken(HogQLParser::OR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ORDER() {
|
|
return getToken(HogQLParser::ORDER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OUTER() {
|
|
return getToken(HogQLParser::OUTER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OUTFILE() {
|
|
return getToken(HogQLParser::OUTFILE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::OVER() {
|
|
return getToken(HogQLParser::OVER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::PARTITION() {
|
|
return getToken(HogQLParser::PARTITION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::POPULATE() {
|
|
return getToken(HogQLParser::POPULATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::PRECEDING() {
|
|
return getToken(HogQLParser::PRECEDING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::PREWHERE() {
|
|
return getToken(HogQLParser::PREWHERE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::PRIMARY() {
|
|
return getToken(HogQLParser::PRIMARY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::RANGE() {
|
|
return getToken(HogQLParser::RANGE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::RELOAD() {
|
|
return getToken(HogQLParser::RELOAD, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::REMOVE() {
|
|
return getToken(HogQLParser::REMOVE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::RENAME() {
|
|
return getToken(HogQLParser::RENAME, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::REPLACE() {
|
|
return getToken(HogQLParser::REPLACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::REPLICA() {
|
|
return getToken(HogQLParser::REPLICA, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::REPLICATED() {
|
|
return getToken(HogQLParser::REPLICATED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::RIGHT() {
|
|
return getToken(HogQLParser::RIGHT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ROLLUP() {
|
|
return getToken(HogQLParser::ROLLUP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ROW() {
|
|
return getToken(HogQLParser::ROW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ROWS() {
|
|
return getToken(HogQLParser::ROWS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SAMPLE() {
|
|
return getToken(HogQLParser::SAMPLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SELECT() {
|
|
return getToken(HogQLParser::SELECT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SEMI() {
|
|
return getToken(HogQLParser::SEMI, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SENDS() {
|
|
return getToken(HogQLParser::SENDS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SET() {
|
|
return getToken(HogQLParser::SET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SETTINGS() {
|
|
return getToken(HogQLParser::SETTINGS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SHOW() {
|
|
return getToken(HogQLParser::SHOW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SOURCE() {
|
|
return getToken(HogQLParser::SOURCE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::START() {
|
|
return getToken(HogQLParser::START, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::STOP() {
|
|
return getToken(HogQLParser::STOP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SUBSTRING() {
|
|
return getToken(HogQLParser::SUBSTRING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SYNC() {
|
|
return getToken(HogQLParser::SYNC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SYNTAX() {
|
|
return getToken(HogQLParser::SYNTAX, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SYSTEM() {
|
|
return getToken(HogQLParser::SYSTEM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TABLE() {
|
|
return getToken(HogQLParser::TABLE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TABLES() {
|
|
return getToken(HogQLParser::TABLES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TEMPORARY() {
|
|
return getToken(HogQLParser::TEMPORARY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TEST() {
|
|
return getToken(HogQLParser::TEST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::THEN() {
|
|
return getToken(HogQLParser::THEN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TIES() {
|
|
return getToken(HogQLParser::TIES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TIMEOUT() {
|
|
return getToken(HogQLParser::TIMEOUT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TIMESTAMP() {
|
|
return getToken(HogQLParser::TIMESTAMP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TOTALS() {
|
|
return getToken(HogQLParser::TOTALS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TRAILING() {
|
|
return getToken(HogQLParser::TRAILING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TRIM() {
|
|
return getToken(HogQLParser::TRIM, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TRUNCATE() {
|
|
return getToken(HogQLParser::TRUNCATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TO() {
|
|
return getToken(HogQLParser::TO, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TOP() {
|
|
return getToken(HogQLParser::TOP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TTL() {
|
|
return getToken(HogQLParser::TTL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::TYPE() {
|
|
return getToken(HogQLParser::TYPE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::UNBOUNDED() {
|
|
return getToken(HogQLParser::UNBOUNDED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::UNION() {
|
|
return getToken(HogQLParser::UNION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::UPDATE() {
|
|
return getToken(HogQLParser::UPDATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::USE() {
|
|
return getToken(HogQLParser::USE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::USING() {
|
|
return getToken(HogQLParser::USING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::UUID() {
|
|
return getToken(HogQLParser::UUID, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::VALUES() {
|
|
return getToken(HogQLParser::VALUES, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::VIEW() {
|
|
return getToken(HogQLParser::VIEW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::VOLUME() {
|
|
return getToken(HogQLParser::VOLUME, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::WATCH() {
|
|
return getToken(HogQLParser::WATCH, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::WHEN() {
|
|
return getToken(HogQLParser::WHEN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::WHERE() {
|
|
return getToken(HogQLParser::WHERE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::WINDOW() {
|
|
return getToken(HogQLParser::WINDOW, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::WITH() {
|
|
return getToken(HogQLParser::WITH, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::KeywordContext::getRuleIndex() const {
|
|
return HogQLParser::RuleKeyword;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::KeywordContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitKeyword(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::KeywordContext* HogQLParser::keyword() {
|
|
KeywordContext *_localctx = _tracker.createInstance<KeywordContext>(_ctx, getState());
|
|
enterRule(_localctx, 112, HogQLParser::RuleKeyword);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(956);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 2) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 2)) & -34368126977) != 0) || ((((_la - 66) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 66)) & -1288627627820033) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 130)) & 8034421735228932089) != 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;
|
|
}
|
|
|
|
//----------------- KeywordForAliasContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::KeywordForAliasContext::KeywordForAliasContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordForAliasContext::DATE() {
|
|
return getToken(HogQLParser::DATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordForAliasContext::FIRST() {
|
|
return getToken(HogQLParser::FIRST, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordForAliasContext::ID() {
|
|
return getToken(HogQLParser::ID, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordForAliasContext::KEY() {
|
|
return getToken(HogQLParser::KEY, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::KeywordForAliasContext::getRuleIndex() const {
|
|
return HogQLParser::RuleKeywordForAlias;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::KeywordForAliasContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitKeywordForAlias(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::KeywordForAliasContext* HogQLParser::keywordForAlias() {
|
|
KeywordForAliasContext *_localctx = _tracker.createInstance<KeywordForAliasContext>(_ctx, getState());
|
|
enterRule(_localctx, 114, HogQLParser::RuleKeywordForAlias);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(958);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 36) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 36)) & 36030996109328385) != 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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::AliasContext::AliasContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::AliasContext::IDENTIFIER() {
|
|
return getToken(HogQLParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
HogQLParser::KeywordForAliasContext* HogQLParser::AliasContext::keywordForAlias() {
|
|
return getRuleContext<HogQLParser::KeywordForAliasContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::AliasContext::getRuleIndex() const {
|
|
return HogQLParser::RuleAlias;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::AliasContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitAlias(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::AliasContext* HogQLParser::alias() {
|
|
AliasContext *_localctx = _tracker.createInstance<AliasContext>(_ctx, getState());
|
|
enterRule(_localctx, 116, HogQLParser::RuleAlias);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(962);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(960);
|
|
match(HogQLParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::KEY: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(961);
|
|
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;
|
|
}
|
|
|
|
//----------------- IdentifierContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IdentifierContext::IDENTIFIER() {
|
|
return getToken(HogQLParser::IDENTIFIER, 0);
|
|
}
|
|
|
|
HogQLParser::IntervalContext* HogQLParser::IdentifierContext::interval() {
|
|
return getRuleContext<HogQLParser::IntervalContext>(0);
|
|
}
|
|
|
|
HogQLParser::KeywordContext* HogQLParser::IdentifierContext::keyword() {
|
|
return getRuleContext<HogQLParser::KeywordContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::IdentifierContext::getRuleIndex() const {
|
|
return HogQLParser::RuleIdentifier;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::identifier() {
|
|
IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 118, HogQLParser::RuleIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(967);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(964);
|
|
match(HogQLParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DAY:
|
|
case HogQLParser::HOUR:
|
|
case HogQLParser::MINUTE:
|
|
case HogQLParser::MONTH:
|
|
case HogQLParser::QUARTER:
|
|
case HogQLParser::SECOND:
|
|
case HogQLParser::WEEK:
|
|
case HogQLParser::YEAR: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(965);
|
|
interval();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::AFTER:
|
|
case HogQLParser::ALIAS:
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::ALTER:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::AST:
|
|
case HogQLParser::ASYNC:
|
|
case HogQLParser::ATTACH:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::CHECK:
|
|
case HogQLParser::CLEAR:
|
|
case HogQLParser::CLUSTER:
|
|
case HogQLParser::CODEC:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::COLUMN:
|
|
case HogQLParser::COMMENT:
|
|
case HogQLParser::CONSTRAINT:
|
|
case HogQLParser::CREATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATABASE:
|
|
case HogQLParser::DATABASES:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DEDUPLICATE:
|
|
case HogQLParser::DEFAULT:
|
|
case HogQLParser::DELAY:
|
|
case HogQLParser::DELETE:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DESCRIBE:
|
|
case HogQLParser::DETACH:
|
|
case HogQLParser::DICTIONARIES:
|
|
case HogQLParser::DICTIONARY:
|
|
case HogQLParser::DISK:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::DISTRIBUTED:
|
|
case HogQLParser::DROP:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::ENGINE:
|
|
case HogQLParser::EVENTS:
|
|
case HogQLParser::EXISTS:
|
|
case HogQLParser::EXPLAIN:
|
|
case HogQLParser::EXPRESSION:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FETCHES:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FLUSH:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FORMAT:
|
|
case HogQLParser::FREEZE:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::FUNCTION:
|
|
case HogQLParser::GLOBAL:
|
|
case HogQLParser::GRANULARITY:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::HIERARCHICAL:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INDEX:
|
|
case HogQLParser::INJECTIVE:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INSERT:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::INTO:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::IS_OBJECT_ID:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::KILL:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LAYOUT:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIFETIME:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::LIVE:
|
|
case HogQLParser::LOCAL:
|
|
case HogQLParser::LOGS:
|
|
case HogQLParser::MATERIALIZE:
|
|
case HogQLParser::MATERIALIZED:
|
|
case HogQLParser::MAX:
|
|
case HogQLParser::MERGES:
|
|
case HogQLParser::MIN:
|
|
case HogQLParser::MODIFY:
|
|
case HogQLParser::MOVE:
|
|
case HogQLParser::MUTATION:
|
|
case HogQLParser::NO:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OPTIMIZE:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OUTFILE:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::POPULATE:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::PRIMARY:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RELOAD:
|
|
case HogQLParser::REMOVE:
|
|
case HogQLParser::RENAME:
|
|
case HogQLParser::REPLACE:
|
|
case HogQLParser::REPLICA:
|
|
case HogQLParser::REPLICATED:
|
|
case HogQLParser::RIGHT:
|
|
case HogQLParser::ROLLUP:
|
|
case HogQLParser::ROW:
|
|
case HogQLParser::ROWS:
|
|
case HogQLParser::SAMPLE:
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::SEMI:
|
|
case HogQLParser::SENDS:
|
|
case HogQLParser::SET:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::SHOW:
|
|
case HogQLParser::SOURCE:
|
|
case HogQLParser::START:
|
|
case HogQLParser::STOP:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::SYNC:
|
|
case HogQLParser::SYNTAX:
|
|
case HogQLParser::SYSTEM:
|
|
case HogQLParser::TABLE:
|
|
case HogQLParser::TABLES:
|
|
case HogQLParser::TEMPORARY:
|
|
case HogQLParser::TEST:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMEOUT:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::TTL:
|
|
case HogQLParser::TYPE:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::UPDATE:
|
|
case HogQLParser::USE:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::UUID:
|
|
case HogQLParser::VALUES:
|
|
case HogQLParser::VIEW:
|
|
case HogQLParser::VOLUME:
|
|
case HogQLParser::WATCH:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH:
|
|
case HogQLParser::JSON_FALSE:
|
|
case HogQLParser::JSON_TRUE: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(966);
|
|
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 ------------------------------------------------------------------
|
|
|
|
HogQLParser::EnumValueContext::EnumValueContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::EnumValueContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::EnumValueContext::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
HogQLParser::NumberLiteralContext* HogQLParser::EnumValueContext::numberLiteral() {
|
|
return getRuleContext<HogQLParser::NumberLiteralContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::EnumValueContext::getRuleIndex() const {
|
|
return HogQLParser::RuleEnumValue;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::EnumValueContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitEnumValue(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::EnumValueContext* HogQLParser::enumValue() {
|
|
EnumValueContext *_localctx = _tracker.createInstance<EnumValueContext>(_ctx, getState());
|
|
enterRule(_localctx, 120, HogQLParser::RuleEnumValue);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(969);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
setState(970);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(971);
|
|
numberLiteral();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- PlaceholderContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::PlaceholderContext::PlaceholderContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::PlaceholderContext::LBRACE() {
|
|
return getToken(HogQLParser::LBRACE, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::PlaceholderContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::PlaceholderContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::PlaceholderContext::getRuleIndex() const {
|
|
return HogQLParser::RulePlaceholder;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::PlaceholderContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitPlaceholder(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::PlaceholderContext* HogQLParser::placeholder() {
|
|
PlaceholderContext *_localctx = _tracker.createInstance<PlaceholderContext>(_ctx, getState());
|
|
enterRule(_localctx, 122, HogQLParser::RulePlaceholder);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(973);
|
|
match(HogQLParser::LBRACE);
|
|
setState(974);
|
|
identifier();
|
|
setState(975);
|
|
match(HogQLParser::RBRACE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
bool HogQLParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
|
|
switch (ruleIndex) {
|
|
case 18: return joinExprSempred(antlrcpp::downCast<JoinExprContext *>(context), predicateIndex);
|
|
case 37: return columnExprSempred(antlrcpp::downCast<ColumnExprContext *>(context), predicateIndex);
|
|
case 47: return tableExprSempred(antlrcpp::downCast<TableExprContext *>(context), predicateIndex);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HogQLParser::joinExprSempred(JoinExprContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 0: return precpred(_ctx, 3);
|
|
case 1: return precpred(_ctx, 4);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HogQLParser::columnExprSempred(ColumnExprContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 2: return precpred(_ctx, 17);
|
|
case 3: return precpred(_ctx, 16);
|
|
case 4: return precpred(_ctx, 15);
|
|
case 5: return precpred(_ctx, 13);
|
|
case 6: return precpred(_ctx, 11);
|
|
case 7: return precpred(_ctx, 10);
|
|
case 8: return precpred(_ctx, 9);
|
|
case 9: return precpred(_ctx, 8);
|
|
case 10: return precpred(_ctx, 21);
|
|
case 11: return precpred(_ctx, 20);
|
|
case 12: return precpred(_ctx, 19);
|
|
case 13: return precpred(_ctx, 14);
|
|
case 14: return precpred(_ctx, 7);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HogQLParser::tableExprSempred(TableExprContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 15: return precpred(_ctx, 3);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void HogQLParser::initialize() {
|
|
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
|
hogqlparserParserInitialize();
|
|
#else
|
|
::antlr4::internal::call_once(hogqlparserParserOnceFlag, hogqlparserParserInitialize);
|
|
#endif
|
|
}
|