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