mirror of
https://github.com/BillyOutlast/posthog.git
synced 2026-02-04 03:01:23 +01:00
12244 lines
381 KiB
C++
12244 lines
381 KiB
C++
|
|
// Generated from HogQLParser.g4 by ANTLR 4.13.2
|
|
|
|
|
|
#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
|
|
std::unique_ptr<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>{
|
|
"program", "declaration", "expression", "varDecl", "identifierList",
|
|
"statement", "returnStmt", "throwStmt", "catchBlock", "tryCatchStmt",
|
|
"ifStmt", "whileStmt", "forStmt", "forInStmt", "funcStmt", "varAssignment",
|
|
"exprStmt", "emptyStmt", "block", "kvPair", "kvPairList", "select",
|
|
"selectStmtWithParens", "subsequentSelectSetClause", "selectSetStmt",
|
|
"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", "columnLambdaExpr",
|
|
"hogqlxTagElement", "hogqlxTagAttribute", "withExprList", "withExpr",
|
|
"columnIdentifier", "nestedIdentifier", "tableExpr", "tableFunctionExpr",
|
|
"tableIdentifier", "tableArgList", "databaseIdentifier", "floatingLiteral",
|
|
"numberLiteral", "literal", "interval", "keyword", "keywordForAlias",
|
|
"alias", "identifier", "enumValue", "placeholder", "string", "templateString",
|
|
"stringContents", "fullTemplateString", "stringContentsFull"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
|
|
"", "", "", "", "", "", "", "", "", "", "", "", "'->'", "'*'", "'`'",
|
|
"'\\'", "':'", "','", "'||'", "'-'", "'$'", "'.'", "'=='", "'='",
|
|
"'>='", "'>'", "'#'", "'~*'", "'=~*'", "'{'", "'['", "'('", "'<='",
|
|
"'<'", "", "'!~*'", "'!~'", "'\\u003F.'", "'\\u003F\\u003F'", "'%'",
|
|
"'+'", "'\\u003F'", "'\"'", "'f''", "'F''", "'''", "'~'", "'=~'",
|
|
"'}'", "']'", "')'", "';'", "'/'", "'_'"
|
|
},
|
|
std::vector<std::string>{
|
|
"", "ALL", "AND", "ANTI", "ANY", "ARRAY", "AS", "ASCENDING", "ASOF",
|
|
"BETWEEN", "BOTH", "BY", "CASE", "CAST", "CATCH", "COHORT", "COLLATE",
|
|
"CROSS", "CUBE", "CURRENT", "DATE", "DAY", "DESC", "DESCENDING", "DISTINCT",
|
|
"ELSE", "END", "EXCEPT", "EXTRACT", "FINAL", "FINALLY", "FIRST", "FN",
|
|
"FOLLOWING", "FOR", "FROM", "FULL", "FUN", "GROUP", "HAVING", "HOUR",
|
|
"ID", "IF", "ILIKE", "IN", "INF", "INNER", "INTERSECT", "INTERVAL",
|
|
"IS", "JOIN", "KEY", "LAST", "LEADING", "LEFT", "LET", "LIKE", "LIMIT",
|
|
"MINUTE", "MONTH", "NAN_SQL", "NOT", "NULL_SQL", "NULLS", "OFFSET",
|
|
"ON", "OR", "ORDER", "OUTER", "OVER", "PARTITION", "PRECEDING", "PREWHERE",
|
|
"QUARTER", "RANGE", "RETURN", "RIGHT", "ROLLUP", "ROW", "ROWS", "SAMPLE",
|
|
"SECOND", "SELECT", "SEMI", "SETTINGS", "SUBSTRING", "THEN", "THROW",
|
|
"TIES", "TIMESTAMP", "TO", "TOP", "TOTALS", "TRAILING", "TRIM", "TRUNCATE",
|
|
"TRY", "UNBOUNDED", "UNION", "USING", "WEEK", "WHEN", "WHERE", "WHILE",
|
|
"WINDOW", "WITH", "YEAR", "ESCAPE_CHAR_COMMON", "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", "NULL_PROPERTY",
|
|
"NULLISH", "PERCENT", "PLUS", "QUERY", "QUOTE_DOUBLE", "QUOTE_SINGLE_TEMPLATE",
|
|
"QUOTE_SINGLE_TEMPLATE_FULL", "QUOTE_SINGLE", "REGEX_SINGLE", "REGEX_DOUBLE",
|
|
"RBRACE", "RBRACKET", "RPAREN", "SEMICOLON", "SLASH", "UNDERSCORE",
|
|
"MULTI_LINE_COMMENT", "SINGLE_LINE_COMMENT", "WHITESPACE", "STRING_TEXT",
|
|
"STRING_ESCAPE_TRIGGER", "FULL_STRING_TEXT", "FULL_STRING_ESCAPE_TRIGGER"
|
|
}
|
|
);
|
|
static const int32_t serializedATNSegment[] = {
|
|
4,1,162,1317,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
|
|
2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
|
|
7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
|
|
7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
|
|
7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
|
|
7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
|
|
7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
|
|
7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
|
|
7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
|
|
7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
|
|
7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
|
|
7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
|
|
7,84,2,85,7,85,2,86,7,86,1,0,5,0,176,8,0,10,0,12,0,179,9,0,1,0,1,0,1,
|
|
1,1,1,3,1,185,8,1,1,2,1,2,1,3,1,3,1,3,1,3,1,3,3,3,194,8,3,1,4,1,4,1,4,
|
|
5,4,199,8,4,10,4,12,4,202,9,4,1,4,3,4,205,8,4,1,5,1,5,1,5,1,5,1,5,1,5,
|
|
1,5,1,5,1,5,1,5,1,5,1,5,3,5,219,8,5,1,6,1,6,3,6,223,8,6,1,6,3,6,226,8,
|
|
6,1,7,1,7,3,7,230,8,7,1,7,3,7,233,8,7,1,8,1,8,1,8,1,8,1,8,3,8,240,8,8,
|
|
1,8,1,8,3,8,244,8,8,1,8,1,8,1,9,1,9,1,9,5,9,251,8,9,10,9,12,9,254,9,9,
|
|
1,9,1,9,3,9,258,8,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,3,10,267,8,10,
|
|
1,11,1,11,1,11,1,11,1,11,1,11,3,11,275,8,11,1,12,1,12,1,12,1,12,1,12,
|
|
3,12,282,8,12,1,12,1,12,3,12,286,8,12,1,12,1,12,1,12,1,12,3,12,292,8,
|
|
12,1,12,1,12,1,12,3,12,297,8,12,1,13,1,13,1,13,1,13,1,13,1,13,3,13,305,
|
|
8,13,1,13,1,13,1,13,1,13,1,13,3,13,312,8,13,1,14,1,14,1,14,1,14,3,14,
|
|
318,8,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,16,1,16,3,16,330,8,
|
|
16,1,17,1,17,1,18,1,18,5,18,336,8,18,10,18,12,18,339,9,18,1,18,1,18,1,
|
|
19,1,19,1,19,1,19,1,20,1,20,1,20,5,20,350,8,20,10,20,12,20,353,9,20,1,
|
|
20,3,20,356,8,20,1,21,1,21,1,21,3,21,361,8,21,1,21,1,21,1,22,1,22,1,22,
|
|
1,22,1,22,1,22,3,22,371,8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
|
|
3,23,381,8,23,1,23,1,23,1,24,1,24,5,24,387,8,24,10,24,12,24,390,9,24,
|
|
1,25,3,25,393,8,25,1,25,1,25,3,25,397,8,25,1,25,3,25,400,8,25,1,25,1,
|
|
25,3,25,404,8,25,1,25,3,25,407,8,25,1,25,3,25,410,8,25,1,25,3,25,413,
|
|
8,25,1,25,3,25,416,8,25,1,25,1,25,3,25,420,8,25,1,25,1,25,3,25,424,8,
|
|
25,1,25,3,25,427,8,25,1,25,3,25,430,8,25,1,25,3,25,433,8,25,1,25,1,25,
|
|
3,25,437,8,25,1,25,3,25,440,8,25,1,26,1,26,1,26,1,27,1,27,1,27,1,27,3,
|
|
27,449,8,27,1,28,1,28,1,28,1,29,3,29,455,8,29,1,29,1,29,1,29,1,29,1,30,
|
|
1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,5,30,474,
|
|
8,30,10,30,12,30,477,9,30,1,31,1,31,1,31,1,32,1,32,1,32,1,33,1,33,1,33,
|
|
1,33,1,33,1,33,1,33,1,33,3,33,493,8,33,1,34,1,34,1,34,1,35,1,35,1,35,
|
|
1,35,1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,3,37,510,8,37,1,37,1,37,
|
|
1,37,1,37,3,37,516,8,37,1,37,1,37,1,37,1,37,3,37,522,8,37,1,37,1,37,1,
|
|
37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,533,8,37,3,37,535,8,37,1,38,1,38,
|
|
1,38,1,39,1,39,1,39,1,40,1,40,1,40,3,40,546,8,40,1,40,3,40,549,8,40,1,
|
|
40,1,40,1,40,1,40,3,40,555,8,40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,563,
|
|
8,40,1,40,1,40,1,40,1,40,5,40,569,8,40,10,40,12,40,572,9,40,1,41,3,41,
|
|
575,8,41,1,41,1,41,1,41,3,41,580,8,41,1,41,3,41,583,8,41,1,41,3,41,586,
|
|
8,41,1,41,1,41,3,41,590,8,41,1,41,1,41,3,41,594,8,41,1,41,3,41,597,8,
|
|
41,3,41,599,8,41,1,41,3,41,602,8,41,1,41,1,41,3,41,606,8,41,1,41,1,41,
|
|
3,41,610,8,41,1,41,3,41,613,8,41,3,41,615,8,41,3,41,617,8,41,1,42,1,42,
|
|
1,42,3,42,622,8,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,3,43,
|
|
633,8,43,1,44,1,44,1,44,1,44,3,44,639,8,44,1,45,1,45,1,45,5,45,644,8,
|
|
45,10,45,12,45,647,9,45,1,46,1,46,3,46,651,8,46,1,46,1,46,3,46,655,8,
|
|
46,1,46,1,46,3,46,659,8,46,1,47,1,47,1,47,1,47,3,47,665,8,47,3,47,667,
|
|
8,47,1,48,1,48,1,48,5,48,672,8,48,10,48,12,48,675,9,48,1,49,1,49,1,49,
|
|
1,49,1,50,3,50,682,8,50,1,50,3,50,685,8,50,1,50,3,50,688,8,50,1,51,1,
|
|
51,1,51,1,51,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,
|
|
54,1,54,3,54,707,8,54,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,
|
|
55,1,55,1,55,3,55,721,8,55,1,56,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,
|
|
57,1,57,1,57,1,57,5,57,735,8,57,10,57,12,57,738,9,57,1,57,3,57,741,8,
|
|
57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,5,57,750,8,57,10,57,12,57,753,9,
|
|
57,1,57,3,57,756,8,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,5,57,765,8,57,
|
|
10,57,12,57,768,9,57,1,57,3,57,771,8,57,1,57,1,57,1,57,1,57,1,57,3,57,
|
|
778,8,57,1,57,1,57,3,57,782,8,57,1,58,1,58,1,58,5,58,787,8,58,10,58,12,
|
|
58,790,9,58,1,58,3,58,793,8,58,1,59,1,59,1,59,3,59,798,8,59,1,59,1,59,
|
|
1,59,1,59,1,59,4,59,805,8,59,11,59,12,59,806,1,59,1,59,3,59,811,8,59,
|
|
1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,
|
|
1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,837,8,59,1,59,
|
|
1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,
|
|
3,59,854,8,59,1,59,1,59,1,59,1,59,3,59,860,8,59,1,59,3,59,863,8,59,1,
|
|
59,3,59,866,8,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,876,8,59,
|
|
1,59,1,59,1,59,1,59,3,59,882,8,59,1,59,3,59,885,8,59,1,59,3,59,888,8,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,896,8,59,1,59,3,59,899,8,59,1,59,
|
|
1,59,3,59,903,8,59,1,59,3,59,906,8,59,1,59,1,59,1,59,1,59,1,59,1,59,1,
|
|
59,1,59,1,59,1,59,1,59,1,59,3,59,920,8,59,1,59,1,59,1,59,1,59,1,59,1,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,937,8,59,1,59,1,
|
|
59,1,59,3,59,942,8,59,1,59,1,59,1,59,3,59,947,8,59,1,59,1,59,1,59,1,59,
|
|
3,59,953,8,59,1,59,1,59,1,59,1,59,1,59,3,59,960,8,59,1,59,1,59,1,59,1,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,972,8,59,1,59,1,59,3,59,976,8,59,
|
|
1,59,3,59,979,8,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,988,8,59,1,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,1002,8,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,
|
|
59,3,59,1018,8,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,
|
|
59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,
|
|
59,1,59,1,59,3,59,1047,8,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,1055,8,
|
|
59,5,59,1057,8,59,10,59,12,59,1060,9,59,1,60,1,60,1,60,1,60,5,60,1066,
|
|
8,60,10,60,12,60,1069,9,60,1,60,3,60,1072,8,60,1,60,1,60,1,60,1,60,1,
|
|
60,5,60,1079,8,60,10,60,12,60,1082,9,60,1,60,3,60,1085,8,60,1,60,1,60,
|
|
3,60,1089,8,60,1,60,1,60,1,60,3,60,1094,8,60,1,61,1,61,1,61,5,61,1099,
|
|
8,61,10,61,12,61,1102,9,61,1,61,1,61,1,61,1,61,1,61,1,61,5,61,1110,8,
|
|
61,10,61,12,61,1113,9,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1121,8,61,
|
|
1,61,1,61,1,61,1,61,1,61,3,61,1128,8,61,1,62,1,62,1,62,1,62,1,62,1,62,
|
|
1,62,1,62,1,62,1,62,1,62,3,62,1141,8,62,1,63,1,63,1,63,5,63,1146,8,63,
|
|
10,63,12,63,1149,9,63,1,63,3,63,1152,8,63,1,64,1,64,1,64,1,64,1,64,1,
|
|
64,1,64,1,64,1,64,1,64,3,64,1164,8,64,1,65,1,65,1,65,1,65,3,65,1170,8,
|
|
65,1,65,3,65,1173,8,65,1,66,1,66,1,66,5,66,1178,8,66,10,66,12,66,1181,
|
|
9,66,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1192,8,67,1,67,
|
|
1,67,1,67,1,67,3,67,1198,8,67,5,67,1200,8,67,10,67,12,67,1203,9,67,1,
|
|
68,1,68,1,68,3,68,1208,8,68,1,68,1,68,1,69,1,69,1,69,3,69,1215,8,69,1,
|
|
69,1,69,1,70,1,70,1,70,5,70,1222,8,70,10,70,12,70,1225,9,70,1,70,3,70,
|
|
1228,8,70,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1238,8,72,3,72,
|
|
1240,8,72,1,73,3,73,1243,8,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1251,
|
|
8,73,1,74,1,74,1,74,3,74,1256,8,74,1,75,1,75,1,76,1,76,1,77,1,77,1,78,
|
|
1,78,3,78,1266,8,78,1,79,1,79,1,79,3,79,1271,8,79,1,80,1,80,1,80,1,80,
|
|
1,81,1,81,1,81,1,81,1,82,1,82,3,82,1283,8,82,1,83,1,83,5,83,1287,8,83,
|
|
10,83,12,83,1290,9,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,3,84,1299,8,
|
|
84,1,85,1,85,5,85,1303,8,85,10,85,12,85,1306,9,85,1,85,1,85,1,86,1,86,
|
|
1,86,1,86,1,86,3,86,1315,8,86,1,86,0,3,80,118,134,87,0,2,4,6,8,10,12,
|
|
14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,
|
|
60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,
|
|
106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140,
|
|
142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,0,17,
|
|
2,0,32,32,37,37,2,0,18,18,77,77,2,0,46,46,54,54,3,0,1,1,4,4,8,8,4,0,1,
|
|
1,3,4,8,8,83,83,2,0,54,54,76,76,2,0,1,1,4,4,2,0,7,7,22,23,2,0,31,31,52,
|
|
52,2,0,74,74,79,79,3,0,10,10,53,53,93,93,2,0,43,43,56,56,1,0,110,111,
|
|
2,0,121,121,142,142,7,0,21,21,40,40,58,59,73,73,81,81,100,100,106,106,
|
|
19,0,1,13,15,20,22,26,28,29,31,31,33,36,38,39,41,44,46,46,48,54,56,57,
|
|
61,61,63,72,74,80,82,86,88,95,97,99,101,102,104,105,4,0,20,20,31,31,41,
|
|
41,51,51,1493,0,177,1,0,0,0,2,184,1,0,0,0,4,186,1,0,0,0,6,188,1,0,0,0,
|
|
8,195,1,0,0,0,10,218,1,0,0,0,12,220,1,0,0,0,14,227,1,0,0,0,16,234,1,0,
|
|
0,0,18,247,1,0,0,0,20,259,1,0,0,0,22,268,1,0,0,0,24,276,1,0,0,0,26,298,
|
|
1,0,0,0,28,313,1,0,0,0,30,322,1,0,0,0,32,327,1,0,0,0,34,331,1,0,0,0,36,
|
|
333,1,0,0,0,38,342,1,0,0,0,40,346,1,0,0,0,42,360,1,0,0,0,44,370,1,0,0,
|
|
0,46,380,1,0,0,0,48,384,1,0,0,0,50,392,1,0,0,0,52,441,1,0,0,0,54,444,
|
|
1,0,0,0,56,450,1,0,0,0,58,454,1,0,0,0,60,460,1,0,0,0,62,478,1,0,0,0,64,
|
|
481,1,0,0,0,66,484,1,0,0,0,68,494,1,0,0,0,70,497,1,0,0,0,72,501,1,0,0,
|
|
0,74,534,1,0,0,0,76,536,1,0,0,0,78,539,1,0,0,0,80,554,1,0,0,0,82,616,
|
|
1,0,0,0,84,621,1,0,0,0,86,632,1,0,0,0,88,634,1,0,0,0,90,640,1,0,0,0,92,
|
|
648,1,0,0,0,94,666,1,0,0,0,96,668,1,0,0,0,98,676,1,0,0,0,100,681,1,0,
|
|
0,0,102,689,1,0,0,0,104,693,1,0,0,0,106,697,1,0,0,0,108,706,1,0,0,0,110,
|
|
720,1,0,0,0,112,722,1,0,0,0,114,781,1,0,0,0,116,783,1,0,0,0,118,946,1,
|
|
0,0,0,120,1088,1,0,0,0,122,1127,1,0,0,0,124,1140,1,0,0,0,126,1142,1,0,
|
|
0,0,128,1163,1,0,0,0,130,1172,1,0,0,0,132,1174,1,0,0,0,134,1191,1,0,0,
|
|
0,136,1204,1,0,0,0,138,1214,1,0,0,0,140,1218,1,0,0,0,142,1229,1,0,0,0,
|
|
144,1239,1,0,0,0,146,1242,1,0,0,0,148,1255,1,0,0,0,150,1257,1,0,0,0,152,
|
|
1259,1,0,0,0,154,1261,1,0,0,0,156,1265,1,0,0,0,158,1270,1,0,0,0,160,1272,
|
|
1,0,0,0,162,1276,1,0,0,0,164,1282,1,0,0,0,166,1284,1,0,0,0,168,1298,1,
|
|
0,0,0,170,1300,1,0,0,0,172,1314,1,0,0,0,174,176,3,2,1,0,175,174,1,0,0,
|
|
0,176,179,1,0,0,0,177,175,1,0,0,0,177,178,1,0,0,0,178,180,1,0,0,0,179,
|
|
177,1,0,0,0,180,181,5,0,0,1,181,1,1,0,0,0,182,185,3,6,3,0,183,185,3,10,
|
|
5,0,184,182,1,0,0,0,184,183,1,0,0,0,185,3,1,0,0,0,186,187,3,118,59,0,
|
|
187,5,1,0,0,0,188,189,5,55,0,0,189,193,3,158,79,0,190,191,5,118,0,0,191,
|
|
192,5,125,0,0,192,194,3,4,2,0,193,190,1,0,0,0,193,194,1,0,0,0,194,7,1,
|
|
0,0,0,195,200,3,158,79,0,196,197,5,119,0,0,197,199,3,158,79,0,198,196,
|
|
1,0,0,0,199,202,1,0,0,0,200,198,1,0,0,0,200,201,1,0,0,0,201,204,1,0,0,
|
|
0,202,200,1,0,0,0,203,205,5,119,0,0,204,203,1,0,0,0,204,205,1,0,0,0,205,
|
|
9,1,0,0,0,206,219,3,12,6,0,207,219,3,14,7,0,208,219,3,18,9,0,209,219,
|
|
3,20,10,0,210,219,3,22,11,0,211,219,3,26,13,0,212,219,3,24,12,0,213,219,
|
|
3,28,14,0,214,219,3,30,15,0,215,219,3,36,18,0,216,219,3,32,16,0,217,219,
|
|
3,34,17,0,218,206,1,0,0,0,218,207,1,0,0,0,218,208,1,0,0,0,218,209,1,0,
|
|
0,0,218,210,1,0,0,0,218,211,1,0,0,0,218,212,1,0,0,0,218,213,1,0,0,0,218,
|
|
214,1,0,0,0,218,215,1,0,0,0,218,216,1,0,0,0,218,217,1,0,0,0,219,11,1,
|
|
0,0,0,220,222,5,75,0,0,221,223,3,4,2,0,222,221,1,0,0,0,222,223,1,0,0,
|
|
0,223,225,1,0,0,0,224,226,5,153,0,0,225,224,1,0,0,0,225,226,1,0,0,0,226,
|
|
13,1,0,0,0,227,229,5,87,0,0,228,230,3,4,2,0,229,228,1,0,0,0,229,230,1,
|
|
0,0,0,230,232,1,0,0,0,231,233,5,153,0,0,232,231,1,0,0,0,232,233,1,0,0,
|
|
0,233,15,1,0,0,0,234,243,5,14,0,0,235,236,5,133,0,0,236,239,3,158,79,
|
|
0,237,238,5,118,0,0,238,240,3,158,79,0,239,237,1,0,0,0,239,240,1,0,0,
|
|
0,240,241,1,0,0,0,241,242,5,152,0,0,242,244,1,0,0,0,243,235,1,0,0,0,243,
|
|
244,1,0,0,0,244,245,1,0,0,0,245,246,3,36,18,0,246,17,1,0,0,0,247,248,
|
|
5,96,0,0,248,252,3,36,18,0,249,251,3,16,8,0,250,249,1,0,0,0,251,254,1,
|
|
0,0,0,252,250,1,0,0,0,252,253,1,0,0,0,253,257,1,0,0,0,254,252,1,0,0,0,
|
|
255,256,5,30,0,0,256,258,3,36,18,0,257,255,1,0,0,0,257,258,1,0,0,0,258,
|
|
19,1,0,0,0,259,260,5,42,0,0,260,261,5,133,0,0,261,262,3,4,2,0,262,263,
|
|
5,152,0,0,263,266,3,10,5,0,264,265,5,25,0,0,265,267,3,10,5,0,266,264,
|
|
1,0,0,0,266,267,1,0,0,0,267,21,1,0,0,0,268,269,5,103,0,0,269,270,5,133,
|
|
0,0,270,271,3,4,2,0,271,272,5,152,0,0,272,274,3,10,5,0,273,275,5,153,
|
|
0,0,274,273,1,0,0,0,274,275,1,0,0,0,275,23,1,0,0,0,276,277,5,34,0,0,277,
|
|
281,5,133,0,0,278,282,3,6,3,0,279,282,3,30,15,0,280,282,3,4,2,0,281,278,
|
|
1,0,0,0,281,279,1,0,0,0,281,280,1,0,0,0,281,282,1,0,0,0,282,283,1,0,0,
|
|
0,283,285,5,153,0,0,284,286,3,4,2,0,285,284,1,0,0,0,285,286,1,0,0,0,286,
|
|
287,1,0,0,0,287,291,5,153,0,0,288,292,3,6,3,0,289,292,3,30,15,0,290,292,
|
|
3,4,2,0,291,288,1,0,0,0,291,289,1,0,0,0,291,290,1,0,0,0,291,292,1,0,0,
|
|
0,292,293,1,0,0,0,293,294,5,152,0,0,294,296,3,10,5,0,295,297,5,153,0,
|
|
0,296,295,1,0,0,0,296,297,1,0,0,0,297,25,1,0,0,0,298,299,5,34,0,0,299,
|
|
300,5,133,0,0,300,301,5,55,0,0,301,304,3,158,79,0,302,303,5,119,0,0,303,
|
|
305,3,158,79,0,304,302,1,0,0,0,304,305,1,0,0,0,305,306,1,0,0,0,306,307,
|
|
5,44,0,0,307,308,3,4,2,0,308,309,5,152,0,0,309,311,3,10,5,0,310,312,5,
|
|
153,0,0,311,310,1,0,0,0,311,312,1,0,0,0,312,27,1,0,0,0,313,314,7,0,0,
|
|
0,314,315,3,158,79,0,315,317,5,133,0,0,316,318,3,8,4,0,317,316,1,0,0,
|
|
0,317,318,1,0,0,0,318,319,1,0,0,0,319,320,5,152,0,0,320,321,3,36,18,0,
|
|
321,29,1,0,0,0,322,323,3,4,2,0,323,324,5,118,0,0,324,325,5,125,0,0,325,
|
|
326,3,4,2,0,326,31,1,0,0,0,327,329,3,4,2,0,328,330,5,153,0,0,329,328,
|
|
1,0,0,0,329,330,1,0,0,0,330,33,1,0,0,0,331,332,5,153,0,0,332,35,1,0,0,
|
|
0,333,337,5,131,0,0,334,336,3,2,1,0,335,334,1,0,0,0,336,339,1,0,0,0,337,
|
|
335,1,0,0,0,337,338,1,0,0,0,338,340,1,0,0,0,339,337,1,0,0,0,340,341,5,
|
|
150,0,0,341,37,1,0,0,0,342,343,3,4,2,0,343,344,5,118,0,0,344,345,3,4,
|
|
2,0,345,39,1,0,0,0,346,351,3,38,19,0,347,348,5,119,0,0,348,350,3,38,19,
|
|
0,349,347,1,0,0,0,350,353,1,0,0,0,351,349,1,0,0,0,351,352,1,0,0,0,352,
|
|
355,1,0,0,0,353,351,1,0,0,0,354,356,5,119,0,0,355,354,1,0,0,0,355,356,
|
|
1,0,0,0,356,41,1,0,0,0,357,361,3,48,24,0,358,361,3,50,25,0,359,361,3,
|
|
122,61,0,360,357,1,0,0,0,360,358,1,0,0,0,360,359,1,0,0,0,361,362,1,0,
|
|
0,0,362,363,5,0,0,1,363,43,1,0,0,0,364,371,3,50,25,0,365,366,5,133,0,
|
|
0,366,367,3,48,24,0,367,368,5,152,0,0,368,371,1,0,0,0,369,371,3,162,81,
|
|
0,370,364,1,0,0,0,370,365,1,0,0,0,370,369,1,0,0,0,371,45,1,0,0,0,372,
|
|
381,5,27,0,0,373,374,5,98,0,0,374,381,5,1,0,0,375,376,5,98,0,0,376,381,
|
|
5,24,0,0,377,381,5,47,0,0,378,379,5,47,0,0,379,381,5,24,0,0,380,372,1,
|
|
0,0,0,380,373,1,0,0,0,380,375,1,0,0,0,380,377,1,0,0,0,380,378,1,0,0,0,
|
|
381,382,1,0,0,0,382,383,3,44,22,0,383,47,1,0,0,0,384,388,3,44,22,0,385,
|
|
387,3,46,23,0,386,385,1,0,0,0,387,390,1,0,0,0,388,386,1,0,0,0,388,389,
|
|
1,0,0,0,389,49,1,0,0,0,390,388,1,0,0,0,391,393,3,52,26,0,392,391,1,0,
|
|
0,0,392,393,1,0,0,0,393,394,1,0,0,0,394,396,5,82,0,0,395,397,5,24,0,0,
|
|
396,395,1,0,0,0,396,397,1,0,0,0,397,399,1,0,0,0,398,400,3,54,27,0,399,
|
|
398,1,0,0,0,399,400,1,0,0,0,400,401,1,0,0,0,401,403,3,116,58,0,402,404,
|
|
3,56,28,0,403,402,1,0,0,0,403,404,1,0,0,0,404,406,1,0,0,0,405,407,3,58,
|
|
29,0,406,405,1,0,0,0,406,407,1,0,0,0,407,409,1,0,0,0,408,410,3,62,31,
|
|
0,409,408,1,0,0,0,409,410,1,0,0,0,410,412,1,0,0,0,411,413,3,64,32,0,412,
|
|
411,1,0,0,0,412,413,1,0,0,0,413,415,1,0,0,0,414,416,3,66,33,0,415,414,
|
|
1,0,0,0,415,416,1,0,0,0,416,419,1,0,0,0,417,418,5,105,0,0,418,420,7,1,
|
|
0,0,419,417,1,0,0,0,419,420,1,0,0,0,420,423,1,0,0,0,421,422,5,105,0,0,
|
|
422,424,5,92,0,0,423,421,1,0,0,0,423,424,1,0,0,0,424,426,1,0,0,0,425,
|
|
427,3,68,34,0,426,425,1,0,0,0,426,427,1,0,0,0,427,429,1,0,0,0,428,430,
|
|
3,60,30,0,429,428,1,0,0,0,429,430,1,0,0,0,430,432,1,0,0,0,431,433,3,70,
|
|
35,0,432,431,1,0,0,0,432,433,1,0,0,0,433,436,1,0,0,0,434,437,3,74,37,
|
|
0,435,437,3,76,38,0,436,434,1,0,0,0,436,435,1,0,0,0,436,437,1,0,0,0,437,
|
|
439,1,0,0,0,438,440,3,78,39,0,439,438,1,0,0,0,439,440,1,0,0,0,440,51,
|
|
1,0,0,0,441,442,5,105,0,0,442,443,3,126,63,0,443,53,1,0,0,0,444,445,5,
|
|
91,0,0,445,448,5,111,0,0,446,447,5,105,0,0,447,449,5,88,0,0,448,446,1,
|
|
0,0,0,448,449,1,0,0,0,449,55,1,0,0,0,450,451,5,35,0,0,451,452,3,80,40,
|
|
0,452,57,1,0,0,0,453,455,7,2,0,0,454,453,1,0,0,0,454,455,1,0,0,0,455,
|
|
456,1,0,0,0,456,457,5,5,0,0,457,458,5,50,0,0,458,459,3,116,58,0,459,59,
|
|
1,0,0,0,460,461,5,104,0,0,461,462,3,158,79,0,462,463,5,6,0,0,463,464,
|
|
5,133,0,0,464,465,3,100,50,0,465,475,5,152,0,0,466,467,5,119,0,0,467,
|
|
468,3,158,79,0,468,469,5,6,0,0,469,470,5,133,0,0,470,471,3,100,50,0,471,
|
|
472,5,152,0,0,472,474,1,0,0,0,473,466,1,0,0,0,474,477,1,0,0,0,475,473,
|
|
1,0,0,0,475,476,1,0,0,0,476,61,1,0,0,0,477,475,1,0,0,0,478,479,5,72,0,
|
|
0,479,480,3,118,59,0,480,63,1,0,0,0,481,482,5,102,0,0,482,483,3,118,59,
|
|
0,483,65,1,0,0,0,484,485,5,38,0,0,485,492,5,11,0,0,486,487,7,1,0,0,487,
|
|
488,5,133,0,0,488,489,3,116,58,0,489,490,5,152,0,0,490,493,1,0,0,0,491,
|
|
493,3,116,58,0,492,486,1,0,0,0,492,491,1,0,0,0,493,67,1,0,0,0,494,495,
|
|
5,39,0,0,495,496,3,118,59,0,496,69,1,0,0,0,497,498,5,67,0,0,498,499,5,
|
|
11,0,0,499,500,3,90,45,0,500,71,1,0,0,0,501,502,5,67,0,0,502,503,5,11,
|
|
0,0,503,504,3,116,58,0,504,73,1,0,0,0,505,506,5,57,0,0,506,509,3,118,
|
|
59,0,507,508,5,119,0,0,508,510,3,118,59,0,509,507,1,0,0,0,509,510,1,0,
|
|
0,0,510,515,1,0,0,0,511,512,5,105,0,0,512,516,5,88,0,0,513,514,5,11,0,
|
|
0,514,516,3,116,58,0,515,511,1,0,0,0,515,513,1,0,0,0,515,516,1,0,0,0,
|
|
516,535,1,0,0,0,517,518,5,57,0,0,518,521,3,118,59,0,519,520,5,105,0,0,
|
|
520,522,5,88,0,0,521,519,1,0,0,0,521,522,1,0,0,0,522,523,1,0,0,0,523,
|
|
524,5,64,0,0,524,525,3,118,59,0,525,535,1,0,0,0,526,527,5,57,0,0,527,
|
|
528,3,118,59,0,528,529,5,64,0,0,529,532,3,118,59,0,530,531,5,11,0,0,531,
|
|
533,3,116,58,0,532,530,1,0,0,0,532,533,1,0,0,0,533,535,1,0,0,0,534,505,
|
|
1,0,0,0,534,517,1,0,0,0,534,526,1,0,0,0,535,75,1,0,0,0,536,537,5,64,0,
|
|
0,537,538,3,118,59,0,538,77,1,0,0,0,539,540,5,84,0,0,540,541,3,96,48,
|
|
0,541,79,1,0,0,0,542,543,6,40,-1,0,543,545,3,134,67,0,544,546,5,29,0,
|
|
0,545,544,1,0,0,0,545,546,1,0,0,0,546,548,1,0,0,0,547,549,3,88,44,0,548,
|
|
547,1,0,0,0,548,549,1,0,0,0,549,555,1,0,0,0,550,551,5,133,0,0,551,552,
|
|
3,80,40,0,552,553,5,152,0,0,553,555,1,0,0,0,554,542,1,0,0,0,554,550,1,
|
|
0,0,0,555,570,1,0,0,0,556,557,10,3,0,0,557,558,3,84,42,0,558,559,3,80,
|
|
40,4,559,569,1,0,0,0,560,562,10,4,0,0,561,563,3,82,41,0,562,561,1,0,0,
|
|
0,562,563,1,0,0,0,563,564,1,0,0,0,564,565,5,50,0,0,565,566,3,80,40,0,
|
|
566,567,3,86,43,0,567,569,1,0,0,0,568,556,1,0,0,0,568,560,1,0,0,0,569,
|
|
572,1,0,0,0,570,568,1,0,0,0,570,571,1,0,0,0,571,81,1,0,0,0,572,570,1,
|
|
0,0,0,573,575,7,3,0,0,574,573,1,0,0,0,574,575,1,0,0,0,575,576,1,0,0,0,
|
|
576,583,5,46,0,0,577,579,5,46,0,0,578,580,7,3,0,0,579,578,1,0,0,0,579,
|
|
580,1,0,0,0,580,583,1,0,0,0,581,583,7,3,0,0,582,574,1,0,0,0,582,577,1,
|
|
0,0,0,582,581,1,0,0,0,583,617,1,0,0,0,584,586,7,4,0,0,585,584,1,0,0,0,
|
|
585,586,1,0,0,0,586,587,1,0,0,0,587,589,7,5,0,0,588,590,5,68,0,0,589,
|
|
588,1,0,0,0,589,590,1,0,0,0,590,599,1,0,0,0,591,593,7,5,0,0,592,594,5,
|
|
68,0,0,593,592,1,0,0,0,593,594,1,0,0,0,594,596,1,0,0,0,595,597,7,4,0,
|
|
0,596,595,1,0,0,0,596,597,1,0,0,0,597,599,1,0,0,0,598,585,1,0,0,0,598,
|
|
591,1,0,0,0,599,617,1,0,0,0,600,602,7,6,0,0,601,600,1,0,0,0,601,602,1,
|
|
0,0,0,602,603,1,0,0,0,603,605,5,36,0,0,604,606,5,68,0,0,605,604,1,0,0,
|
|
0,605,606,1,0,0,0,606,615,1,0,0,0,607,609,5,36,0,0,608,610,5,68,0,0,609,
|
|
608,1,0,0,0,609,610,1,0,0,0,610,612,1,0,0,0,611,613,7,6,0,0,612,611,1,
|
|
0,0,0,612,613,1,0,0,0,613,615,1,0,0,0,614,601,1,0,0,0,614,607,1,0,0,0,
|
|
615,617,1,0,0,0,616,582,1,0,0,0,616,598,1,0,0,0,616,614,1,0,0,0,617,83,
|
|
1,0,0,0,618,619,5,17,0,0,619,622,5,50,0,0,620,622,5,119,0,0,621,618,1,
|
|
0,0,0,621,620,1,0,0,0,622,85,1,0,0,0,623,624,5,65,0,0,624,633,3,116,58,
|
|
0,625,626,5,99,0,0,626,627,5,133,0,0,627,628,3,116,58,0,628,629,5,152,
|
|
0,0,629,633,1,0,0,0,630,631,5,99,0,0,631,633,3,116,58,0,632,623,1,0,0,
|
|
0,632,625,1,0,0,0,632,630,1,0,0,0,633,87,1,0,0,0,634,635,5,80,0,0,635,
|
|
638,3,94,47,0,636,637,5,64,0,0,637,639,3,94,47,0,638,636,1,0,0,0,638,
|
|
639,1,0,0,0,639,89,1,0,0,0,640,645,3,92,46,0,641,642,5,119,0,0,642,644,
|
|
3,92,46,0,643,641,1,0,0,0,644,647,1,0,0,0,645,643,1,0,0,0,645,646,1,0,
|
|
0,0,646,91,1,0,0,0,647,645,1,0,0,0,648,650,3,118,59,0,649,651,7,7,0,0,
|
|
650,649,1,0,0,0,650,651,1,0,0,0,651,654,1,0,0,0,652,653,5,63,0,0,653,
|
|
655,7,8,0,0,654,652,1,0,0,0,654,655,1,0,0,0,655,658,1,0,0,0,656,657,5,
|
|
16,0,0,657,659,5,113,0,0,658,656,1,0,0,0,658,659,1,0,0,0,659,93,1,0,0,
|
|
0,660,667,3,162,81,0,661,664,3,146,73,0,662,663,5,154,0,0,663,665,3,146,
|
|
73,0,664,662,1,0,0,0,664,665,1,0,0,0,665,667,1,0,0,0,666,660,1,0,0,0,
|
|
666,661,1,0,0,0,667,95,1,0,0,0,668,673,3,98,49,0,669,670,5,119,0,0,670,
|
|
672,3,98,49,0,671,669,1,0,0,0,672,675,1,0,0,0,673,671,1,0,0,0,673,674,
|
|
1,0,0,0,674,97,1,0,0,0,675,673,1,0,0,0,676,677,3,158,79,0,677,678,5,125,
|
|
0,0,678,679,3,148,74,0,679,99,1,0,0,0,680,682,3,102,51,0,681,680,1,0,
|
|
0,0,681,682,1,0,0,0,682,684,1,0,0,0,683,685,3,104,52,0,684,683,1,0,0,
|
|
0,684,685,1,0,0,0,685,687,1,0,0,0,686,688,3,106,53,0,687,686,1,0,0,0,
|
|
687,688,1,0,0,0,688,101,1,0,0,0,689,690,5,70,0,0,690,691,5,11,0,0,691,
|
|
692,3,116,58,0,692,103,1,0,0,0,693,694,5,67,0,0,694,695,5,11,0,0,695,
|
|
696,3,90,45,0,696,105,1,0,0,0,697,698,7,9,0,0,698,699,3,108,54,0,699,
|
|
107,1,0,0,0,700,707,3,110,55,0,701,702,5,9,0,0,702,703,3,110,55,0,703,
|
|
704,5,2,0,0,704,705,3,110,55,0,705,707,1,0,0,0,706,700,1,0,0,0,706,701,
|
|
1,0,0,0,707,109,1,0,0,0,708,709,5,19,0,0,709,721,5,78,0,0,710,711,5,97,
|
|
0,0,711,721,5,71,0,0,712,713,5,97,0,0,713,721,5,33,0,0,714,715,3,146,
|
|
73,0,715,716,5,71,0,0,716,721,1,0,0,0,717,718,3,146,73,0,718,719,5,33,
|
|
0,0,719,721,1,0,0,0,720,708,1,0,0,0,720,710,1,0,0,0,720,712,1,0,0,0,720,
|
|
714,1,0,0,0,720,717,1,0,0,0,721,111,1,0,0,0,722,723,3,118,59,0,723,724,
|
|
5,0,0,1,724,113,1,0,0,0,725,782,3,158,79,0,726,727,3,158,79,0,727,728,
|
|
5,133,0,0,728,729,3,158,79,0,729,736,3,114,57,0,730,731,5,119,0,0,731,
|
|
732,3,158,79,0,732,733,3,114,57,0,733,735,1,0,0,0,734,730,1,0,0,0,735,
|
|
738,1,0,0,0,736,734,1,0,0,0,736,737,1,0,0,0,737,740,1,0,0,0,738,736,1,
|
|
0,0,0,739,741,5,119,0,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1,0,0,
|
|
0,742,743,5,152,0,0,743,782,1,0,0,0,744,745,3,158,79,0,745,746,5,133,
|
|
0,0,746,751,3,160,80,0,747,748,5,119,0,0,748,750,3,160,80,0,749,747,1,
|
|
0,0,0,750,753,1,0,0,0,751,749,1,0,0,0,751,752,1,0,0,0,752,755,1,0,0,0,
|
|
753,751,1,0,0,0,754,756,5,119,0,0,755,754,1,0,0,0,755,756,1,0,0,0,756,
|
|
757,1,0,0,0,757,758,5,152,0,0,758,782,1,0,0,0,759,760,3,158,79,0,760,
|
|
761,5,133,0,0,761,766,3,114,57,0,762,763,5,119,0,0,763,765,3,114,57,0,
|
|
764,762,1,0,0,0,765,768,1,0,0,0,766,764,1,0,0,0,766,767,1,0,0,0,767,770,
|
|
1,0,0,0,768,766,1,0,0,0,769,771,5,119,0,0,770,769,1,0,0,0,770,771,1,0,
|
|
0,0,771,772,1,0,0,0,772,773,5,152,0,0,773,782,1,0,0,0,774,775,3,158,79,
|
|
0,775,777,5,133,0,0,776,778,3,116,58,0,777,776,1,0,0,0,777,778,1,0,0,
|
|
0,778,779,1,0,0,0,779,780,5,152,0,0,780,782,1,0,0,0,781,725,1,0,0,0,781,
|
|
726,1,0,0,0,781,744,1,0,0,0,781,759,1,0,0,0,781,774,1,0,0,0,782,115,1,
|
|
0,0,0,783,788,3,118,59,0,784,785,5,119,0,0,785,787,3,118,59,0,786,784,
|
|
1,0,0,0,787,790,1,0,0,0,788,786,1,0,0,0,788,789,1,0,0,0,789,792,1,0,0,
|
|
0,790,788,1,0,0,0,791,793,5,119,0,0,792,791,1,0,0,0,792,793,1,0,0,0,793,
|
|
117,1,0,0,0,794,795,6,59,-1,0,795,797,5,12,0,0,796,798,3,118,59,0,797,
|
|
796,1,0,0,0,797,798,1,0,0,0,798,804,1,0,0,0,799,800,5,101,0,0,800,801,
|
|
3,118,59,0,801,802,5,86,0,0,802,803,3,118,59,0,803,805,1,0,0,0,804,799,
|
|
1,0,0,0,805,806,1,0,0,0,806,804,1,0,0,0,806,807,1,0,0,0,807,810,1,0,0,
|
|
0,808,809,5,25,0,0,809,811,3,118,59,0,810,808,1,0,0,0,810,811,1,0,0,0,
|
|
811,812,1,0,0,0,812,813,5,26,0,0,813,947,1,0,0,0,814,815,5,13,0,0,815,
|
|
816,5,133,0,0,816,817,3,118,59,0,817,818,5,6,0,0,818,819,3,114,57,0,819,
|
|
820,5,152,0,0,820,947,1,0,0,0,821,822,5,20,0,0,822,947,5,113,0,0,823,
|
|
824,5,48,0,0,824,947,5,113,0,0,825,826,5,48,0,0,826,827,3,118,59,0,827,
|
|
828,3,150,75,0,828,947,1,0,0,0,829,830,5,85,0,0,830,831,5,133,0,0,831,
|
|
832,3,118,59,0,832,833,5,35,0,0,833,836,3,118,59,0,834,835,5,34,0,0,835,
|
|
837,3,118,59,0,836,834,1,0,0,0,836,837,1,0,0,0,837,838,1,0,0,0,838,839,
|
|
5,152,0,0,839,947,1,0,0,0,840,841,5,89,0,0,841,947,5,113,0,0,842,843,
|
|
5,94,0,0,843,844,5,133,0,0,844,845,7,10,0,0,845,846,3,164,82,0,846,847,
|
|
5,35,0,0,847,848,3,118,59,0,848,849,5,152,0,0,849,947,1,0,0,0,850,851,
|
|
3,158,79,0,851,853,5,133,0,0,852,854,3,116,58,0,853,852,1,0,0,0,853,854,
|
|
1,0,0,0,854,855,1,0,0,0,855,856,5,152,0,0,856,865,1,0,0,0,857,859,5,133,
|
|
0,0,858,860,5,24,0,0,859,858,1,0,0,0,859,860,1,0,0,0,860,862,1,0,0,0,
|
|
861,863,3,116,58,0,862,861,1,0,0,0,862,863,1,0,0,0,863,864,1,0,0,0,864,
|
|
866,5,152,0,0,865,857,1,0,0,0,865,866,1,0,0,0,866,867,1,0,0,0,867,868,
|
|
5,69,0,0,868,869,5,133,0,0,869,870,3,100,50,0,870,871,5,152,0,0,871,947,
|
|
1,0,0,0,872,873,3,158,79,0,873,875,5,133,0,0,874,876,3,116,58,0,875,874,
|
|
1,0,0,0,875,876,1,0,0,0,876,877,1,0,0,0,877,878,5,152,0,0,878,887,1,0,
|
|
0,0,879,881,5,133,0,0,880,882,5,24,0,0,881,880,1,0,0,0,881,882,1,0,0,
|
|
0,882,884,1,0,0,0,883,885,3,116,58,0,884,883,1,0,0,0,884,885,1,0,0,0,
|
|
885,886,1,0,0,0,886,888,5,152,0,0,887,879,1,0,0,0,887,888,1,0,0,0,888,
|
|
889,1,0,0,0,889,890,5,69,0,0,890,891,3,158,79,0,891,947,1,0,0,0,892,898,
|
|
3,158,79,0,893,895,5,133,0,0,894,896,3,116,58,0,895,894,1,0,0,0,895,896,
|
|
1,0,0,0,896,897,1,0,0,0,897,899,5,152,0,0,898,893,1,0,0,0,898,899,1,0,
|
|
0,0,899,900,1,0,0,0,900,902,5,133,0,0,901,903,5,24,0,0,902,901,1,0,0,
|
|
0,902,903,1,0,0,0,903,905,1,0,0,0,904,906,3,116,58,0,905,904,1,0,0,0,
|
|
905,906,1,0,0,0,906,907,1,0,0,0,907,908,5,152,0,0,908,947,1,0,0,0,909,
|
|
947,3,122,61,0,910,947,3,166,83,0,911,947,3,148,74,0,912,913,5,121,0,
|
|
0,913,947,3,118,59,20,914,915,5,61,0,0,915,947,3,118,59,14,916,917,3,
|
|
138,69,0,917,918,5,123,0,0,918,920,1,0,0,0,919,916,1,0,0,0,919,920,1,
|
|
0,0,0,920,921,1,0,0,0,921,947,5,115,0,0,922,923,5,133,0,0,923,924,3,48,
|
|
24,0,924,925,5,152,0,0,925,947,1,0,0,0,926,927,5,133,0,0,927,928,3,118,
|
|
59,0,928,929,5,152,0,0,929,947,1,0,0,0,930,931,5,133,0,0,931,932,3,116,
|
|
58,0,932,933,5,152,0,0,933,947,1,0,0,0,934,936,5,132,0,0,935,937,3,116,
|
|
58,0,936,935,1,0,0,0,936,937,1,0,0,0,937,938,1,0,0,0,938,947,5,151,0,
|
|
0,939,941,5,131,0,0,940,942,3,40,20,0,941,940,1,0,0,0,941,942,1,0,0,0,
|
|
942,943,1,0,0,0,943,947,5,150,0,0,944,947,3,120,60,0,945,947,3,130,65,
|
|
0,946,794,1,0,0,0,946,814,1,0,0,0,946,821,1,0,0,0,946,823,1,0,0,0,946,
|
|
825,1,0,0,0,946,829,1,0,0,0,946,840,1,0,0,0,946,842,1,0,0,0,946,850,1,
|
|
0,0,0,946,872,1,0,0,0,946,892,1,0,0,0,946,909,1,0,0,0,946,910,1,0,0,0,
|
|
946,911,1,0,0,0,946,912,1,0,0,0,946,914,1,0,0,0,946,919,1,0,0,0,946,922,
|
|
1,0,0,0,946,926,1,0,0,0,946,930,1,0,0,0,946,934,1,0,0,0,946,939,1,0,0,
|
|
0,946,944,1,0,0,0,946,945,1,0,0,0,947,1058,1,0,0,0,948,952,10,19,0,0,
|
|
949,953,5,115,0,0,950,953,5,154,0,0,951,953,5,141,0,0,952,949,1,0,0,0,
|
|
952,950,1,0,0,0,952,951,1,0,0,0,953,954,1,0,0,0,954,1057,3,118,59,20,
|
|
955,959,10,18,0,0,956,960,5,142,0,0,957,960,5,121,0,0,958,960,5,120,0,
|
|
0,959,956,1,0,0,0,959,957,1,0,0,0,959,958,1,0,0,0,960,961,1,0,0,0,961,
|
|
1057,3,118,59,19,962,987,10,17,0,0,963,988,5,124,0,0,964,988,5,125,0,
|
|
0,965,988,5,136,0,0,966,988,5,134,0,0,967,988,5,135,0,0,968,988,5,126,
|
|
0,0,969,988,5,127,0,0,970,972,5,61,0,0,971,970,1,0,0,0,971,972,1,0,0,
|
|
0,972,973,1,0,0,0,973,975,5,44,0,0,974,976,5,15,0,0,975,974,1,0,0,0,975,
|
|
976,1,0,0,0,976,988,1,0,0,0,977,979,5,61,0,0,978,977,1,0,0,0,978,979,
|
|
1,0,0,0,979,980,1,0,0,0,980,988,7,11,0,0,981,988,5,148,0,0,982,988,5,
|
|
149,0,0,983,988,5,138,0,0,984,988,5,129,0,0,985,988,5,130,0,0,986,988,
|
|
5,137,0,0,987,963,1,0,0,0,987,964,1,0,0,0,987,965,1,0,0,0,987,966,1,0,
|
|
0,0,987,967,1,0,0,0,987,968,1,0,0,0,987,969,1,0,0,0,987,971,1,0,0,0,987,
|
|
978,1,0,0,0,987,981,1,0,0,0,987,982,1,0,0,0,987,983,1,0,0,0,987,984,1,
|
|
0,0,0,987,985,1,0,0,0,987,986,1,0,0,0,988,989,1,0,0,0,989,1057,3,118,
|
|
59,18,990,991,10,15,0,0,991,992,5,140,0,0,992,1057,3,118,59,16,993,994,
|
|
10,13,0,0,994,995,5,2,0,0,995,1057,3,118,59,14,996,997,10,12,0,0,997,
|
|
998,5,66,0,0,998,1057,3,118,59,13,999,1001,10,11,0,0,1000,1002,5,61,0,
|
|
0,1001,1000,1,0,0,0,1001,1002,1,0,0,0,1002,1003,1,0,0,0,1003,1004,5,9,
|
|
0,0,1004,1005,3,118,59,0,1005,1006,5,2,0,0,1006,1007,3,118,59,12,1007,
|
|
1057,1,0,0,0,1008,1009,10,10,0,0,1009,1010,5,143,0,0,1010,1011,3,118,
|
|
59,0,1011,1012,5,118,0,0,1012,1013,3,118,59,10,1013,1057,1,0,0,0,1014,
|
|
1015,10,30,0,0,1015,1017,5,133,0,0,1016,1018,3,116,58,0,1017,1016,1,0,
|
|
0,0,1017,1018,1,0,0,0,1018,1019,1,0,0,0,1019,1057,5,152,0,0,1020,1021,
|
|
10,26,0,0,1021,1022,5,132,0,0,1022,1023,3,118,59,0,1023,1024,5,151,0,
|
|
0,1024,1057,1,0,0,0,1025,1026,10,25,0,0,1026,1027,5,123,0,0,1027,1057,
|
|
5,111,0,0,1028,1029,10,24,0,0,1029,1030,5,123,0,0,1030,1057,3,158,79,
|
|
0,1031,1032,10,23,0,0,1032,1033,5,139,0,0,1033,1034,5,132,0,0,1034,1035,
|
|
3,118,59,0,1035,1036,5,151,0,0,1036,1057,1,0,0,0,1037,1038,10,22,0,0,
|
|
1038,1039,5,139,0,0,1039,1057,5,111,0,0,1040,1041,10,21,0,0,1041,1042,
|
|
5,139,0,0,1042,1057,3,158,79,0,1043,1044,10,16,0,0,1044,1046,5,49,0,0,
|
|
1045,1047,5,61,0,0,1046,1045,1,0,0,0,1046,1047,1,0,0,0,1047,1048,1,0,
|
|
0,0,1048,1057,5,62,0,0,1049,1054,10,9,0,0,1050,1051,5,6,0,0,1051,1055,
|
|
3,158,79,0,1052,1053,5,6,0,0,1053,1055,5,113,0,0,1054,1050,1,0,0,0,1054,
|
|
1052,1,0,0,0,1055,1057,1,0,0,0,1056,948,1,0,0,0,1056,955,1,0,0,0,1056,
|
|
962,1,0,0,0,1056,990,1,0,0,0,1056,993,1,0,0,0,1056,996,1,0,0,0,1056,999,
|
|
1,0,0,0,1056,1008,1,0,0,0,1056,1014,1,0,0,0,1056,1020,1,0,0,0,1056,1025,
|
|
1,0,0,0,1056,1028,1,0,0,0,1056,1031,1,0,0,0,1056,1037,1,0,0,0,1056,1040,
|
|
1,0,0,0,1056,1043,1,0,0,0,1056,1049,1,0,0,0,1057,1060,1,0,0,0,1058,1056,
|
|
1,0,0,0,1058,1059,1,0,0,0,1059,119,1,0,0,0,1060,1058,1,0,0,0,1061,1062,
|
|
5,133,0,0,1062,1067,3,158,79,0,1063,1064,5,119,0,0,1064,1066,3,158,79,
|
|
0,1065,1063,1,0,0,0,1066,1069,1,0,0,0,1067,1065,1,0,0,0,1067,1068,1,0,
|
|
0,0,1068,1071,1,0,0,0,1069,1067,1,0,0,0,1070,1072,5,119,0,0,1071,1070,
|
|
1,0,0,0,1071,1072,1,0,0,0,1072,1073,1,0,0,0,1073,1074,5,152,0,0,1074,
|
|
1089,1,0,0,0,1075,1080,3,158,79,0,1076,1077,5,119,0,0,1077,1079,3,158,
|
|
79,0,1078,1076,1,0,0,0,1079,1082,1,0,0,0,1080,1078,1,0,0,0,1080,1081,
|
|
1,0,0,0,1081,1084,1,0,0,0,1082,1080,1,0,0,0,1083,1085,5,119,0,0,1084,
|
|
1083,1,0,0,0,1084,1085,1,0,0,0,1085,1089,1,0,0,0,1086,1087,5,133,0,0,
|
|
1087,1089,5,152,0,0,1088,1061,1,0,0,0,1088,1075,1,0,0,0,1088,1086,1,0,
|
|
0,0,1089,1090,1,0,0,0,1090,1093,5,114,0,0,1091,1094,3,118,59,0,1092,1094,
|
|
3,36,18,0,1093,1091,1,0,0,0,1093,1092,1,0,0,0,1094,121,1,0,0,0,1095,1096,
|
|
5,135,0,0,1096,1100,3,158,79,0,1097,1099,3,124,62,0,1098,1097,1,0,0,0,
|
|
1099,1102,1,0,0,0,1100,1098,1,0,0,0,1100,1101,1,0,0,0,1101,1103,1,0,0,
|
|
0,1102,1100,1,0,0,0,1103,1104,5,154,0,0,1104,1105,5,127,0,0,1105,1128,
|
|
1,0,0,0,1106,1107,5,135,0,0,1107,1111,3,158,79,0,1108,1110,3,124,62,0,
|
|
1109,1108,1,0,0,0,1110,1113,1,0,0,0,1111,1109,1,0,0,0,1111,1112,1,0,0,
|
|
0,1112,1114,1,0,0,0,1113,1111,1,0,0,0,1114,1120,5,127,0,0,1115,1121,3,
|
|
122,61,0,1116,1117,5,131,0,0,1117,1118,3,118,59,0,1118,1119,5,150,0,0,
|
|
1119,1121,1,0,0,0,1120,1115,1,0,0,0,1120,1116,1,0,0,0,1120,1121,1,0,0,
|
|
0,1121,1122,1,0,0,0,1122,1123,5,135,0,0,1123,1124,5,154,0,0,1124,1125,
|
|
3,158,79,0,1125,1126,5,127,0,0,1126,1128,1,0,0,0,1127,1095,1,0,0,0,1127,
|
|
1106,1,0,0,0,1128,123,1,0,0,0,1129,1130,3,158,79,0,1130,1131,5,125,0,
|
|
0,1131,1132,3,164,82,0,1132,1141,1,0,0,0,1133,1134,3,158,79,0,1134,1135,
|
|
5,125,0,0,1135,1136,5,131,0,0,1136,1137,3,118,59,0,1137,1138,5,150,0,
|
|
0,1138,1141,1,0,0,0,1139,1141,3,158,79,0,1140,1129,1,0,0,0,1140,1133,
|
|
1,0,0,0,1140,1139,1,0,0,0,1141,125,1,0,0,0,1142,1147,3,128,64,0,1143,
|
|
1144,5,119,0,0,1144,1146,3,128,64,0,1145,1143,1,0,0,0,1146,1149,1,0,0,
|
|
0,1147,1145,1,0,0,0,1147,1148,1,0,0,0,1148,1151,1,0,0,0,1149,1147,1,0,
|
|
0,0,1150,1152,5,119,0,0,1151,1150,1,0,0,0,1151,1152,1,0,0,0,1152,127,
|
|
1,0,0,0,1153,1154,3,158,79,0,1154,1155,5,6,0,0,1155,1156,5,133,0,0,1156,
|
|
1157,3,48,24,0,1157,1158,5,152,0,0,1158,1164,1,0,0,0,1159,1160,3,118,
|
|
59,0,1160,1161,5,6,0,0,1161,1162,3,158,79,0,1162,1164,1,0,0,0,1163,1153,
|
|
1,0,0,0,1163,1159,1,0,0,0,1164,129,1,0,0,0,1165,1173,3,162,81,0,1166,
|
|
1167,3,138,69,0,1167,1168,5,123,0,0,1168,1170,1,0,0,0,1169,1166,1,0,0,
|
|
0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,1171,1173,3,132,66,0,1172,1165,
|
|
1,0,0,0,1172,1169,1,0,0,0,1173,131,1,0,0,0,1174,1179,3,158,79,0,1175,
|
|
1176,5,123,0,0,1176,1178,3,158,79,0,1177,1175,1,0,0,0,1178,1181,1,0,0,
|
|
0,1179,1177,1,0,0,0,1179,1180,1,0,0,0,1180,133,1,0,0,0,1181,1179,1,0,
|
|
0,0,1182,1183,6,67,-1,0,1183,1192,3,138,69,0,1184,1192,3,136,68,0,1185,
|
|
1186,5,133,0,0,1186,1187,3,48,24,0,1187,1188,5,152,0,0,1188,1192,1,0,
|
|
0,0,1189,1192,3,122,61,0,1190,1192,3,162,81,0,1191,1182,1,0,0,0,1191,
|
|
1184,1,0,0,0,1191,1185,1,0,0,0,1191,1189,1,0,0,0,1191,1190,1,0,0,0,1192,
|
|
1201,1,0,0,0,1193,1197,10,3,0,0,1194,1198,3,156,78,0,1195,1196,5,6,0,
|
|
0,1196,1198,3,158,79,0,1197,1194,1,0,0,0,1197,1195,1,0,0,0,1198,1200,
|
|
1,0,0,0,1199,1193,1,0,0,0,1200,1203,1,0,0,0,1201,1199,1,0,0,0,1201,1202,
|
|
1,0,0,0,1202,135,1,0,0,0,1203,1201,1,0,0,0,1204,1205,3,158,79,0,1205,
|
|
1207,5,133,0,0,1206,1208,3,140,70,0,1207,1206,1,0,0,0,1207,1208,1,0,0,
|
|
0,1208,1209,1,0,0,0,1209,1210,5,152,0,0,1210,137,1,0,0,0,1211,1212,3,
|
|
142,71,0,1212,1213,5,123,0,0,1213,1215,1,0,0,0,1214,1211,1,0,0,0,1214,
|
|
1215,1,0,0,0,1215,1216,1,0,0,0,1216,1217,3,158,79,0,1217,139,1,0,0,0,
|
|
1218,1223,3,118,59,0,1219,1220,5,119,0,0,1220,1222,3,118,59,0,1221,1219,
|
|
1,0,0,0,1222,1225,1,0,0,0,1223,1221,1,0,0,0,1223,1224,1,0,0,0,1224,1227,
|
|
1,0,0,0,1225,1223,1,0,0,0,1226,1228,5,119,0,0,1227,1226,1,0,0,0,1227,
|
|
1228,1,0,0,0,1228,141,1,0,0,0,1229,1230,3,158,79,0,1230,143,1,0,0,0,1231,
|
|
1240,5,109,0,0,1232,1233,5,123,0,0,1233,1240,7,12,0,0,1234,1235,5,111,
|
|
0,0,1235,1237,5,123,0,0,1236,1238,7,12,0,0,1237,1236,1,0,0,0,1237,1238,
|
|
1,0,0,0,1238,1240,1,0,0,0,1239,1231,1,0,0,0,1239,1232,1,0,0,0,1239,1234,
|
|
1,0,0,0,1240,145,1,0,0,0,1241,1243,7,13,0,0,1242,1241,1,0,0,0,1242,1243,
|
|
1,0,0,0,1243,1250,1,0,0,0,1244,1251,3,144,72,0,1245,1251,5,110,0,0,1246,
|
|
1251,5,111,0,0,1247,1251,5,112,0,0,1248,1251,5,45,0,0,1249,1251,5,60,
|
|
0,0,1250,1244,1,0,0,0,1250,1245,1,0,0,0,1250,1246,1,0,0,0,1250,1247,1,
|
|
0,0,0,1250,1248,1,0,0,0,1250,1249,1,0,0,0,1251,147,1,0,0,0,1252,1256,
|
|
3,146,73,0,1253,1256,5,113,0,0,1254,1256,5,62,0,0,1255,1252,1,0,0,0,1255,
|
|
1253,1,0,0,0,1255,1254,1,0,0,0,1256,149,1,0,0,0,1257,1258,7,14,0,0,1258,
|
|
151,1,0,0,0,1259,1260,7,15,0,0,1260,153,1,0,0,0,1261,1262,7,16,0,0,1262,
|
|
155,1,0,0,0,1263,1266,5,108,0,0,1264,1266,3,154,77,0,1265,1263,1,0,0,
|
|
0,1265,1264,1,0,0,0,1266,157,1,0,0,0,1267,1271,5,108,0,0,1268,1271,3,
|
|
150,75,0,1269,1271,3,152,76,0,1270,1267,1,0,0,0,1270,1268,1,0,0,0,1270,
|
|
1269,1,0,0,0,1271,159,1,0,0,0,1272,1273,3,164,82,0,1273,1274,5,125,0,
|
|
0,1274,1275,3,146,73,0,1275,161,1,0,0,0,1276,1277,5,131,0,0,1277,1278,
|
|
3,118,59,0,1278,1279,5,150,0,0,1279,163,1,0,0,0,1280,1283,5,113,0,0,1281,
|
|
1283,3,166,83,0,1282,1280,1,0,0,0,1282,1281,1,0,0,0,1283,165,1,0,0,0,
|
|
1284,1288,5,145,0,0,1285,1287,3,168,84,0,1286,1285,1,0,0,0,1287,1290,
|
|
1,0,0,0,1288,1286,1,0,0,0,1288,1289,1,0,0,0,1289,1291,1,0,0,0,1290,1288,
|
|
1,0,0,0,1291,1292,5,147,0,0,1292,167,1,0,0,0,1293,1294,5,160,0,0,1294,
|
|
1295,3,118,59,0,1295,1296,5,150,0,0,1296,1299,1,0,0,0,1297,1299,5,159,
|
|
0,0,1298,1293,1,0,0,0,1298,1297,1,0,0,0,1299,169,1,0,0,0,1300,1304,5,
|
|
146,0,0,1301,1303,3,172,86,0,1302,1301,1,0,0,0,1303,1306,1,0,0,0,1304,
|
|
1302,1,0,0,0,1304,1305,1,0,0,0,1305,1307,1,0,0,0,1306,1304,1,0,0,0,1307,
|
|
1308,5,0,0,1,1308,171,1,0,0,0,1309,1310,5,162,0,0,1310,1311,3,118,59,
|
|
0,1311,1312,5,150,0,0,1312,1315,1,0,0,0,1313,1315,5,161,0,0,1314,1309,
|
|
1,0,0,0,1314,1313,1,0,0,0,1315,173,1,0,0,0,168,177,184,193,200,204,218,
|
|
222,225,229,232,239,243,252,257,266,274,281,285,291,296,304,311,317,329,
|
|
337,351,355,360,370,380,388,392,396,399,403,406,409,412,415,419,423,426,
|
|
429,432,436,439,448,454,475,492,509,515,521,532,534,545,548,554,562,568,
|
|
570,574,579,582,585,589,593,596,598,601,605,609,612,614,616,621,632,638,
|
|
645,650,654,658,664,666,673,681,684,687,706,720,736,740,751,755,766,770,
|
|
777,781,788,792,797,806,810,836,853,859,862,865,875,881,884,887,895,898,
|
|
902,905,919,936,941,946,952,959,971,975,978,987,1001,1017,1046,1054,1056,
|
|
1058,1067,1071,1080,1084,1088,1093,1100,1111,1120,1127,1140,1147,1151,
|
|
1163,1169,1172,1179,1191,1197,1201,1207,1214,1223,1227,1237,1239,1242,
|
|
1250,1255,1265,1270,1282,1288,1298,1304,1314
|
|
};
|
|
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 = std::move(staticData);
|
|
}
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
//----------------- ProgramContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ProgramContext::EOF() {
|
|
return getToken(HogQLParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::DeclarationContext *> HogQLParser::ProgramContext::declaration() {
|
|
return getRuleContexts<HogQLParser::DeclarationContext>();
|
|
}
|
|
|
|
HogQLParser::DeclarationContext* HogQLParser::ProgramContext::declaration(size_t i) {
|
|
return getRuleContext<HogQLParser::DeclarationContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ProgramContext::getRuleIndex() const {
|
|
return HogQLParser::RuleProgram;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitProgram(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ProgramContext* HogQLParser::program() {
|
|
ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
|
|
enterRule(_localctx, 0, HogQLParser::RuleProgram);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(177);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -140738696331266) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944844006785023) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 4212759) != 0)) {
|
|
setState(174);
|
|
declaration();
|
|
setState(179);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(180);
|
|
match(HogQLParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DeclarationContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::DeclarationContext::DeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::VarDeclContext* HogQLParser::DeclarationContext::varDecl() {
|
|
return getRuleContext<HogQLParser::VarDeclContext>(0);
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::DeclarationContext::statement() {
|
|
return getRuleContext<HogQLParser::StatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::DeclarationContext::getRuleIndex() const {
|
|
return HogQLParser::RuleDeclaration;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::DeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::DeclarationContext* HogQLParser::declaration() {
|
|
DeclarationContext *_localctx = _tracker.createInstance<DeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 2, HogQLParser::RuleDeclaration);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(184);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LET: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(182);
|
|
varDecl();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::COHORT:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DAY:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FN:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::FUN:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::HOUR:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INF:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::MINUTE:
|
|
case HogQLParser::MONTH:
|
|
case HogQLParser::NAN_SQL:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULL_SQL:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::QUARTER:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RETURN:
|
|
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::SETTINGS:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::THROW:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::TRY:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::WEEK:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WHILE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH:
|
|
case HogQLParser::YEAR:
|
|
case HogQLParser::IDENTIFIER:
|
|
case HogQLParser::FLOATING_LITERAL:
|
|
case HogQLParser::OCTAL_LITERAL:
|
|
case HogQLParser::DECIMAL_LITERAL:
|
|
case HogQLParser::HEXADECIMAL_LITERAL:
|
|
case HogQLParser::STRING_LITERAL:
|
|
case HogQLParser::ASTERISK:
|
|
case HogQLParser::DASH:
|
|
case HogQLParser::DOT:
|
|
case HogQLParser::LBRACE:
|
|
case HogQLParser::LBRACKET:
|
|
case HogQLParser::LPAREN:
|
|
case HogQLParser::LT:
|
|
case HogQLParser::PLUS:
|
|
case HogQLParser::QUOTE_SINGLE_TEMPLATE:
|
|
case HogQLParser::SEMICOLON: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(183);
|
|
statement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ExpressionContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ExpressionContext::getRuleIndex() const {
|
|
return HogQLParser::RuleExpression;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::expression() {
|
|
ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 4, HogQLParser::RuleExpression);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(186);
|
|
columnExpr(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VarDeclContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::VarDeclContext::LET() {
|
|
return getToken(HogQLParser::LET, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::VarDeclContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::VarDeclContext::COLON() {
|
|
return getToken(HogQLParser::COLON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::VarDeclContext::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::VarDeclContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::VarDeclContext::getRuleIndex() const {
|
|
return HogQLParser::RuleVarDecl;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::VarDeclContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitVarDecl(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::VarDeclContext* HogQLParser::varDecl() {
|
|
VarDeclContext *_localctx = _tracker.createInstance<VarDeclContext>(_ctx, getState());
|
|
enterRule(_localctx, 6, HogQLParser::RuleVarDecl);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(188);
|
|
match(HogQLParser::LET);
|
|
setState(189);
|
|
identifier();
|
|
setState(193);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COLON) {
|
|
setState(190);
|
|
match(HogQLParser::COLON);
|
|
setState(191);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(192);
|
|
expression();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IdentifierListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IdentifierListContext::IdentifierListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::IdentifierListContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::IdentifierListContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::IdentifierListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IdentifierListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::IdentifierListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleIdentifierList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::IdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitIdentifierList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::IdentifierListContext* HogQLParser::identifierList() {
|
|
IdentifierListContext *_localctx = _tracker.createInstance<IdentifierListContext>(_ctx, getState());
|
|
enterRule(_localctx, 8, HogQLParser::RuleIdentifierList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(195);
|
|
identifier();
|
|
setState(200);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(196);
|
|
match(HogQLParser::COMMA);
|
|
setState(197);
|
|
identifier();
|
|
}
|
|
setState(202);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx);
|
|
}
|
|
setState(204);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(203);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ReturnStmtContext* HogQLParser::StatementContext::returnStmt() {
|
|
return getRuleContext<HogQLParser::ReturnStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::ThrowStmtContext* HogQLParser::StatementContext::throwStmt() {
|
|
return getRuleContext<HogQLParser::ThrowStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::TryCatchStmtContext* HogQLParser::StatementContext::tryCatchStmt() {
|
|
return getRuleContext<HogQLParser::TryCatchStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::IfStmtContext* HogQLParser::StatementContext::ifStmt() {
|
|
return getRuleContext<HogQLParser::IfStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::WhileStmtContext* HogQLParser::StatementContext::whileStmt() {
|
|
return getRuleContext<HogQLParser::WhileStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::ForInStmtContext* HogQLParser::StatementContext::forInStmt() {
|
|
return getRuleContext<HogQLParser::ForInStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::ForStmtContext* HogQLParser::StatementContext::forStmt() {
|
|
return getRuleContext<HogQLParser::ForStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::FuncStmtContext* HogQLParser::StatementContext::funcStmt() {
|
|
return getRuleContext<HogQLParser::FuncStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::VarAssignmentContext* HogQLParser::StatementContext::varAssignment() {
|
|
return getRuleContext<HogQLParser::VarAssignmentContext>(0);
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::StatementContext::block() {
|
|
return getRuleContext<HogQLParser::BlockContext>(0);
|
|
}
|
|
|
|
HogQLParser::ExprStmtContext* HogQLParser::StatementContext::exprStmt() {
|
|
return getRuleContext<HogQLParser::ExprStmtContext>(0);
|
|
}
|
|
|
|
HogQLParser::EmptyStmtContext* HogQLParser::StatementContext::emptyStmt() {
|
|
return getRuleContext<HogQLParser::EmptyStmtContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::StatementContext::getRuleIndex() const {
|
|
return HogQLParser::RuleStatement;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::statement() {
|
|
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 10, HogQLParser::RuleStatement);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(218);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(206);
|
|
returnStmt();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(207);
|
|
throwStmt();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(208);
|
|
tryCatchStmt();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(209);
|
|
ifStmt();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(210);
|
|
whileStmt();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(211);
|
|
forInStmt();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(212);
|
|
forStmt();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(213);
|
|
funcStmt();
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(214);
|
|
varAssignment();
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(215);
|
|
block();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
enterOuterAlt(_localctx, 11);
|
|
setState(216);
|
|
exprStmt();
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
enterOuterAlt(_localctx, 12);
|
|
setState(217);
|
|
emptyStmt();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ReturnStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ReturnStmtContext::RETURN() {
|
|
return getToken(HogQLParser::RETURN, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::ReturnStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ReturnStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ReturnStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleReturnStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitReturnStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ReturnStmtContext* HogQLParser::returnStmt() {
|
|
ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 12, HogQLParser::RuleReturnStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(220);
|
|
match(HogQLParser::RETURN);
|
|
setState(222);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
|
|
case 1: {
|
|
setState(221);
|
|
expression();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(225);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
|
|
case 1: {
|
|
setState(224);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ThrowStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ThrowStmtContext::ThrowStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ThrowStmtContext::THROW() {
|
|
return getToken(HogQLParser::THROW, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::ThrowStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ThrowStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ThrowStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleThrowStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ThrowStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitThrowStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ThrowStmtContext* HogQLParser::throwStmt() {
|
|
ThrowStmtContext *_localctx = _tracker.createInstance<ThrowStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 14, HogQLParser::RuleThrowStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(227);
|
|
match(HogQLParser::THROW);
|
|
setState(229);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
|
|
case 1: {
|
|
setState(228);
|
|
expression();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(232);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
|
|
case 1: {
|
|
setState(231);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- CatchBlockContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::CatchBlockContext::CatchBlockContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::CatchBlockContext::CATCH() {
|
|
return getToken(HogQLParser::CATCH, 0);
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::CatchBlockContext::block() {
|
|
return getRuleContext<HogQLParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::CatchBlockContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::CatchBlockContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::CatchBlockContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::CatchBlockContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::CatchBlockContext::COLON() {
|
|
return getToken(HogQLParser::COLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::CatchBlockContext::getRuleIndex() const {
|
|
return HogQLParser::RuleCatchBlock;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::CatchBlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitCatchBlock(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::CatchBlockContext* HogQLParser::catchBlock() {
|
|
CatchBlockContext *_localctx = _tracker.createInstance<CatchBlockContext>(_ctx, getState());
|
|
enterRule(_localctx, 16, HogQLParser::RuleCatchBlock);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(234);
|
|
match(HogQLParser::CATCH);
|
|
setState(243);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::LPAREN) {
|
|
setState(235);
|
|
match(HogQLParser::LPAREN);
|
|
setState(236);
|
|
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchVar = identifier();
|
|
setState(239);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COLON) {
|
|
setState(237);
|
|
match(HogQLParser::COLON);
|
|
setState(238);
|
|
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchType = identifier();
|
|
}
|
|
setState(241);
|
|
match(HogQLParser::RPAREN);
|
|
}
|
|
setState(245);
|
|
antlrcpp::downCast<CatchBlockContext *>(_localctx)->catchStmt = block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TryCatchStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TryCatchStmtContext::TryCatchStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TryCatchStmtContext::TRY() {
|
|
return getToken(HogQLParser::TRY, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::BlockContext *> HogQLParser::TryCatchStmtContext::block() {
|
|
return getRuleContexts<HogQLParser::BlockContext>();
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::TryCatchStmtContext::block(size_t i) {
|
|
return getRuleContext<HogQLParser::BlockContext>(i);
|
|
}
|
|
|
|
std::vector<HogQLParser::CatchBlockContext *> HogQLParser::TryCatchStmtContext::catchBlock() {
|
|
return getRuleContexts<HogQLParser::CatchBlockContext>();
|
|
}
|
|
|
|
HogQLParser::CatchBlockContext* HogQLParser::TryCatchStmtContext::catchBlock(size_t i) {
|
|
return getRuleContext<HogQLParser::CatchBlockContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TryCatchStmtContext::FINALLY() {
|
|
return getToken(HogQLParser::FINALLY, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TryCatchStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTryCatchStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TryCatchStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTryCatchStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TryCatchStmtContext* HogQLParser::tryCatchStmt() {
|
|
TryCatchStmtContext *_localctx = _tracker.createInstance<TryCatchStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 18, HogQLParser::RuleTryCatchStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(247);
|
|
match(HogQLParser::TRY);
|
|
setState(248);
|
|
antlrcpp::downCast<TryCatchStmtContext *>(_localctx)->tryStmt = block();
|
|
setState(252);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::CATCH) {
|
|
setState(249);
|
|
catchBlock();
|
|
setState(254);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(257);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::FINALLY) {
|
|
setState(255);
|
|
match(HogQLParser::FINALLY);
|
|
setState(256);
|
|
antlrcpp::downCast<TryCatchStmtContext *>(_localctx)->finallyStmt = block();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IfStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IfStmtContext::IF() {
|
|
return getToken(HogQLParser::IF, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IfStmtContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::IfStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IfStmtContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::StatementContext *> HogQLParser::IfStmtContext::statement() {
|
|
return getRuleContexts<HogQLParser::StatementContext>();
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::IfStmtContext::statement(size_t i) {
|
|
return getRuleContext<HogQLParser::StatementContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::IfStmtContext::ELSE() {
|
|
return getToken(HogQLParser::ELSE, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::IfStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleIfStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::IfStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitIfStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::IfStmtContext* HogQLParser::ifStmt() {
|
|
IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 20, HogQLParser::RuleIfStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(259);
|
|
match(HogQLParser::IF);
|
|
setState(260);
|
|
match(HogQLParser::LPAREN);
|
|
setState(261);
|
|
expression();
|
|
setState(262);
|
|
match(HogQLParser::RPAREN);
|
|
setState(263);
|
|
statement();
|
|
setState(266);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx)) {
|
|
case 1: {
|
|
setState(264);
|
|
match(HogQLParser::ELSE);
|
|
setState(265);
|
|
statement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WhileStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WhileStmtContext::WHILE() {
|
|
return getToken(HogQLParser::WHILE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WhileStmtContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::WhileStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WhileStmtContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::WhileStmtContext::statement() {
|
|
return getRuleContext<HogQLParser::StatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::WhileStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::WhileStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleWhileStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::WhileStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitWhileStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::WhileStmtContext* HogQLParser::whileStmt() {
|
|
WhileStmtContext *_localctx = _tracker.createInstance<WhileStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 22, HogQLParser::RuleWhileStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(268);
|
|
match(HogQLParser::WHILE);
|
|
setState(269);
|
|
match(HogQLParser::LPAREN);
|
|
setState(270);
|
|
expression();
|
|
setState(271);
|
|
match(HogQLParser::RPAREN);
|
|
setState(272);
|
|
statement();
|
|
setState(274);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
|
|
case 1: {
|
|
setState(273);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForStmtContext::FOR() {
|
|
return getToken(HogQLParser::FOR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForStmtContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ForStmtContext::SEMICOLON() {
|
|
return getTokens(HogQLParser::SEMICOLON);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForStmtContext::SEMICOLON(size_t i) {
|
|
return getToken(HogQLParser::SEMICOLON, i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForStmtContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::ForStmtContext::statement() {
|
|
return getRuleContext<HogQLParser::StatementContext>(0);
|
|
}
|
|
|
|
std::vector<HogQLParser::VarDeclContext *> HogQLParser::ForStmtContext::varDecl() {
|
|
return getRuleContexts<HogQLParser::VarDeclContext>();
|
|
}
|
|
|
|
HogQLParser::VarDeclContext* HogQLParser::ForStmtContext::varDecl(size_t i) {
|
|
return getRuleContext<HogQLParser::VarDeclContext>(i);
|
|
}
|
|
|
|
std::vector<HogQLParser::VarAssignmentContext *> HogQLParser::ForStmtContext::varAssignment() {
|
|
return getRuleContexts<HogQLParser::VarAssignmentContext>();
|
|
}
|
|
|
|
HogQLParser::VarAssignmentContext* HogQLParser::ForStmtContext::varAssignment(size_t i) {
|
|
return getRuleContext<HogQLParser::VarAssignmentContext>(i);
|
|
}
|
|
|
|
std::vector<HogQLParser::ExpressionContext *> HogQLParser::ForStmtContext::expression() {
|
|
return getRuleContexts<HogQLParser::ExpressionContext>();
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::ForStmtContext::expression(size_t i) {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ForStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleForStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ForStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitForStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ForStmtContext* HogQLParser::forStmt() {
|
|
ForStmtContext *_localctx = _tracker.createInstance<ForStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 24, HogQLParser::RuleForStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(276);
|
|
match(HogQLParser::FOR);
|
|
setState(277);
|
|
match(HogQLParser::LPAREN);
|
|
setState(281);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) {
|
|
case 1: {
|
|
setState(278);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerVarDeclr = varDecl();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(279);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerVarAssignment = varAssignment();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(280);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->initializerExpression = expression();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(283);
|
|
match(HogQLParser::SEMICOLON);
|
|
setState(285);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(284);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->condition = expression();
|
|
}
|
|
setState(287);
|
|
match(HogQLParser::SEMICOLON);
|
|
setState(291);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
|
|
case 1: {
|
|
setState(288);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementVarDeclr = varDecl();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(289);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementVarAssignment = varAssignment();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(290);
|
|
antlrcpp::downCast<ForStmtContext *>(_localctx)->incrementExpression = expression();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(293);
|
|
match(HogQLParser::RPAREN);
|
|
setState(294);
|
|
statement();
|
|
setState(296);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
|
|
case 1: {
|
|
setState(295);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForInStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ForInStmtContext::ForInStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::FOR() {
|
|
return getToken(HogQLParser::FOR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::LET() {
|
|
return getToken(HogQLParser::LET, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::IdentifierContext *> HogQLParser::ForInStmtContext::identifier() {
|
|
return getRuleContexts<HogQLParser::IdentifierContext>();
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ForInStmtContext::identifier(size_t i) {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::IN() {
|
|
return getToken(HogQLParser::IN, 0);
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::ForInStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::StatementContext* HogQLParser::ForInStmtContext::statement() {
|
|
return getRuleContext<HogQLParser::StatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::COMMA() {
|
|
return getToken(HogQLParser::COMMA, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ForInStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ForInStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleForInStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ForInStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitForInStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ForInStmtContext* HogQLParser::forInStmt() {
|
|
ForInStmtContext *_localctx = _tracker.createInstance<ForInStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 26, HogQLParser::RuleForInStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(298);
|
|
match(HogQLParser::FOR);
|
|
setState(299);
|
|
match(HogQLParser::LPAREN);
|
|
setState(300);
|
|
match(HogQLParser::LET);
|
|
setState(301);
|
|
identifier();
|
|
setState(304);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(302);
|
|
match(HogQLParser::COMMA);
|
|
setState(303);
|
|
identifier();
|
|
}
|
|
setState(306);
|
|
match(HogQLParser::IN);
|
|
setState(307);
|
|
expression();
|
|
setState(308);
|
|
match(HogQLParser::RPAREN);
|
|
setState(309);
|
|
statement();
|
|
setState(311);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {
|
|
case 1: {
|
|
setState(310);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FuncStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::FuncStmtContext::FuncStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::FuncStmtContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FuncStmtContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FuncStmtContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::FuncStmtContext::block() {
|
|
return getRuleContext<HogQLParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FuncStmtContext::FN() {
|
|
return getToken(HogQLParser::FN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FuncStmtContext::FUN() {
|
|
return getToken(HogQLParser::FUN, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierListContext* HogQLParser::FuncStmtContext::identifierList() {
|
|
return getRuleContext<HogQLParser::IdentifierListContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::FuncStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleFuncStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::FuncStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFuncStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::FuncStmtContext* HogQLParser::funcStmt() {
|
|
FuncStmtContext *_localctx = _tracker.createInstance<FuncStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 28, HogQLParser::RuleFuncStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(313);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::FN
|
|
|
|
|| _la == HogQLParser::FUN)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(314);
|
|
identifier();
|
|
setState(315);
|
|
match(HogQLParser::LPAREN);
|
|
setState(317);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -5800812384855539714) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 25834219896831) != 0)) {
|
|
setState(316);
|
|
identifierList();
|
|
}
|
|
setState(319);
|
|
match(HogQLParser::RPAREN);
|
|
setState(320);
|
|
block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VarAssignmentContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::VarAssignmentContext::VarAssignmentContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::ExpressionContext *> HogQLParser::VarAssignmentContext::expression() {
|
|
return getRuleContexts<HogQLParser::ExpressionContext>();
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::VarAssignmentContext::expression(size_t i) {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::VarAssignmentContext::COLON() {
|
|
return getToken(HogQLParser::COLON, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::VarAssignmentContext::EQ_SINGLE() {
|
|
return getToken(HogQLParser::EQ_SINGLE, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::VarAssignmentContext::getRuleIndex() const {
|
|
return HogQLParser::RuleVarAssignment;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::VarAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitVarAssignment(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::VarAssignmentContext* HogQLParser::varAssignment() {
|
|
VarAssignmentContext *_localctx = _tracker.createInstance<VarAssignmentContext>(_ctx, getState());
|
|
enterRule(_localctx, 30, HogQLParser::RuleVarAssignment);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(322);
|
|
expression();
|
|
setState(323);
|
|
match(HogQLParser::COLON);
|
|
setState(324);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(325);
|
|
expression();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExprStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ExprStmtContext::ExprStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::ExprStmtContext::expression() {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ExprStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::ExprStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleExprStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::ExprStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitExprStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::ExprStmtContext* HogQLParser::exprStmt() {
|
|
ExprStmtContext *_localctx = _tracker.createInstance<ExprStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 32, HogQLParser::RuleExprStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(327);
|
|
expression();
|
|
setState(329);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
|
|
case 1: {
|
|
setState(328);
|
|
match(HogQLParser::SEMICOLON);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EmptyStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::EmptyStmtContext::EmptyStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::EmptyStmtContext::SEMICOLON() {
|
|
return getToken(HogQLParser::SEMICOLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::EmptyStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleEmptyStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::EmptyStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitEmptyStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::EmptyStmtContext* HogQLParser::emptyStmt() {
|
|
EmptyStmtContext *_localctx = _tracker.createInstance<EmptyStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 34, HogQLParser::RuleEmptyStmt);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(331);
|
|
match(HogQLParser::SEMICOLON);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BlockContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::BlockContext::LBRACE() {
|
|
return getToken(HogQLParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::BlockContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::DeclarationContext *> HogQLParser::BlockContext::declaration() {
|
|
return getRuleContexts<HogQLParser::DeclarationContext>();
|
|
}
|
|
|
|
HogQLParser::DeclarationContext* HogQLParser::BlockContext::declaration(size_t i) {
|
|
return getRuleContext<HogQLParser::DeclarationContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::BlockContext::getRuleIndex() const {
|
|
return HogQLParser::RuleBlock;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitBlock(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::block() {
|
|
BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
|
|
enterRule(_localctx, 36, HogQLParser::RuleBlock);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(333);
|
|
match(HogQLParser::LBRACE);
|
|
setState(337);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -140738696331266) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944844006785023) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 4212759) != 0)) {
|
|
setState(334);
|
|
declaration();
|
|
setState(339);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(340);
|
|
match(HogQLParser::RBRACE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- KvPairContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::KvPairContext::KvPairContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::ExpressionContext *> HogQLParser::KvPairContext::expression() {
|
|
return getRuleContexts<HogQLParser::ExpressionContext>();
|
|
}
|
|
|
|
HogQLParser::ExpressionContext* HogQLParser::KvPairContext::expression(size_t i) {
|
|
return getRuleContext<HogQLParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KvPairContext::COLON() {
|
|
return getToken(HogQLParser::COLON, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::KvPairContext::getRuleIndex() const {
|
|
return HogQLParser::RuleKvPair;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::KvPairContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitKvPair(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::KvPairContext* HogQLParser::kvPair() {
|
|
KvPairContext *_localctx = _tracker.createInstance<KvPairContext>(_ctx, getState());
|
|
enterRule(_localctx, 38, HogQLParser::RuleKvPair);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(342);
|
|
expression();
|
|
setState(343);
|
|
match(HogQLParser::COLON);
|
|
setState(344);
|
|
expression();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- KvPairListContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::KvPairListContext::KvPairListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<HogQLParser::KvPairContext *> HogQLParser::KvPairListContext::kvPair() {
|
|
return getRuleContexts<HogQLParser::KvPairContext>();
|
|
}
|
|
|
|
HogQLParser::KvPairContext* HogQLParser::KvPairListContext::kvPair(size_t i) {
|
|
return getRuleContext<HogQLParser::KvPairContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::KvPairListContext::COMMA() {
|
|
return getTokens(HogQLParser::COMMA);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KvPairListContext::COMMA(size_t i) {
|
|
return getToken(HogQLParser::COMMA, i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::KvPairListContext::getRuleIndex() const {
|
|
return HogQLParser::RuleKvPairList;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::KvPairListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitKvPairList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::KvPairListContext* HogQLParser::kvPairList() {
|
|
KvPairListContext *_localctx = _tracker.createInstance<KvPairListContext>(_ctx, getState());
|
|
enterRule(_localctx, 40, HogQLParser::RuleKvPairList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(346);
|
|
kvPair();
|
|
setState(351);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(347);
|
|
match(HogQLParser::COMMA);
|
|
setState(348);
|
|
kvPair();
|
|
}
|
|
setState(353);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx);
|
|
}
|
|
setState(355);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(354);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SelectContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectContext::SelectContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectContext::EOF() {
|
|
return getToken(HogQLParser::EOF, 0);
|
|
}
|
|
|
|
HogQLParser::SelectSetStmtContext* HogQLParser::SelectContext::selectSetStmt() {
|
|
return getRuleContext<HogQLParser::SelectSetStmtContext>(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, 42, HogQLParser::RuleSelect);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(360);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
|
|
case 1: {
|
|
setState(357);
|
|
selectSetStmt();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(358);
|
|
selectStmt();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(359);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(362);
|
|
match(HogQLParser::EOF);
|
|
|
|
}
|
|
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::SelectSetStmtContext* HogQLParser::SelectStmtWithParensContext::selectSetStmt() {
|
|
return getRuleContext<HogQLParser::SelectSetStmtContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SelectStmtWithParensContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::PlaceholderContext* HogQLParser::SelectStmtWithParensContext::placeholder() {
|
|
return getRuleContext<HogQLParser::PlaceholderContext>(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, 44, HogQLParser::RuleSelectStmtWithParens);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(370);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::WITH: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(364);
|
|
selectStmt();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::LPAREN: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(365);
|
|
match(HogQLParser::LPAREN);
|
|
setState(366);
|
|
selectSetStmt();
|
|
setState(367);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(369);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SubsequentSelectSetClauseContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SubsequentSelectSetClauseContext::SubsequentSelectSetClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::SelectStmtWithParensContext* HogQLParser::SubsequentSelectSetClauseContext::selectStmtWithParens() {
|
|
return getRuleContext<HogQLParser::SelectStmtWithParensContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SubsequentSelectSetClauseContext::EXCEPT() {
|
|
return getToken(HogQLParser::EXCEPT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SubsequentSelectSetClauseContext::UNION() {
|
|
return getToken(HogQLParser::UNION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SubsequentSelectSetClauseContext::ALL() {
|
|
return getToken(HogQLParser::ALL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SubsequentSelectSetClauseContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::SubsequentSelectSetClauseContext::INTERSECT() {
|
|
return getToken(HogQLParser::INTERSECT, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SubsequentSelectSetClauseContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSubsequentSelectSetClause;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SubsequentSelectSetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSubsequentSelectSetClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SubsequentSelectSetClauseContext* HogQLParser::subsequentSelectSetClause() {
|
|
SubsequentSelectSetClauseContext *_localctx = _tracker.createInstance<SubsequentSelectSetClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 46, HogQLParser::RuleSubsequentSelectSetClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(380);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
|
|
case 1: {
|
|
setState(372);
|
|
match(HogQLParser::EXCEPT);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(373);
|
|
match(HogQLParser::UNION);
|
|
setState(374);
|
|
match(HogQLParser::ALL);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(375);
|
|
match(HogQLParser::UNION);
|
|
setState(376);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(377);
|
|
match(HogQLParser::INTERSECT);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(378);
|
|
match(HogQLParser::INTERSECT);
|
|
setState(379);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(382);
|
|
selectStmtWithParens();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SelectSetStmtContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::SelectSetStmtContext::SelectSetStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
HogQLParser::SelectStmtWithParensContext* HogQLParser::SelectSetStmtContext::selectStmtWithParens() {
|
|
return getRuleContext<HogQLParser::SelectStmtWithParensContext>(0);
|
|
}
|
|
|
|
std::vector<HogQLParser::SubsequentSelectSetClauseContext *> HogQLParser::SelectSetStmtContext::subsequentSelectSetClause() {
|
|
return getRuleContexts<HogQLParser::SubsequentSelectSetClauseContext>();
|
|
}
|
|
|
|
HogQLParser::SubsequentSelectSetClauseContext* HogQLParser::SelectSetStmtContext::subsequentSelectSetClause(size_t i) {
|
|
return getRuleContext<HogQLParser::SubsequentSelectSetClauseContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::SelectSetStmtContext::getRuleIndex() const {
|
|
return HogQLParser::RuleSelectSetStmt;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::SelectSetStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitSelectSetStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::SelectSetStmtContext* HogQLParser::selectSetStmt() {
|
|
SelectSetStmtContext *_localctx = _tracker.createInstance<SelectSetStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 48, HogQLParser::RuleSelectSetStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(384);
|
|
selectStmtWithParens();
|
|
setState(388);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::EXCEPT
|
|
|
|
|| _la == HogQLParser::INTERSECT || _la == HogQLParser::UNION) {
|
|
setState(385);
|
|
subsequentSelectSetClause();
|
|
setState(390);
|
|
_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;
|
|
}
|
|
|
|
//----------------- 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, 50, HogQLParser::RuleSelectStmt);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(392);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(391);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->with = withClause();
|
|
}
|
|
setState(394);
|
|
match(HogQLParser::SELECT);
|
|
setState(396);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
|
|
case 1: {
|
|
setState(395);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(399);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
|
|
case 1: {
|
|
setState(398);
|
|
topClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(401);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->columns = columnExprList();
|
|
setState(403);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::FROM) {
|
|
setState(402);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->from = fromClause();
|
|
}
|
|
setState(406);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 18084767253659680) != 0)) {
|
|
setState(405);
|
|
arrayJoinClause();
|
|
}
|
|
setState(409);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::PREWHERE) {
|
|
setState(408);
|
|
prewhereClause();
|
|
}
|
|
setState(412);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WHERE) {
|
|
setState(411);
|
|
antlrcpp::downCast<SelectStmtContext *>(_localctx)->where = whereClause();
|
|
}
|
|
setState(415);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::GROUP) {
|
|
setState(414);
|
|
groupByClause();
|
|
}
|
|
setState(419);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
|
|
case 1: {
|
|
setState(417);
|
|
match(HogQLParser::WITH);
|
|
setState(418);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::CUBE
|
|
|
|
|| _la == HogQLParser::ROLLUP)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(423);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(421);
|
|
match(HogQLParser::WITH);
|
|
setState(422);
|
|
match(HogQLParser::TOTALS);
|
|
}
|
|
setState(426);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::HAVING) {
|
|
setState(425);
|
|
havingClause();
|
|
}
|
|
setState(429);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WINDOW) {
|
|
setState(428);
|
|
windowClause();
|
|
}
|
|
setState(432);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ORDER) {
|
|
setState(431);
|
|
orderByClause();
|
|
}
|
|
setState(436);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LIMIT: {
|
|
setState(434);
|
|
limitAndOffsetClause();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::OFFSET: {
|
|
setState(435);
|
|
offsetOnlyClause();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::EOF:
|
|
case HogQLParser::EXCEPT:
|
|
case HogQLParser::INTERSECT:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::RPAREN: {
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(439);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::SETTINGS) {
|
|
setState(438);
|
|
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, 52, HogQLParser::RuleWithClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(441);
|
|
match(HogQLParser::WITH);
|
|
setState(442);
|
|
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, 54, HogQLParser::RuleTopClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(444);
|
|
match(HogQLParser::TOP);
|
|
setState(445);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
setState(448);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
|
|
case 1: {
|
|
setState(446);
|
|
match(HogQLParser::WITH);
|
|
setState(447);
|
|
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, 56, HogQLParser::RuleFromClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(450);
|
|
match(HogQLParser::FROM);
|
|
setState(451);
|
|
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, 58, HogQLParser::RuleArrayJoinClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(454);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::INNER
|
|
|
|
|| _la == HogQLParser::LEFT) {
|
|
setState(453);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::INNER
|
|
|
|
|| _la == HogQLParser::LEFT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(456);
|
|
match(HogQLParser::ARRAY);
|
|
setState(457);
|
|
match(HogQLParser::JOIN);
|
|
setState(458);
|
|
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, 60, HogQLParser::RuleWindowClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(460);
|
|
match(HogQLParser::WINDOW);
|
|
setState(461);
|
|
identifier();
|
|
setState(462);
|
|
match(HogQLParser::AS);
|
|
setState(463);
|
|
match(HogQLParser::LPAREN);
|
|
setState(464);
|
|
windowExpr();
|
|
setState(465);
|
|
match(HogQLParser::RPAREN);
|
|
setState(475);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(466);
|
|
match(HogQLParser::COMMA);
|
|
setState(467);
|
|
identifier();
|
|
setState(468);
|
|
match(HogQLParser::AS);
|
|
setState(469);
|
|
match(HogQLParser::LPAREN);
|
|
setState(470);
|
|
windowExpr();
|
|
setState(471);
|
|
match(HogQLParser::RPAREN);
|
|
setState(477);
|
|
_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, 62, HogQLParser::RulePrewhereClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(478);
|
|
match(HogQLParser::PREWHERE);
|
|
setState(479);
|
|
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, 64, HogQLParser::RuleWhereClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(481);
|
|
match(HogQLParser::WHERE);
|
|
setState(482);
|
|
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, 66, HogQLParser::RuleGroupByClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(484);
|
|
match(HogQLParser::GROUP);
|
|
setState(485);
|
|
match(HogQLParser::BY);
|
|
setState(492);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
|
|
case 1: {
|
|
setState(486);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::CUBE
|
|
|
|
|| _la == HogQLParser::ROLLUP)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(487);
|
|
match(HogQLParser::LPAREN);
|
|
setState(488);
|
|
columnExprList();
|
|
setState(489);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(491);
|
|
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, 68, HogQLParser::RuleHavingClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(494);
|
|
match(HogQLParser::HAVING);
|
|
setState(495);
|
|
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, 70, HogQLParser::RuleOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(497);
|
|
match(HogQLParser::ORDER);
|
|
setState(498);
|
|
match(HogQLParser::BY);
|
|
setState(499);
|
|
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, 72, HogQLParser::RuleProjectionOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(501);
|
|
match(HogQLParser::ORDER);
|
|
setState(502);
|
|
match(HogQLParser::BY);
|
|
setState(503);
|
|
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, 74, HogQLParser::RuleLimitAndOffsetClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(534);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(505);
|
|
match(HogQLParser::LIMIT);
|
|
setState(506);
|
|
columnExpr(0);
|
|
setState(509);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(507);
|
|
match(HogQLParser::COMMA);
|
|
setState(508);
|
|
columnExpr(0);
|
|
}
|
|
setState(515);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::WITH: {
|
|
setState(511);
|
|
match(HogQLParser::WITH);
|
|
setState(512);
|
|
match(HogQLParser::TIES);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::BY: {
|
|
setState(513);
|
|
match(HogQLParser::BY);
|
|
setState(514);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::EOF:
|
|
case HogQLParser::EXCEPT:
|
|
case HogQLParser::INTERSECT:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::RPAREN: {
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(517);
|
|
match(HogQLParser::LIMIT);
|
|
setState(518);
|
|
columnExpr(0);
|
|
setState(521);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::WITH) {
|
|
setState(519);
|
|
match(HogQLParser::WITH);
|
|
setState(520);
|
|
match(HogQLParser::TIES);
|
|
}
|
|
setState(523);
|
|
match(HogQLParser::OFFSET);
|
|
setState(524);
|
|
columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(526);
|
|
match(HogQLParser::LIMIT);
|
|
setState(527);
|
|
columnExpr(0);
|
|
setState(528);
|
|
match(HogQLParser::OFFSET);
|
|
setState(529);
|
|
columnExpr(0);
|
|
setState(532);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::BY) {
|
|
setState(530);
|
|
match(HogQLParser::BY);
|
|
setState(531);
|
|
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, 76, HogQLParser::RuleOffsetOnlyClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(536);
|
|
match(HogQLParser::OFFSET);
|
|
setState(537);
|
|
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, 78, HogQLParser::RuleSettingsClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(539);
|
|
match(HogQLParser::SETTINGS);
|
|
setState(540);
|
|
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 = 80;
|
|
enterRecursionRule(_localctx, 80, 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(554);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<JoinExprTableContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(543);
|
|
tableExpr(0);
|
|
setState(545);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55, _ctx)) {
|
|
case 1: {
|
|
setState(544);
|
|
match(HogQLParser::FINAL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(548);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
|
|
case 1: {
|
|
setState(547);
|
|
sampleClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<JoinExprParensContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(550);
|
|
match(HogQLParser::LPAREN);
|
|
setState(551);
|
|
joinExpr(0);
|
|
setState(552);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(570);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(568);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx)) {
|
|
case 1: {
|
|
auto newContext = _tracker.createInstance<JoinExprCrossOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
|
|
setState(556);
|
|
|
|
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(557);
|
|
joinOpCross();
|
|
setState(558);
|
|
joinExpr(4);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
auto newContext = _tracker.createInstance<JoinExprOpContext>(_tracker.createInstance<JoinExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleJoinExpr);
|
|
setState(560);
|
|
|
|
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(562);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 18084835973136666) != 0) || _la == HogQLParser::RIGHT
|
|
|
|
|| _la == HogQLParser::SEMI) {
|
|
setState(561);
|
|
joinOp();
|
|
}
|
|
setState(564);
|
|
match(HogQLParser::JOIN);
|
|
setState(565);
|
|
joinExpr(0);
|
|
setState(566);
|
|
joinConstraintClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
setState(572);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _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, 82, HogQLParser::RuleJoinOp);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(616);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::JoinOpInnerContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(582);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
|
|
case 1: {
|
|
setState(574);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 274) != 0)) {
|
|
setState(573);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 274) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(576);
|
|
match(HogQLParser::INNER);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(577);
|
|
match(HogQLParser::INNER);
|
|
setState(579);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 274) != 0)) {
|
|
setState(578);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 274) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(581);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 274) != 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(598);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
|
|
case 1: {
|
|
setState(585);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 282) != 0) || _la == HogQLParser::SEMI) {
|
|
setState(584);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 282) != 0) || _la == HogQLParser::SEMI)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(587);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::LEFT
|
|
|
|
|| _la == HogQLParser::RIGHT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(589);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(588);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(591);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::LEFT
|
|
|
|
|| _la == HogQLParser::RIGHT)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(593);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(592);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
setState(596);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 282) != 0) || _la == HogQLParser::SEMI) {
|
|
setState(595);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 282) != 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(614);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
|
|
case 1: {
|
|
setState(601);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY) {
|
|
setState(600);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(603);
|
|
match(HogQLParser::FULL);
|
|
setState(605);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(604);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(607);
|
|
match(HogQLParser::FULL);
|
|
setState(609);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::OUTER) {
|
|
setState(608);
|
|
match(HogQLParser::OUTER);
|
|
}
|
|
setState(612);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ALL
|
|
|
|
|| _la == HogQLParser::ANY) {
|
|
setState(611);
|
|
_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, 84, HogQLParser::RuleJoinOpCross);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(621);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::CROSS: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(618);
|
|
match(HogQLParser::CROSS);
|
|
setState(619);
|
|
match(HogQLParser::JOIN);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::COMMA: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(620);
|
|
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, 86, HogQLParser::RuleJoinConstraintClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(632);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(623);
|
|
match(HogQLParser::ON);
|
|
setState(624);
|
|
columnExprList();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(625);
|
|
match(HogQLParser::USING);
|
|
setState(626);
|
|
match(HogQLParser::LPAREN);
|
|
setState(627);
|
|
columnExprList();
|
|
setState(628);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(630);
|
|
match(HogQLParser::USING);
|
|
setState(631);
|
|
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, 88, HogQLParser::RuleSampleClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(634);
|
|
match(HogQLParser::SAMPLE);
|
|
setState(635);
|
|
ratioExpr();
|
|
setState(638);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 77, _ctx)) {
|
|
case 1: {
|
|
setState(636);
|
|
match(HogQLParser::OFFSET);
|
|
setState(637);
|
|
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, 90, HogQLParser::RuleOrderExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(640);
|
|
orderExpr();
|
|
setState(645);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(641);
|
|
match(HogQLParser::COMMA);
|
|
setState(642);
|
|
orderExpr();
|
|
setState(647);
|
|
_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, 92, HogQLParser::RuleOrderExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(648);
|
|
columnExpr(0);
|
|
setState(650);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 12583040) != 0)) {
|
|
setState(649);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 12583040) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(654);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NULLS) {
|
|
setState(652);
|
|
match(HogQLParser::NULLS);
|
|
setState(653);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::FIRST
|
|
|
|
|| _la == HogQLParser::LAST)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(658);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COLLATE) {
|
|
setState(656);
|
|
match(HogQLParser::COLLATE);
|
|
setState(657);
|
|
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, 94, HogQLParser::RuleRatioExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(666);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(660);
|
|
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(661);
|
|
numberLiteral();
|
|
setState(664);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
|
|
case 1: {
|
|
setState(662);
|
|
match(HogQLParser::SLASH);
|
|
setState(663);
|
|
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, 96, HogQLParser::RuleSettingExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(668);
|
|
settingExpr();
|
|
setState(673);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::COMMA) {
|
|
setState(669);
|
|
match(HogQLParser::COMMA);
|
|
setState(670);
|
|
settingExpr();
|
|
setState(675);
|
|
_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, 98, HogQLParser::RuleSettingExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(676);
|
|
identifier();
|
|
setState(677);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(678);
|
|
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, 100, HogQLParser::RuleWindowExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(681);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::PARTITION) {
|
|
setState(680);
|
|
winPartitionByClause();
|
|
}
|
|
setState(684);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ORDER) {
|
|
setState(683);
|
|
winOrderByClause();
|
|
}
|
|
setState(687);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::RANGE
|
|
|
|
|| _la == HogQLParser::ROWS) {
|
|
setState(686);
|
|
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, 102, HogQLParser::RuleWinPartitionByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(689);
|
|
match(HogQLParser::PARTITION);
|
|
setState(690);
|
|
match(HogQLParser::BY);
|
|
setState(691);
|
|
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, 104, HogQLParser::RuleWinOrderByClause);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(693);
|
|
match(HogQLParser::ORDER);
|
|
setState(694);
|
|
match(HogQLParser::BY);
|
|
setState(695);
|
|
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, 106, HogQLParser::RuleWinFrameClause);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(697);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::RANGE
|
|
|
|
|| _la == HogQLParser::ROWS)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(698);
|
|
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, 108, HogQLParser::RuleWinFrameExtend);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(706);
|
|
_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(700);
|
|
winFrameBound();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::BETWEEN: {
|
|
_localctx = _tracker.createInstance<HogQLParser::FrameBetweenContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(701);
|
|
match(HogQLParser::BETWEEN);
|
|
setState(702);
|
|
winFrameBound();
|
|
setState(703);
|
|
match(HogQLParser::AND);
|
|
setState(704);
|
|
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, 110, HogQLParser::RuleWinFrameBound);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(720);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
|
|
case 1: {
|
|
setState(708);
|
|
match(HogQLParser::CURRENT);
|
|
setState(709);
|
|
match(HogQLParser::ROW);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(710);
|
|
match(HogQLParser::UNBOUNDED);
|
|
setState(711);
|
|
match(HogQLParser::PRECEDING);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(712);
|
|
match(HogQLParser::UNBOUNDED);
|
|
setState(713);
|
|
match(HogQLParser::FOLLOWING);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(714);
|
|
numberLiteral();
|
|
setState(715);
|
|
match(HogQLParser::PRECEDING);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(717);
|
|
numberLiteral();
|
|
setState(718);
|
|
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, 112, HogQLParser::RuleExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(722);
|
|
columnExpr(0);
|
|
setState(723);
|
|
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, 114, HogQLParser::RuleColumnTypeExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
setState(781);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprSimpleContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(725);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprNestedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(726);
|
|
identifier();
|
|
setState(727);
|
|
match(HogQLParser::LPAREN);
|
|
setState(728);
|
|
identifier();
|
|
setState(729);
|
|
columnTypeExpr();
|
|
setState(736);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(730);
|
|
match(HogQLParser::COMMA);
|
|
setState(731);
|
|
identifier();
|
|
setState(732);
|
|
columnTypeExpr();
|
|
}
|
|
setState(738);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
|
|
}
|
|
setState(740);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(739);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
setState(742);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprEnumContext>(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(744);
|
|
identifier();
|
|
setState(745);
|
|
match(HogQLParser::LPAREN);
|
|
setState(746);
|
|
enumValue();
|
|
setState(751);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(747);
|
|
match(HogQLParser::COMMA);
|
|
setState(748);
|
|
enumValue();
|
|
}
|
|
setState(753);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx);
|
|
}
|
|
setState(755);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(754);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
setState(757);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprComplexContext>(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(759);
|
|
identifier();
|
|
setState(760);
|
|
match(HogQLParser::LPAREN);
|
|
setState(761);
|
|
columnTypeExpr();
|
|
setState(766);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(762);
|
|
match(HogQLParser::COMMA);
|
|
setState(763);
|
|
columnTypeExpr();
|
|
}
|
|
setState(768);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
|
|
}
|
|
setState(770);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(769);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
setState(772);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<HogQLParser::ColumnTypeExprParamContext>(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(774);
|
|
identifier();
|
|
setState(775);
|
|
match(HogQLParser::LPAREN);
|
|
setState(777);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(776);
|
|
columnExprList();
|
|
}
|
|
setState(779);
|
|
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, 116, HogQLParser::RuleColumnExprList);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(783);
|
|
columnExpr(0);
|
|
setState(788);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(784);
|
|
match(HogQLParser::COMMA);
|
|
setState(785);
|
|
columnExpr(0);
|
|
}
|
|
setState(790);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx);
|
|
}
|
|
setState(792);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx)) {
|
|
case 1: {
|
|
setState(791);
|
|
match(HogQLParser::COMMA);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
//----------------- 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);
|
|
}
|
|
//----------------- ColumnExprDictContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprDictContext::LBRACE() {
|
|
return getToken(HogQLParser::LBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprDictContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
HogQLParser::KvPairListContext* HogQLParser::ColumnExprDictContext::kvPairList() {
|
|
return getRuleContext<HogQLParser::KvPairListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprDictContext::ColumnExprDictContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprDictContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprDict(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprSubqueryContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprSubqueryContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::SelectSetStmtContext* HogQLParser::ColumnExprSubqueryContext::selectSetStmt() {
|
|
return getRuleContext<HogQLParser::SelectSetStmtContext>(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);
|
|
}
|
|
//----------------- ColumnExprNullTupleAccessContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNullTupleAccessContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullTupleAccessContext::NULL_PROPERTY() {
|
|
return getToken(HogQLParser::NULL_PROPERTY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullTupleAccessContext::DECIMAL_LITERAL() {
|
|
return getToken(HogQLParser::DECIMAL_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNullTupleAccessContext::ColumnExprNullTupleAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNullTupleAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNullTupleAccess(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);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprWinFunctionTargetContext::LPAREN() {
|
|
return getTokens(HogQLParser::LPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::LPAREN(size_t i) {
|
|
return getToken(HogQLParser::LPAREN, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> HogQLParser::ColumnExprWinFunctionTargetContext::RPAREN() {
|
|
return getTokens(HogQLParser::RPAREN);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::RPAREN(size_t i) {
|
|
return getToken(HogQLParser::RPAREN, i);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprListContext *> HogQLParser::ColumnExprWinFunctionTargetContext::columnExprList() {
|
|
return getRuleContexts<HogQLParser::ColumnExprListContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionTargetContext::columnExprList(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 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);
|
|
}
|
|
//----------------- ColumnExprNullPropertyAccessContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNullPropertyAccessContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullPropertyAccessContext::NULL_PROPERTY() {
|
|
return getToken(HogQLParser::NULL_PROPERTY, 0);
|
|
}
|
|
|
|
HogQLParser::IdentifierContext* HogQLParser::ColumnExprNullPropertyAccessContext::identifier() {
|
|
return getRuleContext<HogQLParser::IdentifierContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNullPropertyAccessContext::ColumnExprNullPropertyAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNullPropertyAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNullPropertyAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ColumnExprIntervalStringContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIntervalStringContext::INTERVAL() {
|
|
return getToken(HogQLParser::INTERVAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprIntervalStringContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprIntervalStringContext::ColumnExprIntervalStringContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprIntervalStringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprIntervalString(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);
|
|
}
|
|
|
|
HogQLParser::StringContext* HogQLParser::ColumnExprTrimContext::string() {
|
|
return getRuleContext<HogQLParser::StringContext>(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);
|
|
}
|
|
//----------------- ColumnExprTemplateStringContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TemplateStringContext* HogQLParser::ColumnExprTemplateStringContext::templateString() {
|
|
return getRuleContext<HogQLParser::TemplateStringContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprTemplateStringContext::ColumnExprTemplateStringContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprTemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprTemplateString(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);
|
|
}
|
|
//----------------- ColumnExprCallContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprCallContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCallContext::LPAREN() {
|
|
return getToken(HogQLParser::LPAREN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprCallContext::RPAREN() {
|
|
return getToken(HogQLParser::RPAREN, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprCallContext::columnExprList() {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprCallContext::ColumnExprCallContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprCallContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprCall(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);
|
|
}
|
|
//----------------- ColumnExprNullArrayAccessContext ------------------------------------------------------------------
|
|
|
|
std::vector<HogQLParser::ColumnExprContext *> HogQLParser::ColumnExprNullArrayAccessContext::columnExpr() {
|
|
return getRuleContexts<HogQLParser::ColumnExprContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnExprNullArrayAccessContext::columnExpr(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullArrayAccessContext::NULL_PROPERTY() {
|
|
return getToken(HogQLParser::NULL_PROPERTY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullArrayAccessContext::LBRACKET() {
|
|
return getToken(HogQLParser::LBRACKET, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprNullArrayAccessContext::RBRACKET() {
|
|
return getToken(HogQLParser::RBRACKET, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprNullArrayAccessContext::ColumnExprNullArrayAccessContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprNullArrayAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprNullArrayAccess(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);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprListContext *> HogQLParser::ColumnExprWinFunctionContext::columnExprList() {
|
|
return getRuleContexts<HogQLParser::ColumnExprListContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionContext::columnExprList(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::ColumnExprWinFunctionContext::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 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);
|
|
}
|
|
//----------------- ColumnExprLambdaContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::ColumnLambdaExprContext* HogQLParser::ColumnExprLambdaContext::columnLambdaExpr() {
|
|
return getRuleContext<HogQLParser::ColumnLambdaExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprLambdaContext::ColumnExprLambdaContext(ColumnExprContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
std::any HogQLParser::ColumnExprLambdaContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitColumnExprLambda(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);
|
|
}
|
|
|
|
std::vector<HogQLParser::ColumnExprListContext *> HogQLParser::ColumnExprFunctionContext::columnExprList() {
|
|
return getRuleContexts<HogQLParser::ColumnExprListContext>();
|
|
}
|
|
|
|
HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprFunctionContext::columnExprList(size_t i) {
|
|
return getRuleContext<HogQLParser::ColumnExprListContext>(i);
|
|
}
|
|
|
|
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 = 118;
|
|
enterRecursionRule(_localctx, 118, 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(946);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<ColumnExprCaseContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(795);
|
|
match(HogQLParser::CASE);
|
|
setState(797);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx)) {
|
|
case 1: {
|
|
setState(796);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->caseExpr = columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(804);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(799);
|
|
match(HogQLParser::WHEN);
|
|
setState(800);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->whenExpr = columnExpr(0);
|
|
setState(801);
|
|
match(HogQLParser::THEN);
|
|
setState(802);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->thenExpr = columnExpr(0);
|
|
setState(806);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == HogQLParser::WHEN);
|
|
setState(810);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::ELSE) {
|
|
setState(808);
|
|
match(HogQLParser::ELSE);
|
|
setState(809);
|
|
antlrcpp::downCast<ColumnExprCaseContext *>(_localctx)->elseExpr = columnExpr(0);
|
|
}
|
|
setState(812);
|
|
match(HogQLParser::END);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<ColumnExprCastContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(814);
|
|
match(HogQLParser::CAST);
|
|
setState(815);
|
|
match(HogQLParser::LPAREN);
|
|
setState(816);
|
|
columnExpr(0);
|
|
setState(817);
|
|
match(HogQLParser::AS);
|
|
setState(818);
|
|
columnTypeExpr();
|
|
setState(819);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<ColumnExprDateContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(821);
|
|
match(HogQLParser::DATE);
|
|
setState(822);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<ColumnExprIntervalStringContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(823);
|
|
match(HogQLParser::INTERVAL);
|
|
setState(824);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<ColumnExprIntervalContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(825);
|
|
match(HogQLParser::INTERVAL);
|
|
setState(826);
|
|
columnExpr(0);
|
|
setState(827);
|
|
interval();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
_localctx = _tracker.createInstance<ColumnExprSubstringContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(829);
|
|
match(HogQLParser::SUBSTRING);
|
|
setState(830);
|
|
match(HogQLParser::LPAREN);
|
|
setState(831);
|
|
columnExpr(0);
|
|
setState(832);
|
|
match(HogQLParser::FROM);
|
|
setState(833);
|
|
columnExpr(0);
|
|
setState(836);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::FOR) {
|
|
setState(834);
|
|
match(HogQLParser::FOR);
|
|
setState(835);
|
|
columnExpr(0);
|
|
}
|
|
setState(838);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
_localctx = _tracker.createInstance<ColumnExprTimestampContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(840);
|
|
match(HogQLParser::TIMESTAMP);
|
|
setState(841);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
_localctx = _tracker.createInstance<ColumnExprTrimContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(842);
|
|
match(HogQLParser::TRIM);
|
|
setState(843);
|
|
match(HogQLParser::LPAREN);
|
|
setState(844);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::BOTH
|
|
|
|
|| _la == HogQLParser::LEADING || _la == HogQLParser::TRAILING)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(845);
|
|
string();
|
|
setState(846);
|
|
match(HogQLParser::FROM);
|
|
setState(847);
|
|
columnExpr(0);
|
|
setState(848);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
_localctx = _tracker.createInstance<ColumnExprWinFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(850);
|
|
identifier();
|
|
|
|
setState(851);
|
|
match(HogQLParser::LPAREN);
|
|
setState(853);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(852);
|
|
antlrcpp::downCast<ColumnExprWinFunctionContext *>(_localctx)->columnExprs = columnExprList();
|
|
}
|
|
setState(855);
|
|
match(HogQLParser::RPAREN);
|
|
setState(865);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::LPAREN) {
|
|
setState(857);
|
|
match(HogQLParser::LPAREN);
|
|
setState(859);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
|
|
case 1: {
|
|
setState(858);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(862);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(861);
|
|
antlrcpp::downCast<ColumnExprWinFunctionContext *>(_localctx)->columnArgList = columnExprList();
|
|
}
|
|
setState(864);
|
|
match(HogQLParser::RPAREN);
|
|
}
|
|
setState(867);
|
|
match(HogQLParser::OVER);
|
|
setState(868);
|
|
match(HogQLParser::LPAREN);
|
|
setState(869);
|
|
windowExpr();
|
|
setState(870);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
_localctx = _tracker.createInstance<ColumnExprWinFunctionTargetContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(872);
|
|
identifier();
|
|
|
|
setState(873);
|
|
match(HogQLParser::LPAREN);
|
|
setState(875);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(874);
|
|
antlrcpp::downCast<ColumnExprWinFunctionTargetContext *>(_localctx)->columnExprs = columnExprList();
|
|
}
|
|
setState(877);
|
|
match(HogQLParser::RPAREN);
|
|
setState(887);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::LPAREN) {
|
|
setState(879);
|
|
match(HogQLParser::LPAREN);
|
|
setState(881);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx)) {
|
|
case 1: {
|
|
setState(880);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(884);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(883);
|
|
antlrcpp::downCast<ColumnExprWinFunctionTargetContext *>(_localctx)->columnArgList = columnExprList();
|
|
}
|
|
setState(886);
|
|
match(HogQLParser::RPAREN);
|
|
}
|
|
setState(889);
|
|
match(HogQLParser::OVER);
|
|
setState(890);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
_localctx = _tracker.createInstance<ColumnExprFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(892);
|
|
identifier();
|
|
setState(898);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
|
|
case 1: {
|
|
setState(893);
|
|
match(HogQLParser::LPAREN);
|
|
setState(895);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(894);
|
|
antlrcpp::downCast<ColumnExprFunctionContext *>(_localctx)->columnExprs = columnExprList();
|
|
}
|
|
setState(897);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(900);
|
|
match(HogQLParser::LPAREN);
|
|
setState(902);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
|
|
case 1: {
|
|
setState(901);
|
|
match(HogQLParser::DISTINCT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(905);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(904);
|
|
antlrcpp::downCast<ColumnExprFunctionContext *>(_localctx)->columnArgList = columnExprList();
|
|
}
|
|
setState(907);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
_localctx = _tracker.createInstance<ColumnExprTagElementContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(909);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
_localctx = _tracker.createInstance<ColumnExprTemplateStringContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(910);
|
|
templateString();
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
_localctx = _tracker.createInstance<ColumnExprLiteralContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(911);
|
|
literal();
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
_localctx = _tracker.createInstance<ColumnExprNegateContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(912);
|
|
match(HogQLParser::DASH);
|
|
setState(913);
|
|
columnExpr(20);
|
|
break;
|
|
}
|
|
|
|
case 16: {
|
|
_localctx = _tracker.createInstance<ColumnExprNotContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(914);
|
|
match(HogQLParser::NOT);
|
|
setState(915);
|
|
columnExpr(14);
|
|
break;
|
|
}
|
|
|
|
case 17: {
|
|
_localctx = _tracker.createInstance<ColumnExprAsteriskContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(919);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -5800812384855539714) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 25834219896831) != 0)) {
|
|
setState(916);
|
|
tableIdentifier();
|
|
setState(917);
|
|
match(HogQLParser::DOT);
|
|
}
|
|
setState(921);
|
|
match(HogQLParser::ASTERISK);
|
|
break;
|
|
}
|
|
|
|
case 18: {
|
|
_localctx = _tracker.createInstance<ColumnExprSubqueryContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(922);
|
|
match(HogQLParser::LPAREN);
|
|
setState(923);
|
|
selectSetStmt();
|
|
setState(924);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 19: {
|
|
_localctx = _tracker.createInstance<ColumnExprParensContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(926);
|
|
match(HogQLParser::LPAREN);
|
|
setState(927);
|
|
columnExpr(0);
|
|
setState(928);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 20: {
|
|
_localctx = _tracker.createInstance<ColumnExprTupleContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(930);
|
|
match(HogQLParser::LPAREN);
|
|
setState(931);
|
|
columnExprList();
|
|
setState(932);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 21: {
|
|
_localctx = _tracker.createInstance<ColumnExprArrayContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(934);
|
|
match(HogQLParser::LBRACKET);
|
|
setState(936);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(935);
|
|
columnExprList();
|
|
}
|
|
setState(938);
|
|
match(HogQLParser::RBRACKET);
|
|
break;
|
|
}
|
|
|
|
case 22: {
|
|
_localctx = _tracker.createInstance<ColumnExprDictContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(939);
|
|
match(HogQLParser::LBRACE);
|
|
setState(941);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(940);
|
|
kvPairList();
|
|
}
|
|
setState(943);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 23: {
|
|
_localctx = _tracker.createInstance<ColumnExprLambdaContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(944);
|
|
columnLambdaExpr();
|
|
break;
|
|
}
|
|
|
|
case 24: {
|
|
_localctx = _tracker.createInstance<ColumnExprIdentifierContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(945);
|
|
columnIdentifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(1058);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(1056);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
|
|
case 1: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence1Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(948);
|
|
|
|
if (!(precpred(_ctx, 19))) throw FailedPredicateException(this, "precpred(_ctx, 19)");
|
|
setState(952);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::ASTERISK: {
|
|
setState(949);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::ASTERISK);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::SLASH: {
|
|
setState(950);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::SLASH);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::PERCENT: {
|
|
setState(951);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->operator_ = match(HogQLParser::PERCENT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(954);
|
|
antlrcpp::downCast<ColumnExprPrecedence1Context *>(_localctx)->right = columnExpr(20);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence2Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(955);
|
|
|
|
if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)");
|
|
setState(959);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::PLUS: {
|
|
setState(956);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::PLUS);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DASH: {
|
|
setState(957);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::DASH);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::CONCAT: {
|
|
setState(958);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->operator_ = match(HogQLParser::CONCAT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(961);
|
|
antlrcpp::downCast<ColumnExprPrecedence2Context *>(_localctx)->right = columnExpr(19);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPrecedence3Context>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
newContext->left = previousContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(962);
|
|
|
|
if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)");
|
|
setState(987);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx)) {
|
|
case 1: {
|
|
setState(963);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::EQ_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(964);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::EQ_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(965);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(966);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::LT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(967);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::LT);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
setState(968);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::GT_EQ);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
setState(969);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::GT);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
setState(971);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(970);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT);
|
|
}
|
|
setState(973);
|
|
match(HogQLParser::IN);
|
|
setState(975);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx)) {
|
|
case 1: {
|
|
setState(974);
|
|
match(HogQLParser::COHORT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
setState(978);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(977);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT);
|
|
}
|
|
setState(980);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::ILIKE
|
|
|
|
|| _la == HogQLParser::LIKE)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
setState(981);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::REGEX_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
setState(982);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::REGEX_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
setState(983);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_REGEX);
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
setState(984);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::IREGEX_SINGLE);
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
setState(985);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::IREGEX_DOUBLE);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
setState(986);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->operator_ = match(HogQLParser::NOT_IREGEX);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(989);
|
|
antlrcpp::downCast<ColumnExprPrecedence3Context *>(_localctx)->right = columnExpr(18);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
auto newContext = _tracker.createInstance<ColumnExprNullishContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(990);
|
|
|
|
if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)");
|
|
setState(991);
|
|
match(HogQLParser::NULLISH);
|
|
setState(992);
|
|
columnExpr(16);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
auto newContext = _tracker.createInstance<ColumnExprAndContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(993);
|
|
|
|
if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
|
|
setState(994);
|
|
match(HogQLParser::AND);
|
|
setState(995);
|
|
columnExpr(14);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
auto newContext = _tracker.createInstance<ColumnExprOrContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(996);
|
|
|
|
if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)");
|
|
setState(997);
|
|
match(HogQLParser::OR);
|
|
setState(998);
|
|
columnExpr(13);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
auto newContext = _tracker.createInstance<ColumnExprBetweenContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(999);
|
|
|
|
if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)");
|
|
setState(1001);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(1000);
|
|
match(HogQLParser::NOT);
|
|
}
|
|
setState(1003);
|
|
match(HogQLParser::BETWEEN);
|
|
setState(1004);
|
|
columnExpr(0);
|
|
setState(1005);
|
|
match(HogQLParser::AND);
|
|
setState(1006);
|
|
columnExpr(12);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
auto newContext = _tracker.createInstance<ColumnExprTernaryOpContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1008);
|
|
|
|
if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(1009);
|
|
match(HogQLParser::QUERY);
|
|
setState(1010);
|
|
columnExpr(0);
|
|
setState(1011);
|
|
match(HogQLParser::COLON);
|
|
setState(1012);
|
|
columnExpr(10);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
auto newContext = _tracker.createInstance<ColumnExprCallContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1014);
|
|
|
|
if (!(precpred(_ctx, 30))) throw FailedPredicateException(this, "precpred(_ctx, 30)");
|
|
setState(1015);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1017);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(1016);
|
|
columnExprList();
|
|
}
|
|
setState(1019);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
auto newContext = _tracker.createInstance<ColumnExprArrayAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1020);
|
|
|
|
if (!(precpred(_ctx, 26))) throw FailedPredicateException(this, "precpred(_ctx, 26)");
|
|
setState(1021);
|
|
match(HogQLParser::LBRACKET);
|
|
setState(1022);
|
|
columnExpr(0);
|
|
setState(1023);
|
|
match(HogQLParser::RBRACKET);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
auto newContext = _tracker.createInstance<ColumnExprTupleAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1025);
|
|
|
|
if (!(precpred(_ctx, 25))) throw FailedPredicateException(this, "precpred(_ctx, 25)");
|
|
setState(1026);
|
|
match(HogQLParser::DOT);
|
|
setState(1027);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
auto newContext = _tracker.createInstance<ColumnExprPropertyAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1028);
|
|
|
|
if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)");
|
|
setState(1029);
|
|
match(HogQLParser::DOT);
|
|
setState(1030);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
auto newContext = _tracker.createInstance<ColumnExprNullArrayAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1031);
|
|
|
|
if (!(precpred(_ctx, 23))) throw FailedPredicateException(this, "precpred(_ctx, 23)");
|
|
setState(1032);
|
|
match(HogQLParser::NULL_PROPERTY);
|
|
setState(1033);
|
|
match(HogQLParser::LBRACKET);
|
|
setState(1034);
|
|
columnExpr(0);
|
|
setState(1035);
|
|
match(HogQLParser::RBRACKET);
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
auto newContext = _tracker.createInstance<ColumnExprNullTupleAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1037);
|
|
|
|
if (!(precpred(_ctx, 22))) throw FailedPredicateException(this, "precpred(_ctx, 22)");
|
|
setState(1038);
|
|
match(HogQLParser::NULL_PROPERTY);
|
|
setState(1039);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
auto newContext = _tracker.createInstance<ColumnExprNullPropertyAccessContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1040);
|
|
|
|
if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)");
|
|
setState(1041);
|
|
match(HogQLParser::NULL_PROPERTY);
|
|
setState(1042);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 16: {
|
|
auto newContext = _tracker.createInstance<ColumnExprIsNullContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1043);
|
|
|
|
if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
|
|
setState(1044);
|
|
match(HogQLParser::IS);
|
|
setState(1046);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::NOT) {
|
|
setState(1045);
|
|
match(HogQLParser::NOT);
|
|
}
|
|
setState(1048);
|
|
match(HogQLParser::NULL_SQL);
|
|
break;
|
|
}
|
|
|
|
case 17: {
|
|
auto newContext = _tracker.createInstance<ColumnExprAliasContext>(_tracker.createInstance<ColumnExprContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleColumnExpr);
|
|
setState(1049);
|
|
|
|
if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)");
|
|
setState(1054);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
|
|
case 1: {
|
|
setState(1050);
|
|
match(HogQLParser::AS);
|
|
setState(1051);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(1052);
|
|
match(HogQLParser::AS);
|
|
setState(1053);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
setState(1060);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::ColumnLambdaExprContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
HogQLParser::BlockContext* HogQLParser::ColumnLambdaExprContext::block() {
|
|
return getRuleContext<HogQLParser::BlockContext>(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, 120, HogQLParser::RuleColumnLambdaExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1088);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 136, _ctx)) {
|
|
case 1: {
|
|
setState(1061);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1062);
|
|
identifier();
|
|
setState(1067);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 132, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(1063);
|
|
match(HogQLParser::COMMA);
|
|
setState(1064);
|
|
identifier();
|
|
}
|
|
setState(1069);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 132, _ctx);
|
|
}
|
|
setState(1071);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(1070);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
setState(1073);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(1075);
|
|
identifier();
|
|
setState(1080);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(1076);
|
|
match(HogQLParser::COMMA);
|
|
setState(1077);
|
|
identifier();
|
|
}
|
|
setState(1082);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx);
|
|
}
|
|
setState(1084);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(1083);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(1086);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1087);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(1090);
|
|
match(HogQLParser::ARROW);
|
|
setState(1093);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx)) {
|
|
case 1: {
|
|
setState(1091);
|
|
columnExpr(0);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(1092);
|
|
block();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
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);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::LBRACE() {
|
|
return getToken(HogQLParser::LBRACE, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::HogqlxTagElementNestedContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 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, 122, HogQLParser::RuleHogqlxTagElement);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1127);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::HogqlxTagElementClosedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1095);
|
|
match(HogQLParser::LT);
|
|
setState(1096);
|
|
identifier();
|
|
setState(1100);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -5800812384855539714) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 25834219896831) != 0)) {
|
|
setState(1097);
|
|
hogqlxTagAttribute();
|
|
setState(1102);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1103);
|
|
match(HogQLParser::SLASH);
|
|
setState(1104);
|
|
match(HogQLParser::GT);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::HogqlxTagElementNestedContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1106);
|
|
match(HogQLParser::LT);
|
|
setState(1107);
|
|
identifier();
|
|
setState(1111);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -5800812384855539714) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 25834219896831) != 0)) {
|
|
setState(1108);
|
|
hogqlxTagAttribute();
|
|
setState(1113);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1114);
|
|
match(HogQLParser::GT);
|
|
setState(1120);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx)) {
|
|
case 1: {
|
|
setState(1115);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(1116);
|
|
match(HogQLParser::LBRACE);
|
|
setState(1117);
|
|
columnExpr(0);
|
|
setState(1118);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(1122);
|
|
match(HogQLParser::LT);
|
|
setState(1123);
|
|
match(HogQLParser::SLASH);
|
|
setState(1124);
|
|
identifier();
|
|
setState(1125);
|
|
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);
|
|
}
|
|
|
|
HogQLParser::StringContext* HogQLParser::HogqlxTagAttributeContext::string() {
|
|
return getRuleContext<HogQLParser::StringContext>(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, 124, HogQLParser::RuleHogqlxTagAttribute);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1140);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1129);
|
|
identifier();
|
|
setState(1130);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(1131);
|
|
string();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1133);
|
|
identifier();
|
|
setState(1134);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(1135);
|
|
match(HogQLParser::LBRACE);
|
|
setState(1136);
|
|
columnExpr(0);
|
|
setState(1137);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(1139);
|
|
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, 126, HogQLParser::RuleWithExprList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1142);
|
|
withExpr();
|
|
setState(1147);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(1143);
|
|
match(HogQLParser::COMMA);
|
|
setState(1144);
|
|
withExpr();
|
|
}
|
|
setState(1149);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx);
|
|
}
|
|
setState(1151);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(1150);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
|
|
}
|
|
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::SelectSetStmtContext* HogQLParser::WithExprSubqueryContext::selectSetStmt() {
|
|
return getRuleContext<HogQLParser::SelectSetStmtContext>(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, 128, HogQLParser::RuleWithExpr);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1163);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<HogQLParser::WithExprSubqueryContext>(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1153);
|
|
identifier();
|
|
setState(1154);
|
|
match(HogQLParser::AS);
|
|
setState(1155);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1156);
|
|
selectSetStmt();
|
|
setState(1157);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<HogQLParser::WithExprColumnContext>(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1159);
|
|
columnExpr(0);
|
|
setState(1160);
|
|
match(HogQLParser::AS);
|
|
setState(1161);
|
|
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, 130, HogQLParser::RuleColumnIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1172);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::LBRACE: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1165);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::COHORT:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DAY:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::HOUR:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::MINUTE:
|
|
case HogQLParser::MONTH:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::QUARTER:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RETURN:
|
|
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::SETTINGS:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::WEEK:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH:
|
|
case HogQLParser::YEAR:
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1169);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 146, _ctx)) {
|
|
case 1: {
|
|
setState(1166);
|
|
tableIdentifier();
|
|
setState(1167);
|
|
match(HogQLParser::DOT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(1171);
|
|
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, 132, HogQLParser::RuleNestedIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1174);
|
|
identifier();
|
|
setState(1179);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(1175);
|
|
match(HogQLParser::DOT);
|
|
setState(1176);
|
|
identifier();
|
|
}
|
|
setState(1181);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _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::SelectSetStmtContext* HogQLParser::TableExprSubqueryContext::selectSetStmt() {
|
|
return getRuleContext<HogQLParser::SelectSetStmtContext>(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 = 134;
|
|
enterRecursionRule(_localctx, 134, 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(1191);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<TableExprIdentifierContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(1183);
|
|
tableIdentifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<TableExprFunctionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(1184);
|
|
tableFunctionExpr();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<TableExprSubqueryContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(1185);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1186);
|
|
selectSetStmt();
|
|
setState(1187);
|
|
match(HogQLParser::RPAREN);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<TableExprTagContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(1189);
|
|
hogqlxTagElement();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<TableExprPlaceholderContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(1190);
|
|
placeholder();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(1201);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _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(1193);
|
|
|
|
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(1197);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::IDENTIFIER: {
|
|
setState(1194);
|
|
alias();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::AS: {
|
|
setState(1195);
|
|
match(HogQLParser::AS);
|
|
setState(1196);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
}
|
|
setState(1203);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _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, 136, HogQLParser::RuleTableFunctionExpr);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1204);
|
|
identifier();
|
|
setState(1205);
|
|
match(HogQLParser::LPAREN);
|
|
setState(1207);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -36169677449216002) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 723944289947615231) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 131)) & 18455) != 0)) {
|
|
setState(1206);
|
|
tableArgList();
|
|
}
|
|
setState(1209);
|
|
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, 138, HogQLParser::RuleTableIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1214);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx)) {
|
|
case 1: {
|
|
setState(1211);
|
|
databaseIdentifier();
|
|
setState(1212);
|
|
match(HogQLParser::DOT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
setState(1216);
|
|
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, 140, HogQLParser::RuleTableArgList);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1218);
|
|
columnExpr(0);
|
|
setState(1223);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(1219);
|
|
match(HogQLParser::COMMA);
|
|
setState(1220);
|
|
columnExpr(0);
|
|
}
|
|
setState(1225);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx);
|
|
}
|
|
setState(1227);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::COMMA) {
|
|
setState(1226);
|
|
match(HogQLParser::COMMA);
|
|
}
|
|
|
|
}
|
|
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, 142, HogQLParser::RuleDatabaseIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1229);
|
|
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, 144, HogQLParser::RuleFloatingLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1239);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::FLOATING_LITERAL: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1231);
|
|
match(HogQLParser::FLOATING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DOT: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1232);
|
|
match(HogQLParser::DOT);
|
|
setState(1233);
|
|
_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(1234);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
setState(1235);
|
|
match(HogQLParser::DOT);
|
|
setState(1237);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx)) {
|
|
case 1: {
|
|
setState(1236);
|
|
_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, 146, HogQLParser::RuleNumberLiteral);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1242);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == HogQLParser::DASH
|
|
|
|
|| _la == HogQLParser::PLUS) {
|
|
setState(1241);
|
|
_la = _input->LA(1);
|
|
if (!(_la == HogQLParser::DASH
|
|
|
|
|| _la == HogQLParser::PLUS)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
setState(1250);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _ctx)) {
|
|
case 1: {
|
|
setState(1244);
|
|
floatingLiteral();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(1245);
|
|
match(HogQLParser::OCTAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(1246);
|
|
match(HogQLParser::DECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(1247);
|
|
match(HogQLParser::HEXADECIMAL_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(1248);
|
|
match(HogQLParser::INF);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
setState(1249);
|
|
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, 148, HogQLParser::RuleLiteral);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1255);
|
|
_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(1252);
|
|
numberLiteral();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::STRING_LITERAL: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1253);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::NULL_SQL: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(1254);
|
|
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, 150, HogQLParser::RuleInterval);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1257);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 864692227968860160) != 0) || ((((_la - 73) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 73)) & 8724152577) != 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::ALL() {
|
|
return getToken(HogQLParser::ALL, 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::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::COHORT() {
|
|
return getToken(HogQLParser::COHORT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::COLLATE() {
|
|
return getToken(HogQLParser::COLLATE, 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::DATE() {
|
|
return getToken(HogQLParser::DATE, 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::DISTINCT() {
|
|
return getToken(HogQLParser::DISTINCT, 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::EXTRACT() {
|
|
return getToken(HogQLParser::EXTRACT, 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::FOR() {
|
|
return getToken(HogQLParser::FOR, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::FOLLOWING() {
|
|
return getToken(HogQLParser::FOLLOWING, 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::GROUP() {
|
|
return getToken(HogQLParser::GROUP, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::HAVING() {
|
|
return getToken(HogQLParser::HAVING, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::ID() {
|
|
return getToken(HogQLParser::ID, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::IS() {
|
|
return getToken(HogQLParser::IS, 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::INNER() {
|
|
return getToken(HogQLParser::INNER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::INTERVAL() {
|
|
return getToken(HogQLParser::INTERVAL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::JOIN() {
|
|
return getToken(HogQLParser::JOIN, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::KEY() {
|
|
return getToken(HogQLParser::KEY, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LAST() {
|
|
return getToken(HogQLParser::LAST, 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::LIKE() {
|
|
return getToken(HogQLParser::LIKE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::LIMIT() {
|
|
return getToken(HogQLParser::LIMIT, 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::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::OVER() {
|
|
return getToken(HogQLParser::OVER, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::PARTITION() {
|
|
return getToken(HogQLParser::PARTITION, 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::RANGE() {
|
|
return getToken(HogQLParser::RANGE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::RETURN() {
|
|
return getToken(HogQLParser::RETURN, 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::SETTINGS() {
|
|
return getToken(HogQLParser::SETTINGS, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::SUBSTRING() {
|
|
return getToken(HogQLParser::SUBSTRING, 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::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::UNBOUNDED() {
|
|
return getToken(HogQLParser::UNBOUNDED, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::UNION() {
|
|
return getToken(HogQLParser::UNION, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::KeywordContext::USING() {
|
|
return getToken(HogQLParser::USING, 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, 152, HogQLParser::RuleKeyword);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1259);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & -6665504612824399874) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 64)) & 3775267732991) != 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, 154, HogQLParser::RuleKeywordForAlias);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1261);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & 2254000985473024) != 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, 156, HogQLParser::RuleAlias);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1265);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1263);
|
|
match(HogQLParser::IDENTIFIER);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::KEY: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1264);
|
|
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, 158, HogQLParser::RuleIdentifier);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1270);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::IDENTIFIER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1267);
|
|
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(1268);
|
|
interval();
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::ALL:
|
|
case HogQLParser::AND:
|
|
case HogQLParser::ANTI:
|
|
case HogQLParser::ANY:
|
|
case HogQLParser::ARRAY:
|
|
case HogQLParser::AS:
|
|
case HogQLParser::ASCENDING:
|
|
case HogQLParser::ASOF:
|
|
case HogQLParser::BETWEEN:
|
|
case HogQLParser::BOTH:
|
|
case HogQLParser::BY:
|
|
case HogQLParser::CASE:
|
|
case HogQLParser::CAST:
|
|
case HogQLParser::COHORT:
|
|
case HogQLParser::COLLATE:
|
|
case HogQLParser::CROSS:
|
|
case HogQLParser::CUBE:
|
|
case HogQLParser::CURRENT:
|
|
case HogQLParser::DATE:
|
|
case HogQLParser::DESC:
|
|
case HogQLParser::DESCENDING:
|
|
case HogQLParser::DISTINCT:
|
|
case HogQLParser::ELSE:
|
|
case HogQLParser::END:
|
|
case HogQLParser::EXTRACT:
|
|
case HogQLParser::FINAL:
|
|
case HogQLParser::FIRST:
|
|
case HogQLParser::FOLLOWING:
|
|
case HogQLParser::FOR:
|
|
case HogQLParser::FROM:
|
|
case HogQLParser::FULL:
|
|
case HogQLParser::GROUP:
|
|
case HogQLParser::HAVING:
|
|
case HogQLParser::ID:
|
|
case HogQLParser::IF:
|
|
case HogQLParser::ILIKE:
|
|
case HogQLParser::IN:
|
|
case HogQLParser::INNER:
|
|
case HogQLParser::INTERVAL:
|
|
case HogQLParser::IS:
|
|
case HogQLParser::JOIN:
|
|
case HogQLParser::KEY:
|
|
case HogQLParser::LAST:
|
|
case HogQLParser::LEADING:
|
|
case HogQLParser::LEFT:
|
|
case HogQLParser::LIKE:
|
|
case HogQLParser::LIMIT:
|
|
case HogQLParser::NOT:
|
|
case HogQLParser::NULLS:
|
|
case HogQLParser::OFFSET:
|
|
case HogQLParser::ON:
|
|
case HogQLParser::OR:
|
|
case HogQLParser::ORDER:
|
|
case HogQLParser::OUTER:
|
|
case HogQLParser::OVER:
|
|
case HogQLParser::PARTITION:
|
|
case HogQLParser::PRECEDING:
|
|
case HogQLParser::PREWHERE:
|
|
case HogQLParser::RANGE:
|
|
case HogQLParser::RETURN:
|
|
case HogQLParser::RIGHT:
|
|
case HogQLParser::ROLLUP:
|
|
case HogQLParser::ROW:
|
|
case HogQLParser::ROWS:
|
|
case HogQLParser::SAMPLE:
|
|
case HogQLParser::SELECT:
|
|
case HogQLParser::SEMI:
|
|
case HogQLParser::SETTINGS:
|
|
case HogQLParser::SUBSTRING:
|
|
case HogQLParser::THEN:
|
|
case HogQLParser::TIES:
|
|
case HogQLParser::TIMESTAMP:
|
|
case HogQLParser::TO:
|
|
case HogQLParser::TOP:
|
|
case HogQLParser::TOTALS:
|
|
case HogQLParser::TRAILING:
|
|
case HogQLParser::TRIM:
|
|
case HogQLParser::TRUNCATE:
|
|
case HogQLParser::UNBOUNDED:
|
|
case HogQLParser::UNION:
|
|
case HogQLParser::USING:
|
|
case HogQLParser::WHEN:
|
|
case HogQLParser::WHERE:
|
|
case HogQLParser::WINDOW:
|
|
case HogQLParser::WITH: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(1269);
|
|
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) {
|
|
}
|
|
|
|
HogQLParser::StringContext* HogQLParser::EnumValueContext::string() {
|
|
return getRuleContext<HogQLParser::StringContext>(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, 160, HogQLParser::RuleEnumValue);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1272);
|
|
string();
|
|
setState(1273);
|
|
match(HogQLParser::EQ_SINGLE);
|
|
setState(1274);
|
|
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::ColumnExprContext* HogQLParser::PlaceholderContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(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, 162, HogQLParser::RulePlaceholder);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1276);
|
|
match(HogQLParser::LBRACE);
|
|
setState(1277);
|
|
columnExpr(0);
|
|
setState(1278);
|
|
match(HogQLParser::RBRACE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StringContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::StringContext::StringContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContext::STRING_LITERAL() {
|
|
return getToken(HogQLParser::STRING_LITERAL, 0);
|
|
}
|
|
|
|
HogQLParser::TemplateStringContext* HogQLParser::StringContext::templateString() {
|
|
return getRuleContext<HogQLParser::TemplateStringContext>(0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::StringContext::getRuleIndex() const {
|
|
return HogQLParser::RuleString;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::StringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitString(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::StringContext* HogQLParser::string() {
|
|
StringContext *_localctx = _tracker.createInstance<StringContext>(_ctx, getState());
|
|
enterRule(_localctx, 164, HogQLParser::RuleString);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1282);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::STRING_LITERAL: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1280);
|
|
match(HogQLParser::STRING_LITERAL);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::QUOTE_SINGLE_TEMPLATE: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1281);
|
|
templateString();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TemplateStringContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::TemplateStringContext::TemplateStringContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TemplateStringContext::QUOTE_SINGLE_TEMPLATE() {
|
|
return getToken(HogQLParser::QUOTE_SINGLE_TEMPLATE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::TemplateStringContext::QUOTE_SINGLE() {
|
|
return getToken(HogQLParser::QUOTE_SINGLE, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::StringContentsContext *> HogQLParser::TemplateStringContext::stringContents() {
|
|
return getRuleContexts<HogQLParser::StringContentsContext>();
|
|
}
|
|
|
|
HogQLParser::StringContentsContext* HogQLParser::TemplateStringContext::stringContents(size_t i) {
|
|
return getRuleContext<HogQLParser::StringContentsContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::TemplateStringContext::getRuleIndex() const {
|
|
return HogQLParser::RuleTemplateString;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::TemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitTemplateString(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::TemplateStringContext* HogQLParser::templateString() {
|
|
TemplateStringContext *_localctx = _tracker.createInstance<TemplateStringContext>(_ctx, getState());
|
|
enterRule(_localctx, 166, HogQLParser::RuleTemplateString);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1284);
|
|
match(HogQLParser::QUOTE_SINGLE_TEMPLATE);
|
|
setState(1288);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::STRING_TEXT
|
|
|
|
|| _la == HogQLParser::STRING_ESCAPE_TRIGGER) {
|
|
setState(1285);
|
|
stringContents();
|
|
setState(1290);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1291);
|
|
match(HogQLParser::QUOTE_SINGLE);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StringContentsContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::StringContentsContext::StringContentsContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsContext::STRING_ESCAPE_TRIGGER() {
|
|
return getToken(HogQLParser::STRING_ESCAPE_TRIGGER, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::StringContentsContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsContext::STRING_TEXT() {
|
|
return getToken(HogQLParser::STRING_TEXT, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::StringContentsContext::getRuleIndex() const {
|
|
return HogQLParser::RuleStringContents;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::StringContentsContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitStringContents(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::StringContentsContext* HogQLParser::stringContents() {
|
|
StringContentsContext *_localctx = _tracker.createInstance<StringContentsContext>(_ctx, getState());
|
|
enterRule(_localctx, 168, HogQLParser::RuleStringContents);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1298);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::STRING_ESCAPE_TRIGGER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1293);
|
|
match(HogQLParser::STRING_ESCAPE_TRIGGER);
|
|
setState(1294);
|
|
columnExpr(0);
|
|
setState(1295);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::STRING_TEXT: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1297);
|
|
match(HogQLParser::STRING_TEXT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FullTemplateStringContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::FullTemplateStringContext::FullTemplateStringContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FullTemplateStringContext::QUOTE_SINGLE_TEMPLATE_FULL() {
|
|
return getToken(HogQLParser::QUOTE_SINGLE_TEMPLATE_FULL, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::FullTemplateStringContext::EOF() {
|
|
return getToken(HogQLParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<HogQLParser::StringContentsFullContext *> HogQLParser::FullTemplateStringContext::stringContentsFull() {
|
|
return getRuleContexts<HogQLParser::StringContentsFullContext>();
|
|
}
|
|
|
|
HogQLParser::StringContentsFullContext* HogQLParser::FullTemplateStringContext::stringContentsFull(size_t i) {
|
|
return getRuleContext<HogQLParser::StringContentsFullContext>(i);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::FullTemplateStringContext::getRuleIndex() const {
|
|
return HogQLParser::RuleFullTemplateString;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::FullTemplateStringContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitFullTemplateString(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::FullTemplateStringContext* HogQLParser::fullTemplateString() {
|
|
FullTemplateStringContext *_localctx = _tracker.createInstance<FullTemplateStringContext>(_ctx, getState());
|
|
enterRule(_localctx, 170, HogQLParser::RuleFullTemplateString);
|
|
size_t _la = 0;
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1300);
|
|
match(HogQLParser::QUOTE_SINGLE_TEMPLATE_FULL);
|
|
setState(1304);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == HogQLParser::FULL_STRING_TEXT
|
|
|
|
|| _la == HogQLParser::FULL_STRING_ESCAPE_TRIGGER) {
|
|
setState(1301);
|
|
stringContentsFull();
|
|
setState(1306);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1307);
|
|
match(HogQLParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StringContentsFullContext ------------------------------------------------------------------
|
|
|
|
HogQLParser::StringContentsFullContext::StringContentsFullContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsFullContext::FULL_STRING_ESCAPE_TRIGGER() {
|
|
return getToken(HogQLParser::FULL_STRING_ESCAPE_TRIGGER, 0);
|
|
}
|
|
|
|
HogQLParser::ColumnExprContext* HogQLParser::StringContentsFullContext::columnExpr() {
|
|
return getRuleContext<HogQLParser::ColumnExprContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsFullContext::RBRACE() {
|
|
return getToken(HogQLParser::RBRACE, 0);
|
|
}
|
|
|
|
tree::TerminalNode* HogQLParser::StringContentsFullContext::FULL_STRING_TEXT() {
|
|
return getToken(HogQLParser::FULL_STRING_TEXT, 0);
|
|
}
|
|
|
|
|
|
size_t HogQLParser::StringContentsFullContext::getRuleIndex() const {
|
|
return HogQLParser::RuleStringContentsFull;
|
|
}
|
|
|
|
|
|
std::any HogQLParser::StringContentsFullContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<HogQLParserVisitor*>(visitor))
|
|
return parserVisitor->visitStringContentsFull(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
HogQLParser::StringContentsFullContext* HogQLParser::stringContentsFull() {
|
|
StringContentsFullContext *_localctx = _tracker.createInstance<StringContentsFullContext>(_ctx, getState());
|
|
enterRule(_localctx, 172, HogQLParser::RuleStringContentsFull);
|
|
|
|
#if __cplusplus > 201703L
|
|
auto onExit = finally([=, this] {
|
|
#else
|
|
auto onExit = finally([=] {
|
|
#endif
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1314);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case HogQLParser::FULL_STRING_ESCAPE_TRIGGER: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1309);
|
|
match(HogQLParser::FULL_STRING_ESCAPE_TRIGGER);
|
|
setState(1310);
|
|
columnExpr(0);
|
|
setState(1311);
|
|
match(HogQLParser::RBRACE);
|
|
break;
|
|
}
|
|
|
|
case HogQLParser::FULL_STRING_TEXT: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1313);
|
|
match(HogQLParser::FULL_STRING_TEXT);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
bool HogQLParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
|
|
switch (ruleIndex) {
|
|
case 40: return joinExprSempred(antlrcpp::downCast<JoinExprContext *>(context), predicateIndex);
|
|
case 59: return columnExprSempred(antlrcpp::downCast<ColumnExprContext *>(context), predicateIndex);
|
|
case 67: 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, 19);
|
|
case 3: return precpred(_ctx, 18);
|
|
case 4: return precpred(_ctx, 17);
|
|
case 5: return precpred(_ctx, 15);
|
|
case 6: return precpred(_ctx, 13);
|
|
case 7: return precpred(_ctx, 12);
|
|
case 8: return precpred(_ctx, 11);
|
|
case 9: return precpred(_ctx, 10);
|
|
case 10: return precpred(_ctx, 30);
|
|
case 11: return precpred(_ctx, 26);
|
|
case 12: return precpred(_ctx, 25);
|
|
case 13: return precpred(_ctx, 24);
|
|
case 14: return precpred(_ctx, 23);
|
|
case 15: return precpred(_ctx, 22);
|
|
case 16: return precpred(_ctx, 21);
|
|
case 17: return precpred(_ctx, 16);
|
|
case 18: return precpred(_ctx, 9);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HogQLParser::tableExprSempred(TableExprContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 19: 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
|
|
}
|