// Generated from HogQLParser.g4 by ANTLR 4.13.1 #include "HogQLParserVisitor.h" #include "HogQLParser.h" using namespace antlrcpp; using namespace antlr4; namespace { struct HogQLParserStaticData final { HogQLParserStaticData(std::vector 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 HogQLParserStaticData *hogqlparserParserStaticData = nullptr; void hogqlparserParserInitialize() { #if ANTLR4_USE_THREAD_LOCAL_CACHE if (hogqlparserParserStaticData != nullptr) { return; } #else assert(hogqlparserParserStaticData == nullptr); #endif auto staticData = std::make_unique( std::vector{ "select", "selectUnionStmt", "selectStmtWithParens", "selectStmt", "withClause", "topClause", "fromClause", "arrayJoinClause", "windowClause", "prewhereClause", "whereClause", "groupByClause", "havingClause", "orderByClause", "projectionOrderByClause", "limitAndOffsetClause", "offsetOnlyClause", "settingsClause", "joinExpr", "joinOp", "joinOpCross", "joinConstraintClause", "sampleClause", "orderExprList", "orderExpr", "ratioExpr", "settingExprList", "settingExpr", "windowExpr", "winPartitionByClause", "winOrderByClause", "winFrameClause", "winFrameExtend", "winFrameBound", "expr", "columnTypeExpr", "columnExprList", "columnExpr", "columnArgList", "columnArgExpr", "columnLambdaExpr", "hogqlxTagElement", "hogqlxTagAttribute", "withExprList", "withExpr", "columnIdentifier", "nestedIdentifier", "tableExpr", "tableFunctionExpr", "tableIdentifier", "tableArgList", "databaseIdentifier", "floatingLiteral", "numberLiteral", "literal", "interval", "keyword", "keywordForAlias", "alias", "identifier", "enumValue", "placeholder" }, std::vector{ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'false'", "'true'", "", "", "", "", "", "", "", "", "'->'", "'*'", "'`'", "'\\'", "':'", "','", "'||'", "'-'", "'$'", "'.'", "'=='", "'='", "'>='", "'>'", "'#'", "'~*'", "'=~*'", "'{'", "'['", "'('", "'<='", "'<'", "", "'!~*'", "'!~'", "'\\u003F\\u003F'", "'%'", "'+'", "'\\u003F'", "'\"'", "'''", "'~'", "'=~'", "'}'", "']'", "')'", "';'", "'/'", "'_'" }, std::vector{ "", "ADD", "AFTER", "ALIAS", "ALL", "ALTER", "AND", "ANTI", "ANY", "ARRAY", "AS", "ASCENDING", "ASOF", "AST", "ASYNC", "ATTACH", "BETWEEN", "BOTH", "BY", "CASE", "CAST", "CHECK", "CLEAR", "CLUSTER", "CODEC", "COHORT", "COLLATE", "COLUMN", "COMMENT", "CONSTRAINT", "CREATE", "CROSS", "CUBE", "CURRENT", "DATABASE", "DATABASES", "DATE", "DAY", "DEDUPLICATE", "DEFAULT", "DELAY", "DELETE", "DESC", "DESCENDING", "DESCRIBE", "DETACH", "DICTIONARIES", "DICTIONARY", "DISK", "DISTINCT", "DISTRIBUTED", "DROP", "ELSE", "END", "ENGINE", "EVENTS", "EXISTS", "EXPLAIN", "EXPRESSION", "EXTRACT", "FETCHES", "FINAL", "FIRST", "FLUSH", "FOLLOWING", "FOR", "FORMAT", "FREEZE", "FROM", "FULL", "FUNCTION", "GLOBAL", "GRANULARITY", "GROUP", "HAVING", "HIERARCHICAL", "HOUR", "ID", "IF", "ILIKE", "IN", "INDEX", "INF", "INJECTIVE", "INNER", "INSERT", "INTERVAL", "INTO", "IS", "IS_OBJECT_ID", "JOIN", "KEY", "KILL", "LAST", "LAYOUT", "LEADING", "LEFT", "LIFETIME", "LIKE", "LIMIT", "LIVE", "LOCAL", "LOGS", "MATERIALIZE", "MATERIALIZED", "MAX", "MERGES", "MIN", "MINUTE", "MODIFY", "MONTH", "MOVE", "MUTATION", "NAN_SQL", "NO", "NOT", "NULL_SQL", "NULLS", "OFFSET", "ON", "OPTIMIZE", "OR", "ORDER", "OUTER", "OUTFILE", "OVER", "PARTITION", "POPULATE", "PRECEDING", "PREWHERE", "PRIMARY", "PROJECTION", "QUARTER", "RANGE", "RELOAD", "REMOVE", "RENAME", "REPLACE", "REPLICA", "REPLICATED", "RIGHT", "ROLLUP", "ROW", "ROWS", "SAMPLE", "SECOND", "SELECT", "SEMI", "SENDS", "SET", "SETTINGS", "SHOW", "SOURCE", "START", "STOP", "SUBSTRING", "SYNC", "SYNTAX", "SYSTEM", "TABLE", "TABLES", "TEMPORARY", "TEST", "THEN", "TIES", "TIMEOUT", "TIMESTAMP", "TO", "TOP", "TOTALS", "TRAILING", "TRIM", "TRUNCATE", "TTL", "TYPE", "UNBOUNDED", "UNION", "UPDATE", "USE", "USING", "UUID", "VALUES", "VIEW", "VOLUME", "WATCH", "WEEK", "WHEN", "WHERE", "WINDOW", "WITH", "YEAR", "JSON_FALSE", "JSON_TRUE", "ESCAPE_CHAR_SINGLE", "ESCAPE_CHAR_DOUBLE", "IDENTIFIER", "FLOATING_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL", "HEXADECIMAL_LITERAL", "STRING_LITERAL", "ARROW", "ASTERISK", "BACKQUOTE", "BACKSLASH", "COLON", "COMMA", "CONCAT", "DASH", "DOLLAR", "DOT", "EQ_DOUBLE", "EQ_SINGLE", "GT_EQ", "GT", "HASH", "IREGEX_SINGLE", "IREGEX_DOUBLE", "LBRACE", "LBRACKET", "LPAREN", "LT_EQ", "LT", "NOT_EQ", "NOT_IREGEX", "NOT_REGEX", "NULLISH", "PERCENT", "PLUS", "QUERY", "QUOTE_DOUBLE", "QUOTE_SINGLE", "REGEX_SINGLE", "REGEX_DOUBLE", "RBRACE", "RBRACKET", "RPAREN", "SEMICOLON", "SLASH", "UNDERSCORE", "MULTI_LINE_COMMENT", "SINGLE_LINE_COMMENT", "WHITESPACE" } ); static const int32_t serializedATNSegment[] = { 4,1,242,972,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2, 7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7, 14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,7, 21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,7, 28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,7, 35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,7, 42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7, 49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7, 56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,1,0,1,0,1,0,3,0, 128,8,0,1,0,1,0,1,1,1,1,1,1,1,1,5,1,136,8,1,10,1,12,1,139,9,1,1,2,1,2, 1,2,1,2,1,2,1,2,3,2,147,8,2,1,3,3,3,150,8,3,1,3,1,3,3,3,154,8,3,1,3,3, 3,157,8,3,1,3,1,3,3,3,161,8,3,1,3,3,3,164,8,3,1,3,3,3,167,8,3,1,3,3,3, 170,8,3,1,3,3,3,173,8,3,1,3,1,3,3,3,177,8,3,1,3,1,3,3,3,181,8,3,1,3,3, 3,184,8,3,1,3,3,3,187,8,3,1,3,3,3,190,8,3,1,3,1,3,3,3,194,8,3,1,3,3,3, 197,8,3,1,4,1,4,1,4,1,5,1,5,1,5,1,5,3,5,206,8,5,1,6,1,6,1,6,1,7,3,7,212, 8,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1, 8,5,8,231,8,8,10,8,12,8,234,9,8,1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11, 1,11,1,11,1,11,1,11,1,11,1,11,3,11,250,8,11,1,12,1,12,1,12,1,13,1,13, 1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,3,15,267,8,15,1,15, 1,15,1,15,1,15,3,15,273,8,15,1,15,1,15,1,15,1,15,3,15,279,8,15,1,15,1, 15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,290,8,15,3,15,292,8,15,1,16, 1,16,1,16,1,17,1,17,1,17,1,18,1,18,1,18,3,18,303,8,18,1,18,3,18,306,8, 18,1,18,1,18,1,18,1,18,3,18,312,8,18,1,18,1,18,1,18,1,18,1,18,1,18,3, 18,320,8,18,1,18,1,18,1,18,1,18,5,18,326,8,18,10,18,12,18,329,9,18,1, 19,3,19,332,8,19,1,19,1,19,1,19,3,19,337,8,19,1,19,3,19,340,8,19,1,19, 3,19,343,8,19,1,19,1,19,3,19,347,8,19,1,19,1,19,3,19,351,8,19,1,19,3, 19,354,8,19,3,19,356,8,19,1,19,3,19,359,8,19,1,19,1,19,3,19,363,8,19, 1,19,1,19,3,19,367,8,19,1,19,3,19,370,8,19,3,19,372,8,19,3,19,374,8,19, 1,20,1,20,1,20,3,20,379,8,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21, 1,21,3,21,390,8,21,1,22,1,22,1,22,1,22,3,22,396,8,22,1,23,1,23,1,23,5, 23,401,8,23,10,23,12,23,404,9,23,1,24,1,24,3,24,408,8,24,1,24,1,24,3, 24,412,8,24,1,24,1,24,3,24,416,8,24,1,25,1,25,1,25,1,25,3,25,422,8,25, 3,25,424,8,25,1,26,1,26,1,26,5,26,429,8,26,10,26,12,26,432,9,26,1,27, 1,27,1,27,1,27,1,28,3,28,439,8,28,1,28,3,28,442,8,28,1,28,3,28,445,8, 28,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,32,1,32,1, 32,1,32,1,32,1,32,3,32,464,8,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1, 33,1,33,1,33,1,33,1,33,3,33,478,8,33,1,34,1,34,1,34,1,35,1,35,1,35,1, 35,1,35,1,35,1,35,1,35,1,35,5,35,492,8,35,10,35,12,35,495,9,35,1,35,1, 35,1,35,1,35,1,35,1,35,1,35,5,35,504,8,35,10,35,12,35,507,9,35,1,35,1, 35,1,35,1,35,1,35,1,35,1,35,5,35,516,8,35,10,35,12,35,519,9,35,1,35,1, 35,1,35,1,35,1,35,3,35,526,8,35,1,35,1,35,3,35,530,8,35,1,36,1,36,1,36, 5,36,535,8,36,10,36,12,36,538,9,36,1,37,1,37,1,37,3,37,543,8,37,1,37, 1,37,1,37,1,37,1,37,4,37,550,8,37,11,37,12,37,551,1,37,1,37,3,37,556, 8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37, 1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,580,8,37,1,37,1,37, 1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37, 597,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,609,8, 37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,619,8,37,1,37,3,37,622, 8,37,1,37,1,37,3,37,626,8,37,1,37,3,37,629,8,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,642,8,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,659,8,37,1, 37,1,37,3,37,663,8,37,1,37,1,37,1,37,1,37,3,37,669,8,37,1,37,1,37,1,37, 1,37,1,37,3,37,676,8,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37, 1,37,3,37,688,8,37,1,37,1,37,3,37,692,8,37,1,37,3,37,695,8,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,3,37,704,8,37,1,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,718,8,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,745,8,37,1,37,1,37,1,37,1,37,1, 37,1,37,1,37,3,37,754,8,37,5,37,756,8,37,10,37,12,37,759,9,37,1,38,1, 38,1,38,5,38,764,8,38,10,38,12,38,767,9,38,1,39,1,39,3,39,771,8,39,1, 40,1,40,1,40,1,40,5,40,777,8,40,10,40,12,40,780,9,40,1,40,1,40,1,40,1, 40,1,40,5,40,787,8,40,10,40,12,40,790,9,40,3,40,792,8,40,1,40,1,40,1, 40,1,41,1,41,1,41,5,41,800,8,41,10,41,12,41,803,9,41,1,41,1,41,1,41,1, 41,1,41,1,41,5,41,811,8,41,10,41,12,41,814,9,41,1,41,1,41,3,41,818,8, 41,1,41,1,41,1,41,1,41,1,41,3,41,825,8,41,1,42,1,42,1,42,1,42,1,42,1, 42,1,42,1,42,1,42,1,42,1,42,3,42,838,8,42,1,43,1,43,1,43,5,43,843,8,43, 10,43,12,43,846,9,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, 3,44,858,8,44,1,45,1,45,1,45,1,45,3,45,864,8,45,1,45,3,45,867,8,45,1, 46,1,46,1,46,5,46,872,8,46,10,46,12,46,875,9,46,1,47,1,47,1,47,1,47,1, 47,1,47,1,47,1,47,1,47,3,47,886,8,47,1,47,1,47,1,47,1,47,3,47,892,8,47, 5,47,894,8,47,10,47,12,47,897,9,47,1,48,1,48,1,48,3,48,902,8,48,1,48, 1,48,1,49,1,49,1,49,3,49,909,8,49,1,49,1,49,1,50,1,50,1,50,5,50,916,8, 50,10,50,12,50,919,9,50,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,3,52, 929,8,52,3,52,931,8,52,1,53,3,53,934,8,53,1,53,1,53,1,53,1,53,1,53,1, 53,3,53,942,8,53,1,54,1,54,1,54,3,54,947,8,54,1,55,1,55,1,56,1,56,1,57, 1,57,1,58,1,58,3,58,957,8,58,1,59,1,59,1,59,3,59,962,8,59,1,60,1,60,1, 60,1,60,1,61,1,61,1,61,1,61,1,61,0,3,36,74,94,62,0,2,4,6,8,10,12,14,16, 18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62, 64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106, 108,110,112,114,116,118,120,122,0,16,2,0,32,32,141,141,2,0,84,84,96,96, 3,0,4,4,8,8,12,12,4,0,4,4,7,8,12,12,147,147,2,0,96,96,140,140,2,0,4,4, 8,8,2,0,11,11,42,43,2,0,62,62,93,93,2,0,133,133,143,143,3,0,17,17,95, 95,170,170,2,0,79,79,98,98,1,0,197,198,2,0,208,208,228,228,8,0,37,37, 76,76,108,108,110,110,132,132,145,145,185,185,190,190,13,0,2,24,26,36, 38,75,77,81,83,107,109,109,111,112,114,115,117,130,133,144,146,184,186, 189,191,192,4,0,36,36,62,62,77,77,91,91,1099,0,127,1,0,0,0,2,131,1,0, 0,0,4,146,1,0,0,0,6,149,1,0,0,0,8,198,1,0,0,0,10,201,1,0,0,0,12,207,1, 0,0,0,14,211,1,0,0,0,16,217,1,0,0,0,18,235,1,0,0,0,20,238,1,0,0,0,22, 241,1,0,0,0,24,251,1,0,0,0,26,254,1,0,0,0,28,258,1,0,0,0,30,291,1,0,0, 0,32,293,1,0,0,0,34,296,1,0,0,0,36,311,1,0,0,0,38,373,1,0,0,0,40,378, 1,0,0,0,42,389,1,0,0,0,44,391,1,0,0,0,46,397,1,0,0,0,48,405,1,0,0,0,50, 423,1,0,0,0,52,425,1,0,0,0,54,433,1,0,0,0,56,438,1,0,0,0,58,446,1,0,0, 0,60,450,1,0,0,0,62,454,1,0,0,0,64,463,1,0,0,0,66,477,1,0,0,0,68,479, 1,0,0,0,70,529,1,0,0,0,72,531,1,0,0,0,74,662,1,0,0,0,76,760,1,0,0,0,78, 770,1,0,0,0,80,791,1,0,0,0,82,824,1,0,0,0,84,837,1,0,0,0,86,839,1,0,0, 0,88,857,1,0,0,0,90,866,1,0,0,0,92,868,1,0,0,0,94,885,1,0,0,0,96,898, 1,0,0,0,98,908,1,0,0,0,100,912,1,0,0,0,102,920,1,0,0,0,104,930,1,0,0, 0,106,933,1,0,0,0,108,946,1,0,0,0,110,948,1,0,0,0,112,950,1,0,0,0,114, 952,1,0,0,0,116,956,1,0,0,0,118,961,1,0,0,0,120,963,1,0,0,0,122,967,1, 0,0,0,124,128,3,2,1,0,125,128,3,6,3,0,126,128,3,82,41,0,127,124,1,0,0, 0,127,125,1,0,0,0,127,126,1,0,0,0,128,129,1,0,0,0,129,130,5,0,0,1,130, 1,1,0,0,0,131,137,3,4,2,0,132,133,5,176,0,0,133,134,5,4,0,0,134,136,3, 4,2,0,135,132,1,0,0,0,136,139,1,0,0,0,137,135,1,0,0,0,137,138,1,0,0,0, 138,3,1,0,0,0,139,137,1,0,0,0,140,147,3,6,3,0,141,142,5,220,0,0,142,143, 3,2,1,0,143,144,5,236,0,0,144,147,1,0,0,0,145,147,3,122,61,0,146,140, 1,0,0,0,146,141,1,0,0,0,146,145,1,0,0,0,147,5,1,0,0,0,148,150,3,8,4,0, 149,148,1,0,0,0,149,150,1,0,0,0,150,151,1,0,0,0,151,153,5,146,0,0,152, 154,5,49,0,0,153,152,1,0,0,0,153,154,1,0,0,0,154,156,1,0,0,0,155,157, 3,10,5,0,156,155,1,0,0,0,156,157,1,0,0,0,157,158,1,0,0,0,158,160,3,72, 36,0,159,161,3,12,6,0,160,159,1,0,0,0,160,161,1,0,0,0,161,163,1,0,0,0, 162,164,3,14,7,0,163,162,1,0,0,0,163,164,1,0,0,0,164,166,1,0,0,0,165, 167,3,18,9,0,166,165,1,0,0,0,166,167,1,0,0,0,167,169,1,0,0,0,168,170, 3,20,10,0,169,168,1,0,0,0,169,170,1,0,0,0,170,172,1,0,0,0,171,173,3,22, 11,0,172,171,1,0,0,0,172,173,1,0,0,0,173,176,1,0,0,0,174,175,5,189,0, 0,175,177,7,0,0,0,176,174,1,0,0,0,176,177,1,0,0,0,177,180,1,0,0,0,178, 179,5,189,0,0,179,181,5,169,0,0,180,178,1,0,0,0,180,181,1,0,0,0,181,183, 1,0,0,0,182,184,3,24,12,0,183,182,1,0,0,0,183,184,1,0,0,0,184,186,1,0, 0,0,185,187,3,16,8,0,186,185,1,0,0,0,186,187,1,0,0,0,187,189,1,0,0,0, 188,190,3,26,13,0,189,188,1,0,0,0,189,190,1,0,0,0,190,193,1,0,0,0,191, 194,3,30,15,0,192,194,3,32,16,0,193,191,1,0,0,0,193,192,1,0,0,0,193,194, 1,0,0,0,194,196,1,0,0,0,195,197,3,34,17,0,196,195,1,0,0,0,196,197,1,0, 0,0,197,7,1,0,0,0,198,199,5,189,0,0,199,200,3,86,43,0,200,9,1,0,0,0,201, 202,5,168,0,0,202,205,5,198,0,0,203,204,5,189,0,0,204,206,5,164,0,0,205, 203,1,0,0,0,205,206,1,0,0,0,206,11,1,0,0,0,207,208,5,68,0,0,208,209,3, 36,18,0,209,13,1,0,0,0,210,212,7,1,0,0,211,210,1,0,0,0,211,212,1,0,0, 0,212,213,1,0,0,0,213,214,5,9,0,0,214,215,5,90,0,0,215,216,3,72,36,0, 216,15,1,0,0,0,217,218,5,188,0,0,218,219,3,118,59,0,219,220,5,10,0,0, 220,221,5,220,0,0,221,222,3,56,28,0,222,232,5,236,0,0,223,224,5,206,0, 0,224,225,3,118,59,0,225,226,5,10,0,0,226,227,5,220,0,0,227,228,3,56, 28,0,228,229,5,236,0,0,229,231,1,0,0,0,230,223,1,0,0,0,231,234,1,0,0, 0,232,230,1,0,0,0,232,233,1,0,0,0,233,17,1,0,0,0,234,232,1,0,0,0,235, 236,5,129,0,0,236,237,3,74,37,0,237,19,1,0,0,0,238,239,5,187,0,0,239, 240,3,74,37,0,240,21,1,0,0,0,241,242,5,73,0,0,242,249,5,18,0,0,243,244, 7,0,0,0,244,245,5,220,0,0,245,246,3,72,36,0,246,247,5,236,0,0,247,250, 1,0,0,0,248,250,3,72,36,0,249,243,1,0,0,0,249,248,1,0,0,0,250,23,1,0, 0,0,251,252,5,74,0,0,252,253,3,74,37,0,253,25,1,0,0,0,254,255,5,122,0, 0,255,256,5,18,0,0,256,257,3,46,23,0,257,27,1,0,0,0,258,259,5,122,0,0, 259,260,5,18,0,0,260,261,3,72,36,0,261,29,1,0,0,0,262,263,5,99,0,0,263, 266,3,74,37,0,264,265,5,206,0,0,265,267,3,74,37,0,266,264,1,0,0,0,266, 267,1,0,0,0,267,272,1,0,0,0,268,269,5,189,0,0,269,273,5,164,0,0,270,271, 5,18,0,0,271,273,3,72,36,0,272,268,1,0,0,0,272,270,1,0,0,0,272,273,1, 0,0,0,273,292,1,0,0,0,274,275,5,99,0,0,275,278,3,74,37,0,276,277,5,189, 0,0,277,279,5,164,0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,280,1,0,0,0, 280,281,5,118,0,0,281,282,3,74,37,0,282,292,1,0,0,0,283,284,5,99,0,0, 284,285,3,74,37,0,285,286,5,118,0,0,286,289,3,74,37,0,287,288,5,18,0, 0,288,290,3,72,36,0,289,287,1,0,0,0,289,290,1,0,0,0,290,292,1,0,0,0,291, 262,1,0,0,0,291,274,1,0,0,0,291,283,1,0,0,0,292,31,1,0,0,0,293,294,5, 118,0,0,294,295,3,74,37,0,295,33,1,0,0,0,296,297,5,150,0,0,297,298,3, 52,26,0,298,35,1,0,0,0,299,300,6,18,-1,0,300,302,3,94,47,0,301,303,5, 61,0,0,302,301,1,0,0,0,302,303,1,0,0,0,303,305,1,0,0,0,304,306,3,44,22, 0,305,304,1,0,0,0,305,306,1,0,0,0,306,312,1,0,0,0,307,308,5,220,0,0,308, 309,3,36,18,0,309,310,5,236,0,0,310,312,1,0,0,0,311,299,1,0,0,0,311,307, 1,0,0,0,312,327,1,0,0,0,313,314,10,3,0,0,314,315,3,40,20,0,315,316,3, 36,18,4,316,326,1,0,0,0,317,319,10,4,0,0,318,320,3,38,19,0,319,318,1, 0,0,0,319,320,1,0,0,0,320,321,1,0,0,0,321,322,5,90,0,0,322,323,3,36,18, 0,323,324,3,42,21,0,324,326,1,0,0,0,325,313,1,0,0,0,325,317,1,0,0,0,326, 329,1,0,0,0,327,325,1,0,0,0,327,328,1,0,0,0,328,37,1,0,0,0,329,327,1, 0,0,0,330,332,7,2,0,0,331,330,1,0,0,0,331,332,1,0,0,0,332,333,1,0,0,0, 333,340,5,84,0,0,334,336,5,84,0,0,335,337,7,2,0,0,336,335,1,0,0,0,336, 337,1,0,0,0,337,340,1,0,0,0,338,340,7,2,0,0,339,331,1,0,0,0,339,334,1, 0,0,0,339,338,1,0,0,0,340,374,1,0,0,0,341,343,7,3,0,0,342,341,1,0,0,0, 342,343,1,0,0,0,343,344,1,0,0,0,344,346,7,4,0,0,345,347,5,123,0,0,346, 345,1,0,0,0,346,347,1,0,0,0,347,356,1,0,0,0,348,350,7,4,0,0,349,351,5, 123,0,0,350,349,1,0,0,0,350,351,1,0,0,0,351,353,1,0,0,0,352,354,7,3,0, 0,353,352,1,0,0,0,353,354,1,0,0,0,354,356,1,0,0,0,355,342,1,0,0,0,355, 348,1,0,0,0,356,374,1,0,0,0,357,359,7,5,0,0,358,357,1,0,0,0,358,359,1, 0,0,0,359,360,1,0,0,0,360,362,5,69,0,0,361,363,5,123,0,0,362,361,1,0, 0,0,362,363,1,0,0,0,363,372,1,0,0,0,364,366,5,69,0,0,365,367,5,123,0, 0,366,365,1,0,0,0,366,367,1,0,0,0,367,369,1,0,0,0,368,370,7,5,0,0,369, 368,1,0,0,0,369,370,1,0,0,0,370,372,1,0,0,0,371,358,1,0,0,0,371,364,1, 0,0,0,372,374,1,0,0,0,373,339,1,0,0,0,373,355,1,0,0,0,373,371,1,0,0,0, 374,39,1,0,0,0,375,376,5,31,0,0,376,379,5,90,0,0,377,379,5,206,0,0,378, 375,1,0,0,0,378,377,1,0,0,0,379,41,1,0,0,0,380,381,5,119,0,0,381,390, 3,72,36,0,382,383,5,179,0,0,383,384,5,220,0,0,384,385,3,72,36,0,385,386, 5,236,0,0,386,390,1,0,0,0,387,388,5,179,0,0,388,390,3,72,36,0,389,380, 1,0,0,0,389,382,1,0,0,0,389,387,1,0,0,0,390,43,1,0,0,0,391,392,5,144, 0,0,392,395,3,50,25,0,393,394,5,118,0,0,394,396,3,50,25,0,395,393,1,0, 0,0,395,396,1,0,0,0,396,45,1,0,0,0,397,402,3,48,24,0,398,399,5,206,0, 0,399,401,3,48,24,0,400,398,1,0,0,0,401,404,1,0,0,0,402,400,1,0,0,0,402, 403,1,0,0,0,403,47,1,0,0,0,404,402,1,0,0,0,405,407,3,74,37,0,406,408, 7,6,0,0,407,406,1,0,0,0,407,408,1,0,0,0,408,411,1,0,0,0,409,410,5,117, 0,0,410,412,7,7,0,0,411,409,1,0,0,0,411,412,1,0,0,0,412,415,1,0,0,0,413, 414,5,26,0,0,414,416,5,200,0,0,415,413,1,0,0,0,415,416,1,0,0,0,416,49, 1,0,0,0,417,424,3,122,61,0,418,421,3,106,53,0,419,420,5,238,0,0,420,422, 3,106,53,0,421,419,1,0,0,0,421,422,1,0,0,0,422,424,1,0,0,0,423,417,1, 0,0,0,423,418,1,0,0,0,424,51,1,0,0,0,425,430,3,54,27,0,426,427,5,206, 0,0,427,429,3,54,27,0,428,426,1,0,0,0,429,432,1,0,0,0,430,428,1,0,0,0, 430,431,1,0,0,0,431,53,1,0,0,0,432,430,1,0,0,0,433,434,3,118,59,0,434, 435,5,212,0,0,435,436,3,108,54,0,436,55,1,0,0,0,437,439,3,58,29,0,438, 437,1,0,0,0,438,439,1,0,0,0,439,441,1,0,0,0,440,442,3,60,30,0,441,440, 1,0,0,0,441,442,1,0,0,0,442,444,1,0,0,0,443,445,3,62,31,0,444,443,1,0, 0,0,444,445,1,0,0,0,445,57,1,0,0,0,446,447,5,126,0,0,447,448,5,18,0,0, 448,449,3,72,36,0,449,59,1,0,0,0,450,451,5,122,0,0,451,452,5,18,0,0,452, 453,3,46,23,0,453,61,1,0,0,0,454,455,7,8,0,0,455,456,3,64,32,0,456,63, 1,0,0,0,457,464,3,66,33,0,458,459,5,16,0,0,459,460,3,66,33,0,460,461, 5,6,0,0,461,462,3,66,33,0,462,464,1,0,0,0,463,457,1,0,0,0,463,458,1,0, 0,0,464,65,1,0,0,0,465,466,5,33,0,0,466,478,5,142,0,0,467,468,5,175,0, 0,468,478,5,128,0,0,469,470,5,175,0,0,470,478,5,64,0,0,471,472,3,106, 53,0,472,473,5,128,0,0,473,478,1,0,0,0,474,475,3,106,53,0,475,476,5,64, 0,0,476,478,1,0,0,0,477,465,1,0,0,0,477,467,1,0,0,0,477,469,1,0,0,0,477, 471,1,0,0,0,477,474,1,0,0,0,478,67,1,0,0,0,479,480,3,74,37,0,480,481, 5,0,0,1,481,69,1,0,0,0,482,530,3,118,59,0,483,484,3,118,59,0,484,485, 5,220,0,0,485,486,3,118,59,0,486,493,3,70,35,0,487,488,5,206,0,0,488, 489,3,118,59,0,489,490,3,70,35,0,490,492,1,0,0,0,491,487,1,0,0,0,492, 495,1,0,0,0,493,491,1,0,0,0,493,494,1,0,0,0,494,496,1,0,0,0,495,493,1, 0,0,0,496,497,5,236,0,0,497,530,1,0,0,0,498,499,3,118,59,0,499,500,5, 220,0,0,500,505,3,120,60,0,501,502,5,206,0,0,502,504,3,120,60,0,503,501, 1,0,0,0,504,507,1,0,0,0,505,503,1,0,0,0,505,506,1,0,0,0,506,508,1,0,0, 0,507,505,1,0,0,0,508,509,5,236,0,0,509,530,1,0,0,0,510,511,3,118,59, 0,511,512,5,220,0,0,512,517,3,70,35,0,513,514,5,206,0,0,514,516,3,70, 35,0,515,513,1,0,0,0,516,519,1,0,0,0,517,515,1,0,0,0,517,518,1,0,0,0, 518,520,1,0,0,0,519,517,1,0,0,0,520,521,5,236,0,0,521,530,1,0,0,0,522, 523,3,118,59,0,523,525,5,220,0,0,524,526,3,72,36,0,525,524,1,0,0,0,525, 526,1,0,0,0,526,527,1,0,0,0,527,528,5,236,0,0,528,530,1,0,0,0,529,482, 1,0,0,0,529,483,1,0,0,0,529,498,1,0,0,0,529,510,1,0,0,0,529,522,1,0,0, 0,530,71,1,0,0,0,531,536,3,74,37,0,532,533,5,206,0,0,533,535,3,74,37, 0,534,532,1,0,0,0,535,538,1,0,0,0,536,534,1,0,0,0,536,537,1,0,0,0,537, 73,1,0,0,0,538,536,1,0,0,0,539,540,6,37,-1,0,540,542,5,19,0,0,541,543, 3,74,37,0,542,541,1,0,0,0,542,543,1,0,0,0,543,549,1,0,0,0,544,545,5,186, 0,0,545,546,3,74,37,0,546,547,5,163,0,0,547,548,3,74,37,0,548,550,1,0, 0,0,549,544,1,0,0,0,550,551,1,0,0,0,551,549,1,0,0,0,551,552,1,0,0,0,552, 555,1,0,0,0,553,554,5,52,0,0,554,556,3,74,37,0,555,553,1,0,0,0,555,556, 1,0,0,0,556,557,1,0,0,0,557,558,5,53,0,0,558,663,1,0,0,0,559,560,5,20, 0,0,560,561,5,220,0,0,561,562,3,74,37,0,562,563,5,10,0,0,563,564,3,70, 35,0,564,565,5,236,0,0,565,663,1,0,0,0,566,567,5,36,0,0,567,663,5,200, 0,0,568,569,5,86,0,0,569,570,3,74,37,0,570,571,3,110,55,0,571,663,1,0, 0,0,572,573,5,155,0,0,573,574,5,220,0,0,574,575,3,74,37,0,575,576,5,68, 0,0,576,579,3,74,37,0,577,578,5,65,0,0,578,580,3,74,37,0,579,577,1,0, 0,0,579,580,1,0,0,0,580,581,1,0,0,0,581,582,5,236,0,0,582,663,1,0,0,0, 583,584,5,166,0,0,584,663,5,200,0,0,585,586,5,171,0,0,586,587,5,220,0, 0,587,588,7,9,0,0,588,589,5,200,0,0,589,590,5,68,0,0,590,591,3,74,37, 0,591,592,5,236,0,0,592,663,1,0,0,0,593,594,3,118,59,0,594,596,5,220, 0,0,595,597,3,72,36,0,596,595,1,0,0,0,596,597,1,0,0,0,597,598,1,0,0,0, 598,599,5,236,0,0,599,600,1,0,0,0,600,601,5,125,0,0,601,602,5,220,0,0, 602,603,3,56,28,0,603,604,5,236,0,0,604,663,1,0,0,0,605,606,3,118,59, 0,606,608,5,220,0,0,607,609,3,72,36,0,608,607,1,0,0,0,608,609,1,0,0,0, 609,610,1,0,0,0,610,611,5,236,0,0,611,612,1,0,0,0,612,613,5,125,0,0,613, 614,3,118,59,0,614,663,1,0,0,0,615,621,3,118,59,0,616,618,5,220,0,0,617, 619,3,72,36,0,618,617,1,0,0,0,618,619,1,0,0,0,619,620,1,0,0,0,620,622, 5,236,0,0,621,616,1,0,0,0,621,622,1,0,0,0,622,623,1,0,0,0,623,625,5,220, 0,0,624,626,5,49,0,0,625,624,1,0,0,0,625,626,1,0,0,0,626,628,1,0,0,0, 627,629,3,76,38,0,628,627,1,0,0,0,628,629,1,0,0,0,629,630,1,0,0,0,630, 631,5,236,0,0,631,663,1,0,0,0,632,663,3,82,41,0,633,663,3,108,54,0,634, 635,5,208,0,0,635,663,3,74,37,18,636,637,5,115,0,0,637,663,3,74,37,12, 638,639,3,98,49,0,639,640,5,210,0,0,640,642,1,0,0,0,641,638,1,0,0,0,641, 642,1,0,0,0,642,643,1,0,0,0,643,663,5,202,0,0,644,645,5,220,0,0,645,646, 3,2,1,0,646,647,5,236,0,0,647,663,1,0,0,0,648,649,5,220,0,0,649,650,3, 74,37,0,650,651,5,236,0,0,651,663,1,0,0,0,652,653,5,220,0,0,653,654,3, 72,36,0,654,655,5,236,0,0,655,663,1,0,0,0,656,658,5,219,0,0,657,659,3, 72,36,0,658,657,1,0,0,0,658,659,1,0,0,0,659,660,1,0,0,0,660,663,5,235, 0,0,661,663,3,90,45,0,662,539,1,0,0,0,662,559,1,0,0,0,662,566,1,0,0,0, 662,568,1,0,0,0,662,572,1,0,0,0,662,583,1,0,0,0,662,585,1,0,0,0,662,593, 1,0,0,0,662,605,1,0,0,0,662,615,1,0,0,0,662,632,1,0,0,0,662,633,1,0,0, 0,662,634,1,0,0,0,662,636,1,0,0,0,662,641,1,0,0,0,662,644,1,0,0,0,662, 648,1,0,0,0,662,652,1,0,0,0,662,656,1,0,0,0,662,661,1,0,0,0,663,757,1, 0,0,0,664,668,10,17,0,0,665,669,5,202,0,0,666,669,5,238,0,0,667,669,5, 227,0,0,668,665,1,0,0,0,668,666,1,0,0,0,668,667,1,0,0,0,669,670,1,0,0, 0,670,756,3,74,37,18,671,675,10,16,0,0,672,676,5,228,0,0,673,676,5,208, 0,0,674,676,5,207,0,0,675,672,1,0,0,0,675,673,1,0,0,0,675,674,1,0,0,0, 676,677,1,0,0,0,677,756,3,74,37,17,678,703,10,15,0,0,679,704,5,211,0, 0,680,704,5,212,0,0,681,704,5,223,0,0,682,704,5,221,0,0,683,704,5,222, 0,0,684,704,5,213,0,0,685,704,5,214,0,0,686,688,5,115,0,0,687,686,1,0, 0,0,687,688,1,0,0,0,688,689,1,0,0,0,689,691,5,80,0,0,690,692,5,25,0,0, 691,690,1,0,0,0,691,692,1,0,0,0,692,704,1,0,0,0,693,695,5,115,0,0,694, 693,1,0,0,0,694,695,1,0,0,0,695,696,1,0,0,0,696,704,7,10,0,0,697,704, 5,232,0,0,698,704,5,233,0,0,699,704,5,225,0,0,700,704,5,216,0,0,701,704, 5,217,0,0,702,704,5,224,0,0,703,679,1,0,0,0,703,680,1,0,0,0,703,681,1, 0,0,0,703,682,1,0,0,0,703,683,1,0,0,0,703,684,1,0,0,0,703,685,1,0,0,0, 703,687,1,0,0,0,703,694,1,0,0,0,703,697,1,0,0,0,703,698,1,0,0,0,703,699, 1,0,0,0,703,700,1,0,0,0,703,701,1,0,0,0,703,702,1,0,0,0,704,705,1,0,0, 0,705,756,3,74,37,16,706,707,10,13,0,0,707,708,5,226,0,0,708,756,3,74, 37,14,709,710,10,11,0,0,710,711,5,6,0,0,711,756,3,74,37,12,712,713,10, 10,0,0,713,714,5,121,0,0,714,756,3,74,37,11,715,717,10,9,0,0,716,718, 5,115,0,0,717,716,1,0,0,0,717,718,1,0,0,0,718,719,1,0,0,0,719,720,5,16, 0,0,720,721,3,74,37,0,721,722,5,6,0,0,722,723,3,74,37,10,723,756,1,0, 0,0,724,725,10,8,0,0,725,726,5,229,0,0,726,727,3,74,37,0,727,728,5,205, 0,0,728,729,3,74,37,8,729,756,1,0,0,0,730,731,10,21,0,0,731,732,5,219, 0,0,732,733,3,74,37,0,733,734,5,235,0,0,734,756,1,0,0,0,735,736,10,20, 0,0,736,737,5,210,0,0,737,756,5,198,0,0,738,739,10,19,0,0,739,740,5,210, 0,0,740,756,3,118,59,0,741,742,10,14,0,0,742,744,5,88,0,0,743,745,5,115, 0,0,744,743,1,0,0,0,744,745,1,0,0,0,745,746,1,0,0,0,746,756,5,116,0,0, 747,753,10,7,0,0,748,754,3,116,58,0,749,750,5,10,0,0,750,754,3,118,59, 0,751,752,5,10,0,0,752,754,5,200,0,0,753,748,1,0,0,0,753,749,1,0,0,0, 753,751,1,0,0,0,754,756,1,0,0,0,755,664,1,0,0,0,755,671,1,0,0,0,755,678, 1,0,0,0,755,706,1,0,0,0,755,709,1,0,0,0,755,712,1,0,0,0,755,715,1,0,0, 0,755,724,1,0,0,0,755,730,1,0,0,0,755,735,1,0,0,0,755,738,1,0,0,0,755, 741,1,0,0,0,755,747,1,0,0,0,756,759,1,0,0,0,757,755,1,0,0,0,757,758,1, 0,0,0,758,75,1,0,0,0,759,757,1,0,0,0,760,765,3,78,39,0,761,762,5,206, 0,0,762,764,3,78,39,0,763,761,1,0,0,0,764,767,1,0,0,0,765,763,1,0,0,0, 765,766,1,0,0,0,766,77,1,0,0,0,767,765,1,0,0,0,768,771,3,80,40,0,769, 771,3,74,37,0,770,768,1,0,0,0,770,769,1,0,0,0,771,79,1,0,0,0,772,773, 5,220,0,0,773,778,3,118,59,0,774,775,5,206,0,0,775,777,3,118,59,0,776, 774,1,0,0,0,777,780,1,0,0,0,778,776,1,0,0,0,778,779,1,0,0,0,779,781,1, 0,0,0,780,778,1,0,0,0,781,782,5,236,0,0,782,792,1,0,0,0,783,788,3,118, 59,0,784,785,5,206,0,0,785,787,3,118,59,0,786,784,1,0,0,0,787,790,1,0, 0,0,788,786,1,0,0,0,788,789,1,0,0,0,789,792,1,0,0,0,790,788,1,0,0,0,791, 772,1,0,0,0,791,783,1,0,0,0,792,793,1,0,0,0,793,794,5,201,0,0,794,795, 3,74,37,0,795,81,1,0,0,0,796,797,5,222,0,0,797,801,3,118,59,0,798,800, 3,84,42,0,799,798,1,0,0,0,800,803,1,0,0,0,801,799,1,0,0,0,801,802,1,0, 0,0,802,804,1,0,0,0,803,801,1,0,0,0,804,805,5,238,0,0,805,806,5,214,0, 0,806,825,1,0,0,0,807,808,5,222,0,0,808,812,3,118,59,0,809,811,3,84,42, 0,810,809,1,0,0,0,811,814,1,0,0,0,812,810,1,0,0,0,812,813,1,0,0,0,813, 815,1,0,0,0,814,812,1,0,0,0,815,817,5,214,0,0,816,818,3,82,41,0,817,816, 1,0,0,0,817,818,1,0,0,0,818,819,1,0,0,0,819,820,5,222,0,0,820,821,5,238, 0,0,821,822,3,118,59,0,822,823,5,214,0,0,823,825,1,0,0,0,824,796,1,0, 0,0,824,807,1,0,0,0,825,83,1,0,0,0,826,827,3,118,59,0,827,828,5,212,0, 0,828,829,5,200,0,0,829,838,1,0,0,0,830,831,3,118,59,0,831,832,5,212, 0,0,832,833,5,218,0,0,833,834,3,74,37,0,834,835,5,234,0,0,835,838,1,0, 0,0,836,838,3,118,59,0,837,826,1,0,0,0,837,830,1,0,0,0,837,836,1,0,0, 0,838,85,1,0,0,0,839,844,3,88,44,0,840,841,5,206,0,0,841,843,3,88,44, 0,842,840,1,0,0,0,843,846,1,0,0,0,844,842,1,0,0,0,844,845,1,0,0,0,845, 87,1,0,0,0,846,844,1,0,0,0,847,848,3,118,59,0,848,849,5,10,0,0,849,850, 5,220,0,0,850,851,3,2,1,0,851,852,5,236,0,0,852,858,1,0,0,0,853,854,3, 74,37,0,854,855,5,10,0,0,855,856,3,118,59,0,856,858,1,0,0,0,857,847,1, 0,0,0,857,853,1,0,0,0,858,89,1,0,0,0,859,867,3,122,61,0,860,861,3,98, 49,0,861,862,5,210,0,0,862,864,1,0,0,0,863,860,1,0,0,0,863,864,1,0,0, 0,864,865,1,0,0,0,865,867,3,92,46,0,866,859,1,0,0,0,866,863,1,0,0,0,867, 91,1,0,0,0,868,873,3,118,59,0,869,870,5,210,0,0,870,872,3,118,59,0,871, 869,1,0,0,0,872,875,1,0,0,0,873,871,1,0,0,0,873,874,1,0,0,0,874,93,1, 0,0,0,875,873,1,0,0,0,876,877,6,47,-1,0,877,886,3,98,49,0,878,886,3,96, 48,0,879,880,5,220,0,0,880,881,3,2,1,0,881,882,5,236,0,0,882,886,1,0, 0,0,883,886,3,82,41,0,884,886,3,122,61,0,885,876,1,0,0,0,885,878,1,0, 0,0,885,879,1,0,0,0,885,883,1,0,0,0,885,884,1,0,0,0,886,895,1,0,0,0,887, 891,10,3,0,0,888,892,3,116,58,0,889,890,5,10,0,0,890,892,3,118,59,0,891, 888,1,0,0,0,891,889,1,0,0,0,892,894,1,0,0,0,893,887,1,0,0,0,894,897,1, 0,0,0,895,893,1,0,0,0,895,896,1,0,0,0,896,95,1,0,0,0,897,895,1,0,0,0, 898,899,3,118,59,0,899,901,5,220,0,0,900,902,3,100,50,0,901,900,1,0,0, 0,901,902,1,0,0,0,902,903,1,0,0,0,903,904,5,236,0,0,904,97,1,0,0,0,905, 906,3,102,51,0,906,907,5,210,0,0,907,909,1,0,0,0,908,905,1,0,0,0,908, 909,1,0,0,0,909,910,1,0,0,0,910,911,3,118,59,0,911,99,1,0,0,0,912,917, 3,74,37,0,913,914,5,206,0,0,914,916,3,74,37,0,915,913,1,0,0,0,916,919, 1,0,0,0,917,915,1,0,0,0,917,918,1,0,0,0,918,101,1,0,0,0,919,917,1,0,0, 0,920,921,3,118,59,0,921,103,1,0,0,0,922,931,5,196,0,0,923,924,5,210, 0,0,924,931,7,11,0,0,925,926,5,198,0,0,926,928,5,210,0,0,927,929,7,11, 0,0,928,927,1,0,0,0,928,929,1,0,0,0,929,931,1,0,0,0,930,922,1,0,0,0,930, 923,1,0,0,0,930,925,1,0,0,0,931,105,1,0,0,0,932,934,7,12,0,0,933,932, 1,0,0,0,933,934,1,0,0,0,934,941,1,0,0,0,935,942,3,104,52,0,936,942,5, 197,0,0,937,942,5,198,0,0,938,942,5,199,0,0,939,942,5,82,0,0,940,942, 5,113,0,0,941,935,1,0,0,0,941,936,1,0,0,0,941,937,1,0,0,0,941,938,1,0, 0,0,941,939,1,0,0,0,941,940,1,0,0,0,942,107,1,0,0,0,943,947,3,106,53, 0,944,947,5,200,0,0,945,947,5,116,0,0,946,943,1,0,0,0,946,944,1,0,0,0, 946,945,1,0,0,0,947,109,1,0,0,0,948,949,7,13,0,0,949,111,1,0,0,0,950, 951,7,14,0,0,951,113,1,0,0,0,952,953,7,15,0,0,953,115,1,0,0,0,954,957, 5,195,0,0,955,957,3,114,57,0,956,954,1,0,0,0,956,955,1,0,0,0,957,117, 1,0,0,0,958,962,5,195,0,0,959,962,3,110,55,0,960,962,3,112,56,0,961,958, 1,0,0,0,961,959,1,0,0,0,961,960,1,0,0,0,962,119,1,0,0,0,963,964,5,200, 0,0,964,965,5,212,0,0,965,966,3,106,53,0,966,121,1,0,0,0,967,968,5,218, 0,0,968,969,3,118,59,0,969,970,5,234,0,0,970,123,1,0,0,0,120,127,137, 146,149,153,156,160,163,166,169,172,176,180,183,186,189,193,196,205,211, 232,249,266,272,278,289,291,302,305,311,319,325,327,331,336,339,342,346, 350,353,355,358,362,366,369,371,373,378,389,395,402,407,411,415,421,423, 430,438,441,444,463,477,493,505,517,525,529,536,542,551,555,579,596,608, 618,621,625,628,641,658,662,668,675,687,691,694,703,717,744,753,755,757, 765,770,778,788,791,801,812,817,824,837,844,857,863,866,873,885,891,895, 901,908,917,928,930,933,941,946,956,961 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); antlr4::atn::ATNDeserializer deserializer; staticData->atn = deserializer.deserialize(staticData->serializedATN); const size_t count = staticData->atn->getNumberOfDecisions(); staticData->decisionToDFA.reserve(count); for (size_t i = 0; i < count; i++) { staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); } hogqlparserParserStaticData = staticData.release(); } } HogQLParser::HogQLParser(TokenStream *input) : HogQLParser(input, antlr4::atn::ParserATNSimulatorOptions()) {} HogQLParser::HogQLParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { HogQLParser::initialize(); _interpreter = new atn::ParserATNSimulator(this, *hogqlparserParserStaticData->atn, hogqlparserParserStaticData->decisionToDFA, hogqlparserParserStaticData->sharedContextCache, options); } HogQLParser::~HogQLParser() { delete _interpreter; } const atn::ATN& HogQLParser::getATN() const { return *hogqlparserParserStaticData->atn; } std::string HogQLParser::getGrammarFileName() const { return "HogQLParser.g4"; } const std::vector& HogQLParser::getRuleNames() const { return hogqlparserParserStaticData->ruleNames; } const dfa::Vocabulary& HogQLParser::getVocabulary() const { return hogqlparserParserStaticData->vocabulary; } antlr4::atn::SerializedATNView HogQLParser::getSerializedATN() const { return hogqlparserParserStaticData->serializedATN; } //----------------- SelectContext ------------------------------------------------------------------ HogQLParser::SelectContext::SelectContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::SelectContext::EOF() { return getToken(HogQLParser::EOF, 0); } HogQLParser::SelectUnionStmtContext* HogQLParser::SelectContext::selectUnionStmt() { return getRuleContext(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, 0, HogQLParser::RuleSelect); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(127); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { case 1: { setState(124); selectUnionStmt(); break; } case 2: { setState(125); selectStmt(); break; } case 3: { setState(126); hogqlxTagElement(); break; } default: break; } setState(129); match(HogQLParser::EOF); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- SelectUnionStmtContext ------------------------------------------------------------------ HogQLParser::SelectUnionStmtContext::SelectUnionStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } std::vector HogQLParser::SelectUnionStmtContext::selectStmtWithParens() { return getRuleContexts(); } HogQLParser::SelectStmtWithParensContext* HogQLParser::SelectUnionStmtContext::selectStmtWithParens(size_t i) { return getRuleContext(i); } std::vector HogQLParser::SelectUnionStmtContext::UNION() { return getTokens(HogQLParser::UNION); } tree::TerminalNode* HogQLParser::SelectUnionStmtContext::UNION(size_t i) { return getToken(HogQLParser::UNION, i); } std::vector HogQLParser::SelectUnionStmtContext::ALL() { return getTokens(HogQLParser::ALL); } tree::TerminalNode* HogQLParser::SelectUnionStmtContext::ALL(size_t i) { return getToken(HogQLParser::ALL, i); } size_t HogQLParser::SelectUnionStmtContext::getRuleIndex() const { return HogQLParser::RuleSelectUnionStmt; } std::any HogQLParser::SelectUnionStmtContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitSelectUnionStmt(this); else return visitor->visitChildren(this); } HogQLParser::SelectUnionStmtContext* HogQLParser::selectUnionStmt() { SelectUnionStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 2, HogQLParser::RuleSelectUnionStmt); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(131); selectStmtWithParens(); setState(137); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::UNION) { setState(132); match(HogQLParser::UNION); setState(133); match(HogQLParser::ALL); setState(134); selectStmtWithParens(); setState(139); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- SelectStmtWithParensContext ------------------------------------------------------------------ HogQLParser::SelectStmtWithParensContext::SelectStmtWithParensContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } HogQLParser::SelectStmtContext* HogQLParser::SelectStmtWithParensContext::selectStmt() { return getRuleContext(0); } tree::TerminalNode* HogQLParser::SelectStmtWithParensContext::LPAREN() { return getToken(HogQLParser::LPAREN, 0); } HogQLParser::SelectUnionStmtContext* HogQLParser::SelectStmtWithParensContext::selectUnionStmt() { 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, 4, HogQLParser::RuleSelectStmtWithParens); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(146); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::SELECT: case HogQLParser::WITH: { enterOuterAlt(_localctx, 1); setState(140); selectStmt(); break; } case HogQLParser::LPAREN: { enterOuterAlt(_localctx, 2); setState(141); match(HogQLParser::LPAREN); setState(142); selectUnionStmt(); setState(143); match(HogQLParser::RPAREN); break; } case HogQLParser::LBRACE: { enterOuterAlt(_localctx, 3); setState(145); 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; } //----------------- 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::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, 6, HogQLParser::RuleSelectStmt); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(149); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::WITH) { setState(148); antlrcpp::downCast(_localctx)->with = withClause(); } setState(151); match(HogQLParser::SELECT); setState(153); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 4, _ctx)) { case 1: { setState(152); match(HogQLParser::DISTINCT); break; } default: break; } setState(156); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 5, _ctx)) { case 1: { setState(155); topClause(); break; } default: break; } setState(158); antlrcpp::downCast(_localctx)->columns = columnExprList(); setState(160); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::FROM) { setState(159); antlrcpp::downCast(_localctx)->from = fromClause(); } setState(163); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ARRAY || _la == HogQLParser::INNER || _la == HogQLParser::LEFT) { setState(162); arrayJoinClause(); } setState(166); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::PREWHERE) { setState(165); prewhereClause(); } setState(169); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::WHERE) { setState(168); antlrcpp::downCast(_localctx)->where = whereClause(); } setState(172); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::GROUP) { setState(171); groupByClause(); } setState(176); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { case 1: { setState(174); match(HogQLParser::WITH); setState(175); _la = _input->LA(1); if (!(_la == HogQLParser::CUBE || _la == HogQLParser::ROLLUP)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } break; } default: break; } setState(180); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::WITH) { setState(178); match(HogQLParser::WITH); setState(179); match(HogQLParser::TOTALS); } setState(183); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::HAVING) { setState(182); havingClause(); } setState(186); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::WINDOW) { setState(185); windowClause(); } setState(189); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ORDER) { setState(188); orderByClause(); } setState(193); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::LIMIT: { setState(191); limitAndOffsetClause(); break; } case HogQLParser::OFFSET: { setState(192); offsetOnlyClause(); break; } case HogQLParser::EOF: case HogQLParser::SETTINGS: case HogQLParser::UNION: case HogQLParser::RPAREN: { break; } default: break; } setState(196); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::SETTINGS) { setState(195); 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, 8, HogQLParser::RuleWithClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(198); match(HogQLParser::WITH); setState(199); 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, 10, HogQLParser::RuleTopClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(201); match(HogQLParser::TOP); setState(202); match(HogQLParser::DECIMAL_LITERAL); setState(205); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 18, _ctx)) { case 1: { setState(203); match(HogQLParser::WITH); setState(204); 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, 12, HogQLParser::RuleFromClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(207); match(HogQLParser::FROM); setState(208); 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, 14, HogQLParser::RuleArrayJoinClause); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(211); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::INNER || _la == HogQLParser::LEFT) { setState(210); _la = _input->LA(1); if (!(_la == HogQLParser::INNER || _la == HogQLParser::LEFT)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(213); match(HogQLParser::ARRAY); setState(214); match(HogQLParser::JOIN); setState(215); 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, 16, HogQLParser::RuleWindowClause); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(217); match(HogQLParser::WINDOW); setState(218); identifier(); setState(219); match(HogQLParser::AS); setState(220); match(HogQLParser::LPAREN); setState(221); windowExpr(); setState(222); match(HogQLParser::RPAREN); setState(232); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(223); match(HogQLParser::COMMA); setState(224); identifier(); setState(225); match(HogQLParser::AS); setState(226); match(HogQLParser::LPAREN); setState(227); windowExpr(); setState(228); match(HogQLParser::RPAREN); setState(234); _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, 18, HogQLParser::RulePrewhereClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(235); match(HogQLParser::PREWHERE); setState(236); 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, 20, HogQLParser::RuleWhereClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(238); match(HogQLParser::WHERE); setState(239); 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, 22, HogQLParser::RuleGroupByClause); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(241); match(HogQLParser::GROUP); setState(242); match(HogQLParser::BY); setState(249); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { case 1: { setState(243); _la = _input->LA(1); if (!(_la == HogQLParser::CUBE || _la == HogQLParser::ROLLUP)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(244); match(HogQLParser::LPAREN); setState(245); columnExprList(); setState(246); match(HogQLParser::RPAREN); break; } case 2: { setState(248); 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, 24, HogQLParser::RuleHavingClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(251); match(HogQLParser::HAVING); setState(252); 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, 26, HogQLParser::RuleOrderByClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(254); match(HogQLParser::ORDER); setState(255); match(HogQLParser::BY); setState(256); 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, 28, HogQLParser::RuleProjectionOrderByClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(258); match(HogQLParser::ORDER); setState(259); match(HogQLParser::BY); setState(260); 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::BY() { return getToken(HogQLParser::BY, 0); } HogQLParser::ColumnExprListContext* HogQLParser::LimitAndOffsetClauseContext::columnExprList() { return getRuleContext(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, 30, HogQLParser::RuleLimitAndOffsetClause); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(291); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 26, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(262); match(HogQLParser::LIMIT); setState(263); columnExpr(0); setState(266); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::COMMA) { setState(264); match(HogQLParser::COMMA); setState(265); columnExpr(0); } setState(272); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::WITH: { setState(268); match(HogQLParser::WITH); setState(269); match(HogQLParser::TIES); break; } case HogQLParser::BY: { setState(270); match(HogQLParser::BY); setState(271); columnExprList(); break; } case HogQLParser::EOF: case HogQLParser::SETTINGS: case HogQLParser::UNION: case HogQLParser::RPAREN: { break; } default: break; } break; } case 2: { enterOuterAlt(_localctx, 2); setState(274); match(HogQLParser::LIMIT); setState(275); columnExpr(0); setState(278); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::WITH) { setState(276); match(HogQLParser::WITH); setState(277); match(HogQLParser::TIES); } setState(280); match(HogQLParser::OFFSET); setState(281); columnExpr(0); break; } case 3: { enterOuterAlt(_localctx, 3); setState(283); match(HogQLParser::LIMIT); setState(284); columnExpr(0); setState(285); match(HogQLParser::OFFSET); setState(286); columnExpr(0); setState(289); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::BY) { setState(287); match(HogQLParser::BY); setState(288); columnExprList(); } break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- OffsetOnlyClauseContext ------------------------------------------------------------------ HogQLParser::OffsetOnlyClauseContext::OffsetOnlyClauseContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::OffsetOnlyClauseContext::OFFSET() { return getToken(HogQLParser::OFFSET, 0); } HogQLParser::ColumnExprContext* HogQLParser::OffsetOnlyClauseContext::columnExpr() { return getRuleContext(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, 32, HogQLParser::RuleOffsetOnlyClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(293); match(HogQLParser::OFFSET); setState(294); 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, 34, HogQLParser::RuleSettingsClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(296); match(HogQLParser::SETTINGS); setState(297); 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 = 36; enterRecursionRule(_localctx, 36, HogQLParser::RuleJoinExpr, precedence); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif unrollRecursionContexts(parentContext); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(311); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 29, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(300); tableExpr(0); setState(302); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 27, _ctx)) { case 1: { setState(301); match(HogQLParser::FINAL); break; } default: break; } setState(305); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 28, _ctx)) { case 1: { setState(304); sampleClause(); break; } default: break; } break; } case 2: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(307); match(HogQLParser::LPAREN); setState(308); joinExpr(0); setState(309); match(HogQLParser::RPAREN); break; } default: break; } _ctx->stop = _input->LT(-1); setState(327); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) triggerExitRuleEvent(); previousContext = _localctx; setState(325); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 31, _ctx)) { case 1: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleJoinExpr); setState(313); if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)"); setState(314); joinOpCross(); setState(315); joinExpr(4); break; } case 2: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleJoinExpr); setState(317); if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); setState(319); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4496) != 0) || ((((_la - 69) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 69)) & 134250497) != 0) || _la == HogQLParser::RIGHT || _la == HogQLParser::SEMI) { setState(318); joinOp(); } setState(321); match(HogQLParser::JOIN); setState(322); joinExpr(0); setState(323); joinConstraintClause(); break; } default: break; } } setState(329); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 32, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- JoinOpContext ------------------------------------------------------------------ HogQLParser::JoinOpContext::JoinOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t HogQLParser::JoinOpContext::getRuleIndex() const { return HogQLParser::RuleJoinOp; } void HogQLParser::JoinOpContext::copyFrom(JoinOpContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- JoinOpFullContext ------------------------------------------------------------------ tree::TerminalNode* HogQLParser::JoinOpFullContext::FULL() { return getToken(HogQLParser::FULL, 0); } tree::TerminalNode* HogQLParser::JoinOpFullContext::OUTER() { return getToken(HogQLParser::OUTER, 0); } tree::TerminalNode* HogQLParser::JoinOpFullContext::ALL() { return getToken(HogQLParser::ALL, 0); } tree::TerminalNode* HogQLParser::JoinOpFullContext::ANY() { return getToken(HogQLParser::ANY, 0); } HogQLParser::JoinOpFullContext::JoinOpFullContext(JoinOpContext *ctx) { copyFrom(ctx); } std::any HogQLParser::JoinOpFullContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(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, 38, HogQLParser::RuleJoinOp); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(373); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 46, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 1); setState(339); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 35, _ctx)) { case 1: { setState(331); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4368) != 0)) { setState(330); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4368) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(333); match(HogQLParser::INNER); break; } case 2: { setState(334); match(HogQLParser::INNER); setState(336); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4368) != 0)) { setState(335); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4368) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } break; } case 3: { setState(338); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4368) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } break; } default: break; } break; } case 2: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(355); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 40, _ctx)) { case 1: { setState(342); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI) { setState(341); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(344); _la = _input->LA(1); if (!(_la == HogQLParser::LEFT || _la == HogQLParser::RIGHT)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(346); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::OUTER) { setState(345); match(HogQLParser::OUTER); } break; } case 2: { setState(348); _la = _input->LA(1); if (!(_la == HogQLParser::LEFT || _la == HogQLParser::RIGHT)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(350); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::OUTER) { setState(349); match(HogQLParser::OUTER); } setState(353); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI) { setState(352); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4496) != 0) || _la == HogQLParser::SEMI)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } break; } default: break; } break; } case 3: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 3); setState(371); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 45, _ctx)) { case 1: { setState(358); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ALL || _la == HogQLParser::ANY) { setState(357); _la = _input->LA(1); if (!(_la == HogQLParser::ALL || _la == HogQLParser::ANY)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(360); match(HogQLParser::FULL); setState(362); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::OUTER) { setState(361); match(HogQLParser::OUTER); } break; } case 2: { setState(364); match(HogQLParser::FULL); setState(366); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::OUTER) { setState(365); match(HogQLParser::OUTER); } setState(369); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ALL || _la == HogQLParser::ANY) { setState(368); _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, 40, HogQLParser::RuleJoinOpCross); #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::CROSS: { enterOuterAlt(_localctx, 1); setState(375); match(HogQLParser::CROSS); setState(376); match(HogQLParser::JOIN); break; } case HogQLParser::COMMA: { enterOuterAlt(_localctx, 2); setState(377); 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, 42, HogQLParser::RuleJoinConstraintClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(389); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 48, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(380); match(HogQLParser::ON); setState(381); columnExprList(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(382); match(HogQLParser::USING); setState(383); match(HogQLParser::LPAREN); setState(384); columnExprList(); setState(385); match(HogQLParser::RPAREN); break; } case 3: { enterOuterAlt(_localctx, 3); setState(387); match(HogQLParser::USING); setState(388); 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, 44, HogQLParser::RuleSampleClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(391); match(HogQLParser::SAMPLE); setState(392); ratioExpr(); setState(395); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 49, _ctx)) { case 1: { setState(393); match(HogQLParser::OFFSET); setState(394); ratioExpr(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- OrderExprListContext ------------------------------------------------------------------ HogQLParser::OrderExprListContext::OrderExprListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } std::vector HogQLParser::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, 46, HogQLParser::RuleOrderExprList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(397); orderExpr(); setState(402); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(398); match(HogQLParser::COMMA); setState(399); orderExpr(); setState(404); _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, 48, HogQLParser::RuleOrderExpr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(405); columnExpr(0); setState(407); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 13194139535360) != 0)) { setState(406); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 13194139535360) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(411); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::NULLS) { setState(409); match(HogQLParser::NULLS); setState(410); _la = _input->LA(1); if (!(_la == HogQLParser::FIRST || _la == HogQLParser::LAST)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(415); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::COLLATE) { setState(413); match(HogQLParser::COLLATE); setState(414); 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, 50, HogQLParser::RuleRatioExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(423); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::LBRACE: { enterOuterAlt(_localctx, 1); setState(417); 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(418); numberLiteral(); setState(421); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 54, _ctx)) { case 1: { setState(419); match(HogQLParser::SLASH); setState(420); 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, 52, HogQLParser::RuleSettingExprList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(425); settingExpr(); setState(430); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(426); match(HogQLParser::COMMA); setState(427); settingExpr(); setState(432); _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, 54, HogQLParser::RuleSettingExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(433); identifier(); setState(434); match(HogQLParser::EQ_SINGLE); setState(435); 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, 56, HogQLParser::RuleWindowExpr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(438); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::PARTITION) { setState(437); winPartitionByClause(); } setState(441); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ORDER) { setState(440); winOrderByClause(); } setState(444); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::RANGE || _la == HogQLParser::ROWS) { setState(443); 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, 58, HogQLParser::RuleWinPartitionByClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(446); match(HogQLParser::PARTITION); setState(447); match(HogQLParser::BY); setState(448); 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, 60, HogQLParser::RuleWinOrderByClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(450); match(HogQLParser::ORDER); setState(451); match(HogQLParser::BY); setState(452); 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, 62, HogQLParser::RuleWinFrameClause); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(454); _la = _input->LA(1); if (!(_la == HogQLParser::RANGE || _la == HogQLParser::ROWS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(455); 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, 64, HogQLParser::RuleWinFrameExtend); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(463); _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(457); winFrameBound(); break; } case HogQLParser::BETWEEN: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(458); match(HogQLParser::BETWEEN); setState(459); winFrameBound(); setState(460); match(HogQLParser::AND); setState(461); 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, 66, HogQLParser::RuleWinFrameBound); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(477); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 61, _ctx)) { case 1: { setState(465); match(HogQLParser::CURRENT); setState(466); match(HogQLParser::ROW); break; } case 2: { setState(467); match(HogQLParser::UNBOUNDED); setState(468); match(HogQLParser::PRECEDING); break; } case 3: { setState(469); match(HogQLParser::UNBOUNDED); setState(470); match(HogQLParser::FOLLOWING); break; } case 4: { setState(471); numberLiteral(); setState(472); match(HogQLParser::PRECEDING); break; } case 5: { setState(474); numberLiteral(); setState(475); 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, 68, HogQLParser::RuleExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(479); columnExpr(0); setState(480); 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, 70, HogQLParser::RuleColumnTypeExpr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(529); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 66, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 1); setState(482); identifier(); break; } case 2: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(483); identifier(); setState(484); match(HogQLParser::LPAREN); setState(485); identifier(); setState(486); columnTypeExpr(); setState(493); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(487); match(HogQLParser::COMMA); setState(488); identifier(); setState(489); columnTypeExpr(); setState(495); _errHandler->sync(this); _la = _input->LA(1); } setState(496); match(HogQLParser::RPAREN); break; } case 3: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 3); setState(498); identifier(); setState(499); match(HogQLParser::LPAREN); setState(500); enumValue(); setState(505); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(501); match(HogQLParser::COMMA); setState(502); enumValue(); setState(507); _errHandler->sync(this); _la = _input->LA(1); } setState(508); match(HogQLParser::RPAREN); break; } case 4: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 4); setState(510); identifier(); setState(511); match(HogQLParser::LPAREN); setState(512); columnTypeExpr(); setState(517); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(513); match(HogQLParser::COMMA); setState(514); columnTypeExpr(); setState(519); _errHandler->sync(this); _la = _input->LA(1); } setState(520); match(HogQLParser::RPAREN); break; } case 5: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 5); setState(522); identifier(); setState(523); match(HogQLParser::LPAREN); setState(525); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(524); columnExprList(); } setState(527); 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, 72, HogQLParser::RuleColumnExprList); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(531); columnExpr(0); setState(536); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 67, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { setState(532); match(HogQLParser::COMMA); setState(533); columnExpr(0); } setState(538); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 67, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ColumnExprContext ------------------------------------------------------------------ HogQLParser::ColumnExprContext::ColumnExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t HogQLParser::ColumnExprContext::getRuleIndex() const { return HogQLParser::RuleColumnExpr; } void HogQLParser::ColumnExprContext::copyFrom(ColumnExprContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- ColumnExprTernaryOpContext ------------------------------------------------------------------ std::vector HogQLParser::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); } HogQLParser::AliasContext* HogQLParser::ColumnExprAliasContext::alias() { 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); } //----------------- ColumnExprSubqueryContext ------------------------------------------------------------------ tree::TerminalNode* HogQLParser::ColumnExprSubqueryContext::LPAREN() { return getToken(HogQLParser::LPAREN, 0); } HogQLParser::SelectUnionStmtContext* HogQLParser::ColumnExprSubqueryContext::selectUnionStmt() { 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); } //----------------- 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); } //----------------- 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); } tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::LPAREN() { return getToken(HogQLParser::LPAREN, 0); } tree::TerminalNode* HogQLParser::ColumnExprWinFunctionTargetContext::RPAREN() { return getToken(HogQLParser::RPAREN, 0); } HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionTargetContext::columnExprList() { return getRuleContext(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); } //----------------- ColumnExprTrimContext ------------------------------------------------------------------ tree::TerminalNode* HogQLParser::ColumnExprTrimContext::TRIM() { return getToken(HogQLParser::TRIM, 0); } tree::TerminalNode* HogQLParser::ColumnExprTrimContext::LPAREN() { return getToken(HogQLParser::LPAREN, 0); } tree::TerminalNode* HogQLParser::ColumnExprTrimContext::STRING_LITERAL() { return getToken(HogQLParser::STRING_LITERAL, 0); } tree::TerminalNode* HogQLParser::ColumnExprTrimContext::FROM() { return getToken(HogQLParser::FROM, 0); } HogQLParser::ColumnExprContext* HogQLParser::ColumnExprTrimContext::columnExpr() { return getRuleContext(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); } //----------------- 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); } //----------------- 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); } //----------------- 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); } HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprWinFunctionContext::columnExprList() { return getRuleContext(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); } //----------------- 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); } HogQLParser::ColumnArgListContext* HogQLParser::ColumnExprFunctionContext::columnArgList() { return getRuleContext(0); } HogQLParser::ColumnExprListContext* HogQLParser::ColumnExprFunctionContext::columnExprList() { return getRuleContext(0); } 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 = 74; enterRecursionRule(_localctx, 74, HogQLParser::RuleColumnExpr, precedence); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif unrollRecursionContexts(parentContext); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(662); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 80, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(540); match(HogQLParser::CASE); setState(542); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 68, _ctx)) { case 1: { setState(541); antlrcpp::downCast(_localctx)->caseExpr = columnExpr(0); break; } default: break; } setState(549); _errHandler->sync(this); _la = _input->LA(1); do { setState(544); match(HogQLParser::WHEN); setState(545); antlrcpp::downCast(_localctx)->whenExpr = columnExpr(0); setState(546); match(HogQLParser::THEN); setState(547); antlrcpp::downCast(_localctx)->thenExpr = columnExpr(0); setState(551); _errHandler->sync(this); _la = _input->LA(1); } while (_la == HogQLParser::WHEN); setState(555); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::ELSE) { setState(553); match(HogQLParser::ELSE); setState(554); antlrcpp::downCast(_localctx)->elseExpr = columnExpr(0); } setState(557); match(HogQLParser::END); break; } case 2: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(559); match(HogQLParser::CAST); setState(560); match(HogQLParser::LPAREN); setState(561); columnExpr(0); setState(562); match(HogQLParser::AS); setState(563); columnTypeExpr(); setState(564); match(HogQLParser::RPAREN); break; } case 3: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(566); match(HogQLParser::DATE); setState(567); match(HogQLParser::STRING_LITERAL); break; } case 4: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(568); match(HogQLParser::INTERVAL); setState(569); columnExpr(0); setState(570); interval(); break; } case 5: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(572); match(HogQLParser::SUBSTRING); setState(573); match(HogQLParser::LPAREN); setState(574); columnExpr(0); setState(575); match(HogQLParser::FROM); setState(576); columnExpr(0); setState(579); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::FOR) { setState(577); match(HogQLParser::FOR); setState(578); columnExpr(0); } setState(581); match(HogQLParser::RPAREN); break; } case 6: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(583); match(HogQLParser::TIMESTAMP); setState(584); match(HogQLParser::STRING_LITERAL); break; } case 7: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(585); match(HogQLParser::TRIM); setState(586); match(HogQLParser::LPAREN); setState(587); _la = _input->LA(1); if (!(_la == HogQLParser::BOTH || _la == HogQLParser::LEADING || _la == HogQLParser::TRAILING)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(588); match(HogQLParser::STRING_LITERAL); setState(589); match(HogQLParser::FROM); setState(590); columnExpr(0); setState(591); match(HogQLParser::RPAREN); break; } case 8: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(593); identifier(); setState(594); match(HogQLParser::LPAREN); setState(596); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(595); columnExprList(); } setState(598); match(HogQLParser::RPAREN); setState(600); match(HogQLParser::OVER); setState(601); match(HogQLParser::LPAREN); setState(602); windowExpr(); setState(603); match(HogQLParser::RPAREN); break; } case 9: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(605); identifier(); setState(606); match(HogQLParser::LPAREN); setState(608); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(607); columnExprList(); } setState(610); match(HogQLParser::RPAREN); setState(612); match(HogQLParser::OVER); setState(613); identifier(); break; } case 10: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(615); identifier(); setState(621); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 75, _ctx)) { case 1: { setState(616); match(HogQLParser::LPAREN); setState(618); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(617); columnExprList(); } setState(620); match(HogQLParser::RPAREN); break; } default: break; } setState(623); match(HogQLParser::LPAREN); setState(625); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 76, _ctx)) { case 1: { setState(624); match(HogQLParser::DISTINCT); break; } default: break; } setState(628); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(627); columnArgList(); } setState(630); match(HogQLParser::RPAREN); break; } case 11: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(632); hogqlxTagElement(); break; } case 12: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(633); literal(); break; } case 13: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(634); match(HogQLParser::DASH); setState(635); columnExpr(18); break; } case 14: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(636); match(HogQLParser::NOT); setState(637); columnExpr(12); break; } case 15: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(641); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE || _la == HogQLParser::IDENTIFIER) { setState(638); tableIdentifier(); setState(639); match(HogQLParser::DOT); } setState(643); match(HogQLParser::ASTERISK); break; } case 16: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(644); match(HogQLParser::LPAREN); setState(645); selectUnionStmt(); setState(646); match(HogQLParser::RPAREN); break; } case 17: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(648); match(HogQLParser::LPAREN); setState(649); columnExpr(0); setState(650); match(HogQLParser::RPAREN); break; } case 18: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(652); match(HogQLParser::LPAREN); setState(653); columnExprList(); setState(654); match(HogQLParser::RPAREN); break; } case 19: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(656); match(HogQLParser::LBRACKET); setState(658); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(657); columnExprList(); } setState(660); match(HogQLParser::RBRACKET); break; } case 20: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(661); columnIdentifier(); break; } default: break; } _ctx->stop = _input->LT(-1); setState(757); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 91, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) triggerExitRuleEvent(); previousContext = _localctx; setState(755); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 90, _ctx)) { case 1: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; newContext->left = previousContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(664); if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)"); setState(668); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::ASTERISK: { setState(665); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::ASTERISK); break; } case HogQLParser::SLASH: { setState(666); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::SLASH); break; } case HogQLParser::PERCENT: { setState(667); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::PERCENT); break; } default: throw NoViableAltException(this); } setState(670); antlrcpp::downCast(_localctx)->right = columnExpr(18); break; } case 2: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; newContext->left = previousContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(671); if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)"); setState(675); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::PLUS: { setState(672); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::PLUS); break; } case HogQLParser::DASH: { setState(673); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::DASH); break; } case HogQLParser::CONCAT: { setState(674); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::CONCAT); break; } default: throw NoViableAltException(this); } setState(677); antlrcpp::downCast(_localctx)->right = columnExpr(17); break; } case 3: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; newContext->left = previousContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(678); if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)"); setState(703); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 86, _ctx)) { case 1: { setState(679); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::EQ_DOUBLE); break; } case 2: { setState(680); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::EQ_SINGLE); break; } case 3: { setState(681); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::NOT_EQ); break; } case 4: { setState(682); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::LT_EQ); break; } case 5: { setState(683); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::LT); break; } case 6: { setState(684); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::GT_EQ); break; } case 7: { setState(685); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::GT); break; } case 8: { setState(687); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::NOT) { setState(686); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::NOT); } setState(689); match(HogQLParser::IN); setState(691); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::COHORT) { setState(690); match(HogQLParser::COHORT); } break; } case 9: { setState(694); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::NOT) { setState(693); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::NOT); } setState(696); _la = _input->LA(1); if (!(_la == HogQLParser::ILIKE || _la == HogQLParser::LIKE)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } break; } case 10: { setState(697); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::REGEX_SINGLE); break; } case 11: { setState(698); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::REGEX_DOUBLE); break; } case 12: { setState(699); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::NOT_REGEX); break; } case 13: { setState(700); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::IREGEX_SINGLE); break; } case 14: { setState(701); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::IREGEX_DOUBLE); break; } case 15: { setState(702); antlrcpp::downCast(_localctx)->operator_ = match(HogQLParser::NOT_IREGEX); break; } default: break; } setState(705); antlrcpp::downCast(_localctx)->right = columnExpr(16); break; } case 4: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(706); if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)"); setState(707); match(HogQLParser::NULLISH); setState(708); columnExpr(14); break; } case 5: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(709); if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)"); setState(710); match(HogQLParser::AND); setState(711); columnExpr(12); break; } case 6: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(712); if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)"); setState(713); match(HogQLParser::OR); setState(714); columnExpr(11); break; } case 7: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(715); if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)"); setState(717); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::NOT) { setState(716); match(HogQLParser::NOT); } setState(719); match(HogQLParser::BETWEEN); setState(720); columnExpr(0); setState(721); match(HogQLParser::AND); setState(722); columnExpr(10); break; } case 8: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(724); if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)"); setState(725); match(HogQLParser::QUERY); setState(726); columnExpr(0); setState(727); match(HogQLParser::COLON); setState(728); columnExpr(8); break; } case 9: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(730); if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)"); setState(731); match(HogQLParser::LBRACKET); setState(732); columnExpr(0); setState(733); match(HogQLParser::RBRACKET); break; } case 10: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(735); if (!(precpred(_ctx, 20))) throw FailedPredicateException(this, "precpred(_ctx, 20)"); setState(736); match(HogQLParser::DOT); setState(737); match(HogQLParser::DECIMAL_LITERAL); break; } case 11: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(738); if (!(precpred(_ctx, 19))) throw FailedPredicateException(this, "precpred(_ctx, 19)"); setState(739); match(HogQLParser::DOT); setState(740); identifier(); break; } case 12: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(741); if (!(precpred(_ctx, 14))) throw FailedPredicateException(this, "precpred(_ctx, 14)"); setState(742); match(HogQLParser::IS); setState(744); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::NOT) { setState(743); match(HogQLParser::NOT); } setState(746); match(HogQLParser::NULL_SQL); break; } case 13: { auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleColumnExpr); setState(747); if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)"); setState(753); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 89, _ctx)) { case 1: { setState(748); alias(); break; } case 2: { setState(749); match(HogQLParser::AS); setState(750); identifier(); break; } case 3: { setState(751); match(HogQLParser::AS); setState(752); match(HogQLParser::STRING_LITERAL); break; } default: break; } break; } default: break; } } setState(759); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 91, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ColumnArgListContext ------------------------------------------------------------------ HogQLParser::ColumnArgListContext::ColumnArgListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } std::vector HogQLParser::ColumnArgListContext::columnArgExpr() { return getRuleContexts(); } HogQLParser::ColumnArgExprContext* HogQLParser::ColumnArgListContext::columnArgExpr(size_t i) { return getRuleContext(i); } std::vector HogQLParser::ColumnArgListContext::COMMA() { return getTokens(HogQLParser::COMMA); } tree::TerminalNode* HogQLParser::ColumnArgListContext::COMMA(size_t i) { return getToken(HogQLParser::COMMA, i); } size_t HogQLParser::ColumnArgListContext::getRuleIndex() const { return HogQLParser::RuleColumnArgList; } std::any HogQLParser::ColumnArgListContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitColumnArgList(this); else return visitor->visitChildren(this); } HogQLParser::ColumnArgListContext* HogQLParser::columnArgList() { ColumnArgListContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 76, HogQLParser::RuleColumnArgList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(760); columnArgExpr(); setState(765); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(761); match(HogQLParser::COMMA); setState(762); columnArgExpr(); setState(767); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ColumnArgExprContext ------------------------------------------------------------------ HogQLParser::ColumnArgExprContext::ColumnArgExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } HogQLParser::ColumnLambdaExprContext* HogQLParser::ColumnArgExprContext::columnLambdaExpr() { return getRuleContext(0); } HogQLParser::ColumnExprContext* HogQLParser::ColumnArgExprContext::columnExpr() { return getRuleContext(0); } size_t HogQLParser::ColumnArgExprContext::getRuleIndex() const { return HogQLParser::RuleColumnArgExpr; } std::any HogQLParser::ColumnArgExprContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitColumnArgExpr(this); else return visitor->visitChildren(this); } HogQLParser::ColumnArgExprContext* HogQLParser::columnArgExpr() { ColumnArgExprContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 78, HogQLParser::RuleColumnArgExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(770); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 93, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(768); columnLambdaExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(769); columnExpr(0); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ColumnLambdaExprContext ------------------------------------------------------------------ HogQLParser::ColumnLambdaExprContext::ColumnLambdaExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::ColumnLambdaExprContext::ARROW() { return getToken(HogQLParser::ARROW, 0); } HogQLParser::ColumnExprContext* HogQLParser::ColumnLambdaExprContext::columnExpr() { return getRuleContext(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); } 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, 80, HogQLParser::RuleColumnLambdaExpr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(791); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::LPAREN: { setState(772); match(HogQLParser::LPAREN); setState(773); identifier(); setState(778); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(774); match(HogQLParser::COMMA); setState(775); identifier(); setState(780); _errHandler->sync(this); _la = _input->LA(1); } setState(781); match(HogQLParser::RPAREN); break; } case HogQLParser::AFTER: case HogQLParser::ALIAS: case HogQLParser::ALL: case HogQLParser::ALTER: case HogQLParser::AND: case HogQLParser::ANTI: case HogQLParser::ANY: case HogQLParser::ARRAY: case HogQLParser::AS: case HogQLParser::ASCENDING: case HogQLParser::ASOF: case HogQLParser::AST: case HogQLParser::ASYNC: case HogQLParser::ATTACH: case HogQLParser::BETWEEN: case HogQLParser::BOTH: case HogQLParser::BY: case HogQLParser::CASE: case HogQLParser::CAST: case HogQLParser::CHECK: case HogQLParser::CLEAR: case HogQLParser::CLUSTER: case HogQLParser::CODEC: case HogQLParser::COLLATE: case HogQLParser::COLUMN: case HogQLParser::COMMENT: case HogQLParser::CONSTRAINT: case HogQLParser::CREATE: case HogQLParser::CROSS: case HogQLParser::CUBE: case HogQLParser::CURRENT: case HogQLParser::DATABASE: case HogQLParser::DATABASES: case HogQLParser::DATE: case HogQLParser::DAY: case HogQLParser::DEDUPLICATE: case HogQLParser::DEFAULT: case HogQLParser::DELAY: case HogQLParser::DELETE: case HogQLParser::DESC: case HogQLParser::DESCENDING: case HogQLParser::DESCRIBE: case HogQLParser::DETACH: case HogQLParser::DICTIONARIES: case HogQLParser::DICTIONARY: case HogQLParser::DISK: case HogQLParser::DISTINCT: case HogQLParser::DISTRIBUTED: case HogQLParser::DROP: case HogQLParser::ELSE: case HogQLParser::END: case HogQLParser::ENGINE: case HogQLParser::EVENTS: case HogQLParser::EXISTS: case HogQLParser::EXPLAIN: case HogQLParser::EXPRESSION: case HogQLParser::EXTRACT: case HogQLParser::FETCHES: case HogQLParser::FINAL: case HogQLParser::FIRST: case HogQLParser::FLUSH: case HogQLParser::FOLLOWING: case HogQLParser::FOR: case HogQLParser::FORMAT: case HogQLParser::FREEZE: case HogQLParser::FROM: case HogQLParser::FULL: case HogQLParser::FUNCTION: case HogQLParser::GLOBAL: case HogQLParser::GRANULARITY: case HogQLParser::GROUP: case HogQLParser::HAVING: case HogQLParser::HIERARCHICAL: case HogQLParser::HOUR: case HogQLParser::ID: case HogQLParser::IF: case HogQLParser::ILIKE: case HogQLParser::IN: case HogQLParser::INDEX: case HogQLParser::INJECTIVE: case HogQLParser::INNER: case HogQLParser::INSERT: case HogQLParser::INTERVAL: case HogQLParser::INTO: case HogQLParser::IS: case HogQLParser::IS_OBJECT_ID: case HogQLParser::JOIN: case HogQLParser::KEY: case HogQLParser::KILL: case HogQLParser::LAST: case HogQLParser::LAYOUT: case HogQLParser::LEADING: case HogQLParser::LEFT: case HogQLParser::LIFETIME: case HogQLParser::LIKE: case HogQLParser::LIMIT: case HogQLParser::LIVE: case HogQLParser::LOCAL: case HogQLParser::LOGS: case HogQLParser::MATERIALIZE: case HogQLParser::MATERIALIZED: case HogQLParser::MAX: case HogQLParser::MERGES: case HogQLParser::MIN: case HogQLParser::MINUTE: case HogQLParser::MODIFY: case HogQLParser::MONTH: case HogQLParser::MOVE: case HogQLParser::MUTATION: case HogQLParser::NO: case HogQLParser::NOT: case HogQLParser::NULLS: case HogQLParser::OFFSET: case HogQLParser::ON: case HogQLParser::OPTIMIZE: case HogQLParser::OR: case HogQLParser::ORDER: case HogQLParser::OUTER: case HogQLParser::OUTFILE: case HogQLParser::OVER: case HogQLParser::PARTITION: case HogQLParser::POPULATE: case HogQLParser::PRECEDING: case HogQLParser::PREWHERE: case HogQLParser::PRIMARY: case HogQLParser::QUARTER: case HogQLParser::RANGE: case HogQLParser::RELOAD: case HogQLParser::REMOVE: case HogQLParser::RENAME: case HogQLParser::REPLACE: case HogQLParser::REPLICA: case HogQLParser::REPLICATED: case HogQLParser::RIGHT: case HogQLParser::ROLLUP: case HogQLParser::ROW: case HogQLParser::ROWS: case HogQLParser::SAMPLE: case HogQLParser::SECOND: case HogQLParser::SELECT: case HogQLParser::SEMI: case HogQLParser::SENDS: case HogQLParser::SET: case HogQLParser::SETTINGS: case HogQLParser::SHOW: case HogQLParser::SOURCE: case HogQLParser::START: case HogQLParser::STOP: case HogQLParser::SUBSTRING: case HogQLParser::SYNC: case HogQLParser::SYNTAX: case HogQLParser::SYSTEM: case HogQLParser::TABLE: case HogQLParser::TABLES: case HogQLParser::TEMPORARY: case HogQLParser::TEST: case HogQLParser::THEN: case HogQLParser::TIES: case HogQLParser::TIMEOUT: case HogQLParser::TIMESTAMP: case HogQLParser::TO: case HogQLParser::TOP: case HogQLParser::TOTALS: case HogQLParser::TRAILING: case HogQLParser::TRIM: case HogQLParser::TRUNCATE: case HogQLParser::TTL: case HogQLParser::TYPE: case HogQLParser::UNBOUNDED: case HogQLParser::UNION: case HogQLParser::UPDATE: case HogQLParser::USE: case HogQLParser::USING: case HogQLParser::UUID: case HogQLParser::VALUES: case HogQLParser::VIEW: case HogQLParser::VOLUME: case HogQLParser::WATCH: case HogQLParser::WEEK: case HogQLParser::WHEN: case HogQLParser::WHERE: case HogQLParser::WINDOW: case HogQLParser::WITH: case HogQLParser::YEAR: case HogQLParser::JSON_FALSE: case HogQLParser::JSON_TRUE: case HogQLParser::IDENTIFIER: { setState(783); identifier(); setState(788); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(784); match(HogQLParser::COMMA); setState(785); identifier(); setState(790); _errHandler->sync(this); _la = _input->LA(1); } break; } default: throw NoViableAltException(this); } setState(793); match(HogQLParser::ARROW); setState(794); columnExpr(0); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- HogqlxTagElementContext ------------------------------------------------------------------ HogQLParser::HogqlxTagElementContext::HogqlxTagElementContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t HogQLParser::HogqlxTagElementContext::getRuleIndex() const { return HogQLParser::RuleHogqlxTagElement; } void HogQLParser::HogqlxTagElementContext::copyFrom(HogqlxTagElementContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- HogqlxTagElementClosedContext ------------------------------------------------------------------ tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::LT() { return getToken(HogQLParser::LT, 0); } HogQLParser::IdentifierContext* HogQLParser::HogqlxTagElementClosedContext::identifier() { return getRuleContext(0); } tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::SLASH() { return getToken(HogQLParser::SLASH, 0); } tree::TerminalNode* HogQLParser::HogqlxTagElementClosedContext::GT() { return getToken(HogQLParser::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 ------------------------------------------------------------------ std::vector HogQLParser::HogqlxTagElementNestedContext::LT() { return getTokens(HogQLParser::LT); } tree::TerminalNode* HogQLParser::HogqlxTagElementNestedContext::LT(size_t i) { return getToken(HogQLParser::LT, i); } 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::SLASH() { return getToken(HogQLParser::SLASH, 0); } std::vector HogQLParser::HogqlxTagElementNestedContext::hogqlxTagAttribute() { return getRuleContexts(); } HogQLParser::HogqlxTagAttributeContext* HogQLParser::HogqlxTagElementNestedContext::hogqlxTagAttribute(size_t i) { return getRuleContext(i); } HogQLParser::HogqlxTagElementContext* HogQLParser::HogqlxTagElementNestedContext::hogqlxTagElement() { return getRuleContext(0); } 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, 82, HogQLParser::RuleHogqlxTagElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(824); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 100, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 1); setState(796); match(HogQLParser::LT); setState(797); identifier(); setState(801); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE || _la == HogQLParser::IDENTIFIER) { setState(798); hogqlxTagAttribute(); setState(803); _errHandler->sync(this); _la = _input->LA(1); } setState(804); match(HogQLParser::SLASH); setState(805); match(HogQLParser::GT); break; } case 2: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(807); match(HogQLParser::LT); setState(808); identifier(); setState(812); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -5066549581053953) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || _la == HogQLParser::JSON_TRUE || _la == HogQLParser::IDENTIFIER) { setState(809); hogqlxTagAttribute(); setState(814); _errHandler->sync(this); _la = _input->LA(1); } setState(815); match(HogQLParser::GT); setState(817); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 99, _ctx)) { case 1: { setState(816); hogqlxTagElement(); break; } default: break; } setState(819); match(HogQLParser::LT); setState(820); match(HogQLParser::SLASH); setState(821); identifier(); setState(822); 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); } tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::STRING_LITERAL() { return getToken(HogQLParser::STRING_LITERAL, 0); } tree::TerminalNode* HogQLParser::HogqlxTagAttributeContext::LBRACE() { return getToken(HogQLParser::LBRACE, 0); } HogQLParser::ColumnExprContext* HogQLParser::HogqlxTagAttributeContext::columnExpr() { return getRuleContext(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, 84, HogQLParser::RuleHogqlxTagAttribute); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(837); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 101, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(826); identifier(); setState(827); match(HogQLParser::EQ_SINGLE); setState(828); match(HogQLParser::STRING_LITERAL); break; } case 2: { enterOuterAlt(_localctx, 2); setState(830); identifier(); setState(831); match(HogQLParser::EQ_SINGLE); setState(832); match(HogQLParser::LBRACE); setState(833); columnExpr(0); setState(834); match(HogQLParser::RBRACE); break; } case 3: { enterOuterAlt(_localctx, 3); setState(836); 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, 86, HogQLParser::RuleWithExprList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(839); withExpr(); setState(844); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(840); match(HogQLParser::COMMA); setState(841); withExpr(); setState(846); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- WithExprContext ------------------------------------------------------------------ HogQLParser::WithExprContext::WithExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t HogQLParser::WithExprContext::getRuleIndex() const { return HogQLParser::RuleWithExpr; } void HogQLParser::WithExprContext::copyFrom(WithExprContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- WithExprColumnContext ------------------------------------------------------------------ HogQLParser::ColumnExprContext* HogQLParser::WithExprColumnContext::columnExpr() { return getRuleContext(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::SelectUnionStmtContext* HogQLParser::WithExprSubqueryContext::selectUnionStmt() { 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, 88, HogQLParser::RuleWithExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(857); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 103, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 1); setState(847); identifier(); setState(848); match(HogQLParser::AS); setState(849); match(HogQLParser::LPAREN); setState(850); selectUnionStmt(); setState(851); match(HogQLParser::RPAREN); break; } case 2: { _localctx = _tracker.createInstance(_localctx); enterOuterAlt(_localctx, 2); setState(853); columnExpr(0); setState(854); match(HogQLParser::AS); setState(855); 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, 90, HogQLParser::RuleColumnIdentifier); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(866); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::LBRACE: { enterOuterAlt(_localctx, 1); setState(859); placeholder(); break; } case HogQLParser::AFTER: case HogQLParser::ALIAS: case HogQLParser::ALL: case HogQLParser::ALTER: case HogQLParser::AND: case HogQLParser::ANTI: case HogQLParser::ANY: case HogQLParser::ARRAY: case HogQLParser::AS: case HogQLParser::ASCENDING: case HogQLParser::ASOF: case HogQLParser::AST: case HogQLParser::ASYNC: case HogQLParser::ATTACH: case HogQLParser::BETWEEN: case HogQLParser::BOTH: case HogQLParser::BY: case HogQLParser::CASE: case HogQLParser::CAST: case HogQLParser::CHECK: case HogQLParser::CLEAR: case HogQLParser::CLUSTER: case HogQLParser::CODEC: case HogQLParser::COLLATE: case HogQLParser::COLUMN: case HogQLParser::COMMENT: case HogQLParser::CONSTRAINT: case HogQLParser::CREATE: case HogQLParser::CROSS: case HogQLParser::CUBE: case HogQLParser::CURRENT: case HogQLParser::DATABASE: case HogQLParser::DATABASES: case HogQLParser::DATE: case HogQLParser::DAY: case HogQLParser::DEDUPLICATE: case HogQLParser::DEFAULT: case HogQLParser::DELAY: case HogQLParser::DELETE: case HogQLParser::DESC: case HogQLParser::DESCENDING: case HogQLParser::DESCRIBE: case HogQLParser::DETACH: case HogQLParser::DICTIONARIES: case HogQLParser::DICTIONARY: case HogQLParser::DISK: case HogQLParser::DISTINCT: case HogQLParser::DISTRIBUTED: case HogQLParser::DROP: case HogQLParser::ELSE: case HogQLParser::END: case HogQLParser::ENGINE: case HogQLParser::EVENTS: case HogQLParser::EXISTS: case HogQLParser::EXPLAIN: case HogQLParser::EXPRESSION: case HogQLParser::EXTRACT: case HogQLParser::FETCHES: case HogQLParser::FINAL: case HogQLParser::FIRST: case HogQLParser::FLUSH: case HogQLParser::FOLLOWING: case HogQLParser::FOR: case HogQLParser::FORMAT: case HogQLParser::FREEZE: case HogQLParser::FROM: case HogQLParser::FULL: case HogQLParser::FUNCTION: case HogQLParser::GLOBAL: case HogQLParser::GRANULARITY: case HogQLParser::GROUP: case HogQLParser::HAVING: case HogQLParser::HIERARCHICAL: case HogQLParser::HOUR: case HogQLParser::ID: case HogQLParser::IF: case HogQLParser::ILIKE: case HogQLParser::IN: case HogQLParser::INDEX: case HogQLParser::INJECTIVE: case HogQLParser::INNER: case HogQLParser::INSERT: case HogQLParser::INTERVAL: case HogQLParser::INTO: case HogQLParser::IS: case HogQLParser::IS_OBJECT_ID: case HogQLParser::JOIN: case HogQLParser::KEY: case HogQLParser::KILL: case HogQLParser::LAST: case HogQLParser::LAYOUT: case HogQLParser::LEADING: case HogQLParser::LEFT: case HogQLParser::LIFETIME: case HogQLParser::LIKE: case HogQLParser::LIMIT: case HogQLParser::LIVE: case HogQLParser::LOCAL: case HogQLParser::LOGS: case HogQLParser::MATERIALIZE: case HogQLParser::MATERIALIZED: case HogQLParser::MAX: case HogQLParser::MERGES: case HogQLParser::MIN: case HogQLParser::MINUTE: case HogQLParser::MODIFY: case HogQLParser::MONTH: case HogQLParser::MOVE: case HogQLParser::MUTATION: case HogQLParser::NO: case HogQLParser::NOT: case HogQLParser::NULLS: case HogQLParser::OFFSET: case HogQLParser::ON: case HogQLParser::OPTIMIZE: case HogQLParser::OR: case HogQLParser::ORDER: case HogQLParser::OUTER: case HogQLParser::OUTFILE: case HogQLParser::OVER: case HogQLParser::PARTITION: case HogQLParser::POPULATE: case HogQLParser::PRECEDING: case HogQLParser::PREWHERE: case HogQLParser::PRIMARY: case HogQLParser::QUARTER: case HogQLParser::RANGE: case HogQLParser::RELOAD: case HogQLParser::REMOVE: case HogQLParser::RENAME: case HogQLParser::REPLACE: case HogQLParser::REPLICA: case HogQLParser::REPLICATED: case HogQLParser::RIGHT: case HogQLParser::ROLLUP: case HogQLParser::ROW: case HogQLParser::ROWS: case HogQLParser::SAMPLE: case HogQLParser::SECOND: case HogQLParser::SELECT: case HogQLParser::SEMI: case HogQLParser::SENDS: case HogQLParser::SET: case HogQLParser::SETTINGS: case HogQLParser::SHOW: case HogQLParser::SOURCE: case HogQLParser::START: case HogQLParser::STOP: case HogQLParser::SUBSTRING: case HogQLParser::SYNC: case HogQLParser::SYNTAX: case HogQLParser::SYSTEM: case HogQLParser::TABLE: case HogQLParser::TABLES: case HogQLParser::TEMPORARY: case HogQLParser::TEST: case HogQLParser::THEN: case HogQLParser::TIES: case HogQLParser::TIMEOUT: case HogQLParser::TIMESTAMP: case HogQLParser::TO: case HogQLParser::TOP: case HogQLParser::TOTALS: case HogQLParser::TRAILING: case HogQLParser::TRIM: case HogQLParser::TRUNCATE: case HogQLParser::TTL: case HogQLParser::TYPE: case HogQLParser::UNBOUNDED: case HogQLParser::UNION: case HogQLParser::UPDATE: case HogQLParser::USE: case HogQLParser::USING: case HogQLParser::UUID: case HogQLParser::VALUES: case HogQLParser::VIEW: case HogQLParser::VOLUME: case HogQLParser::WATCH: case HogQLParser::WEEK: case HogQLParser::WHEN: case HogQLParser::WHERE: case HogQLParser::WINDOW: case HogQLParser::WITH: case HogQLParser::YEAR: case HogQLParser::JSON_FALSE: case HogQLParser::JSON_TRUE: case HogQLParser::IDENTIFIER: { enterOuterAlt(_localctx, 2); setState(863); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 104, _ctx)) { case 1: { setState(860); tableIdentifier(); setState(861); match(HogQLParser::DOT); break; } default: break; } setState(865); 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, 92, HogQLParser::RuleNestedIdentifier); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(868); identifier(); setState(873); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 106, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { setState(869); match(HogQLParser::DOT); setState(870); identifier(); } setState(875); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 106, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TableExprContext ------------------------------------------------------------------ HogQLParser::TableExprContext::TableExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } size_t HogQLParser::TableExprContext::getRuleIndex() const { return HogQLParser::RuleTableExpr; } void HogQLParser::TableExprContext::copyFrom(TableExprContext *ctx) { ParserRuleContext::copyFrom(ctx); } //----------------- TableExprTagContext ------------------------------------------------------------------ HogQLParser::HogqlxTagElementContext* HogQLParser::TableExprTagContext::hogqlxTagElement() { return getRuleContext(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::SelectUnionStmtContext* HogQLParser::TableExprSubqueryContext::selectUnionStmt() { 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 = 94; enterRecursionRule(_localctx, 94, HogQLParser::RuleTableExpr, precedence); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif unrollRecursionContexts(parentContext); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(885); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 107, _ctx)) { case 1: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(877); tableIdentifier(); break; } case 2: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(878); tableFunctionExpr(); break; } case 3: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(879); match(HogQLParser::LPAREN); setState(880); selectUnionStmt(); setState(881); match(HogQLParser::RPAREN); break; } case 4: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(883); hogqlxTagElement(); break; } case 5: { _localctx = _tracker.createInstance(_localctx); _ctx = _localctx; previousContext = _localctx; setState(884); placeholder(); break; } default: break; } _ctx->stop = _input->LT(-1); setState(895); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 109, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) triggerExitRuleEvent(); previousContext = _localctx; auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); _localctx = newContext; pushNewRecursionContext(newContext, startState, RuleTableExpr); setState(887); if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)"); setState(891); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::DATE: case HogQLParser::FIRST: case HogQLParser::ID: case HogQLParser::KEY: case HogQLParser::IDENTIFIER: { setState(888); alias(); break; } case HogQLParser::AS: { setState(889); match(HogQLParser::AS); setState(890); identifier(); break; } default: throw NoViableAltException(this); } } setState(897); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 109, _ctx); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TableFunctionExprContext ------------------------------------------------------------------ HogQLParser::TableFunctionExprContext::TableFunctionExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } HogQLParser::IdentifierContext* HogQLParser::TableFunctionExprContext::identifier() { return getRuleContext(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, 96, HogQLParser::RuleTableFunctionExpr); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(898); identifier(); setState(899); match(HogQLParser::LPAREN); setState(901); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -33554436) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 64)) & -1) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 128)) & -9) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 192)) & 70263309817) != 0)) { setState(900); tableArgList(); } setState(903); match(HogQLParser::RPAREN); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TableIdentifierContext ------------------------------------------------------------------ HogQLParser::TableIdentifierContext::TableIdentifierContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } HogQLParser::IdentifierContext* HogQLParser::TableIdentifierContext::identifier() { return getRuleContext(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, 98, HogQLParser::RuleTableIdentifier); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(908); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 111, _ctx)) { case 1: { setState(905); databaseIdentifier(); setState(906); match(HogQLParser::DOT); break; } default: break; } setState(910); identifier(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TableArgListContext ------------------------------------------------------------------ HogQLParser::TableArgListContext::TableArgListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } std::vector HogQLParser::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, 100, HogQLParser::RuleTableArgList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(912); columnExpr(0); setState(917); _errHandler->sync(this); _la = _input->LA(1); while (_la == HogQLParser::COMMA) { setState(913); match(HogQLParser::COMMA); setState(914); columnExpr(0); setState(919); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- DatabaseIdentifierContext ------------------------------------------------------------------ HogQLParser::DatabaseIdentifierContext::DatabaseIdentifierContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } HogQLParser::IdentifierContext* HogQLParser::DatabaseIdentifierContext::identifier() { return getRuleContext(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, 102, HogQLParser::RuleDatabaseIdentifier); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(920); 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, 104, HogQLParser::RuleFloatingLiteral); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(930); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::FLOATING_LITERAL: { enterOuterAlt(_localctx, 1); setState(922); match(HogQLParser::FLOATING_LITERAL); break; } case HogQLParser::DOT: { enterOuterAlt(_localctx, 2); setState(923); match(HogQLParser::DOT); setState(924); _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(925); match(HogQLParser::DECIMAL_LITERAL); setState(926); match(HogQLParser::DOT); setState(928); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 113, _ctx)) { case 1: { setState(927); _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, 106, HogQLParser::RuleNumberLiteral); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(933); _errHandler->sync(this); _la = _input->LA(1); if (_la == HogQLParser::DASH || _la == HogQLParser::PLUS) { setState(932); _la = _input->LA(1); if (!(_la == HogQLParser::DASH || _la == HogQLParser::PLUS)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } setState(941); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 116, _ctx)) { case 1: { setState(935); floatingLiteral(); break; } case 2: { setState(936); match(HogQLParser::OCTAL_LITERAL); break; } case 3: { setState(937); match(HogQLParser::DECIMAL_LITERAL); break; } case 4: { setState(938); match(HogQLParser::HEXADECIMAL_LITERAL); break; } case 5: { setState(939); match(HogQLParser::INF); break; } case 6: { setState(940); 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, 108, HogQLParser::RuleLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(946); _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(943); numberLiteral(); break; } case HogQLParser::STRING_LITERAL: { enterOuterAlt(_localctx, 2); setState(944); match(HogQLParser::STRING_LITERAL); break; } case HogQLParser::NULL_SQL: { enterOuterAlt(_localctx, 3); setState(945); 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, 110, HogQLParser::RuleInterval); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(948); _la = _input->LA(1); if (!(_la == HogQLParser::DAY || ((((_la - 76) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 76)) & 72057615512764417) != 0) || ((((_la - 145) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 145)) & 36283883716609) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- KeywordContext ------------------------------------------------------------------ HogQLParser::KeywordContext::KeywordContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::KeywordContext::AFTER() { return getToken(HogQLParser::AFTER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ALIAS() { return getToken(HogQLParser::ALIAS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ALL() { return getToken(HogQLParser::ALL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ALTER() { return getToken(HogQLParser::ALTER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::AND() { return getToken(HogQLParser::AND, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ANTI() { return getToken(HogQLParser::ANTI, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ANY() { return getToken(HogQLParser::ANY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ARRAY() { return getToken(HogQLParser::ARRAY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::AS() { return getToken(HogQLParser::AS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ASCENDING() { return getToken(HogQLParser::ASCENDING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ASOF() { return getToken(HogQLParser::ASOF, 0); } tree::TerminalNode* HogQLParser::KeywordContext::AST() { return getToken(HogQLParser::AST, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ASYNC() { return getToken(HogQLParser::ASYNC, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ATTACH() { return getToken(HogQLParser::ATTACH, 0); } tree::TerminalNode* HogQLParser::KeywordContext::BETWEEN() { return getToken(HogQLParser::BETWEEN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::BOTH() { return getToken(HogQLParser::BOTH, 0); } tree::TerminalNode* HogQLParser::KeywordContext::BY() { return getToken(HogQLParser::BY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CASE() { return getToken(HogQLParser::CASE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CAST() { return getToken(HogQLParser::CAST, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CHECK() { return getToken(HogQLParser::CHECK, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CLEAR() { return getToken(HogQLParser::CLEAR, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CLUSTER() { return getToken(HogQLParser::CLUSTER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CODEC() { return getToken(HogQLParser::CODEC, 0); } tree::TerminalNode* HogQLParser::KeywordContext::COLLATE() { return getToken(HogQLParser::COLLATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::COLUMN() { return getToken(HogQLParser::COLUMN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::COMMENT() { return getToken(HogQLParser::COMMENT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CONSTRAINT() { return getToken(HogQLParser::CONSTRAINT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CREATE() { return getToken(HogQLParser::CREATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CROSS() { return getToken(HogQLParser::CROSS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CUBE() { return getToken(HogQLParser::CUBE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::CURRENT() { return getToken(HogQLParser::CURRENT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DATABASE() { return getToken(HogQLParser::DATABASE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DATABASES() { return getToken(HogQLParser::DATABASES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DATE() { return getToken(HogQLParser::DATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DEDUPLICATE() { return getToken(HogQLParser::DEDUPLICATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DEFAULT() { return getToken(HogQLParser::DEFAULT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DELAY() { return getToken(HogQLParser::DELAY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DELETE() { return getToken(HogQLParser::DELETE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DESCRIBE() { return getToken(HogQLParser::DESCRIBE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DESC() { return getToken(HogQLParser::DESC, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DESCENDING() { return getToken(HogQLParser::DESCENDING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DETACH() { return getToken(HogQLParser::DETACH, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DICTIONARIES() { return getToken(HogQLParser::DICTIONARIES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DICTIONARY() { return getToken(HogQLParser::DICTIONARY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DISK() { return getToken(HogQLParser::DISK, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DISTINCT() { return getToken(HogQLParser::DISTINCT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DISTRIBUTED() { return getToken(HogQLParser::DISTRIBUTED, 0); } tree::TerminalNode* HogQLParser::KeywordContext::DROP() { return getToken(HogQLParser::DROP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ELSE() { return getToken(HogQLParser::ELSE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::END() { return getToken(HogQLParser::END, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ENGINE() { return getToken(HogQLParser::ENGINE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::EVENTS() { return getToken(HogQLParser::EVENTS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::EXISTS() { return getToken(HogQLParser::EXISTS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::EXPLAIN() { return getToken(HogQLParser::EXPLAIN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::EXPRESSION() { return getToken(HogQLParser::EXPRESSION, 0); } tree::TerminalNode* HogQLParser::KeywordContext::EXTRACT() { return getToken(HogQLParser::EXTRACT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FETCHES() { return getToken(HogQLParser::FETCHES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FINAL() { return getToken(HogQLParser::FINAL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FIRST() { return getToken(HogQLParser::FIRST, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FLUSH() { return getToken(HogQLParser::FLUSH, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FOR() { return getToken(HogQLParser::FOR, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FOLLOWING() { return getToken(HogQLParser::FOLLOWING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FORMAT() { return getToken(HogQLParser::FORMAT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FREEZE() { return getToken(HogQLParser::FREEZE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FROM() { return getToken(HogQLParser::FROM, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FULL() { return getToken(HogQLParser::FULL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::FUNCTION() { return getToken(HogQLParser::FUNCTION, 0); } tree::TerminalNode* HogQLParser::KeywordContext::GLOBAL() { return getToken(HogQLParser::GLOBAL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::GRANULARITY() { return getToken(HogQLParser::GRANULARITY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::GROUP() { return getToken(HogQLParser::GROUP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::HAVING() { return getToken(HogQLParser::HAVING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::HIERARCHICAL() { return getToken(HogQLParser::HIERARCHICAL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ID() { return getToken(HogQLParser::ID, 0); } tree::TerminalNode* HogQLParser::KeywordContext::IF() { return getToken(HogQLParser::IF, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ILIKE() { return getToken(HogQLParser::ILIKE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::IN() { return getToken(HogQLParser::IN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INDEX() { return getToken(HogQLParser::INDEX, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INJECTIVE() { return getToken(HogQLParser::INJECTIVE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INNER() { return getToken(HogQLParser::INNER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INSERT() { return getToken(HogQLParser::INSERT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INTERVAL() { return getToken(HogQLParser::INTERVAL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::INTO() { return getToken(HogQLParser::INTO, 0); } tree::TerminalNode* HogQLParser::KeywordContext::IS() { return getToken(HogQLParser::IS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::IS_OBJECT_ID() { return getToken(HogQLParser::IS_OBJECT_ID, 0); } tree::TerminalNode* HogQLParser::KeywordContext::JOIN() { return getToken(HogQLParser::JOIN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::JSON_FALSE() { return getToken(HogQLParser::JSON_FALSE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::JSON_TRUE() { return getToken(HogQLParser::JSON_TRUE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::KEY() { return getToken(HogQLParser::KEY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::KILL() { return getToken(HogQLParser::KILL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LAST() { return getToken(HogQLParser::LAST, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LAYOUT() { return getToken(HogQLParser::LAYOUT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LEADING() { return getToken(HogQLParser::LEADING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LEFT() { return getToken(HogQLParser::LEFT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LIFETIME() { return getToken(HogQLParser::LIFETIME, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LIKE() { return getToken(HogQLParser::LIKE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LIMIT() { return getToken(HogQLParser::LIMIT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LIVE() { return getToken(HogQLParser::LIVE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LOCAL() { return getToken(HogQLParser::LOCAL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::LOGS() { return getToken(HogQLParser::LOGS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MATERIALIZE() { return getToken(HogQLParser::MATERIALIZE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MATERIALIZED() { return getToken(HogQLParser::MATERIALIZED, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MAX() { return getToken(HogQLParser::MAX, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MERGES() { return getToken(HogQLParser::MERGES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MIN() { return getToken(HogQLParser::MIN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MODIFY() { return getToken(HogQLParser::MODIFY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MOVE() { return getToken(HogQLParser::MOVE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::MUTATION() { return getToken(HogQLParser::MUTATION, 0); } tree::TerminalNode* HogQLParser::KeywordContext::NO() { return getToken(HogQLParser::NO, 0); } tree::TerminalNode* HogQLParser::KeywordContext::NOT() { return getToken(HogQLParser::NOT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::NULLS() { return getToken(HogQLParser::NULLS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OFFSET() { return getToken(HogQLParser::OFFSET, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ON() { return getToken(HogQLParser::ON, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OPTIMIZE() { return getToken(HogQLParser::OPTIMIZE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OR() { return getToken(HogQLParser::OR, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ORDER() { return getToken(HogQLParser::ORDER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OUTER() { return getToken(HogQLParser::OUTER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OUTFILE() { return getToken(HogQLParser::OUTFILE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::OVER() { return getToken(HogQLParser::OVER, 0); } tree::TerminalNode* HogQLParser::KeywordContext::PARTITION() { return getToken(HogQLParser::PARTITION, 0); } tree::TerminalNode* HogQLParser::KeywordContext::POPULATE() { return getToken(HogQLParser::POPULATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::PRECEDING() { return getToken(HogQLParser::PRECEDING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::PREWHERE() { return getToken(HogQLParser::PREWHERE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::PRIMARY() { return getToken(HogQLParser::PRIMARY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::RANGE() { return getToken(HogQLParser::RANGE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::RELOAD() { return getToken(HogQLParser::RELOAD, 0); } tree::TerminalNode* HogQLParser::KeywordContext::REMOVE() { return getToken(HogQLParser::REMOVE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::RENAME() { return getToken(HogQLParser::RENAME, 0); } tree::TerminalNode* HogQLParser::KeywordContext::REPLACE() { return getToken(HogQLParser::REPLACE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::REPLICA() { return getToken(HogQLParser::REPLICA, 0); } tree::TerminalNode* HogQLParser::KeywordContext::REPLICATED() { return getToken(HogQLParser::REPLICATED, 0); } tree::TerminalNode* HogQLParser::KeywordContext::RIGHT() { return getToken(HogQLParser::RIGHT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ROLLUP() { return getToken(HogQLParser::ROLLUP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ROW() { return getToken(HogQLParser::ROW, 0); } tree::TerminalNode* HogQLParser::KeywordContext::ROWS() { return getToken(HogQLParser::ROWS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SAMPLE() { return getToken(HogQLParser::SAMPLE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SELECT() { return getToken(HogQLParser::SELECT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SEMI() { return getToken(HogQLParser::SEMI, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SENDS() { return getToken(HogQLParser::SENDS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SET() { return getToken(HogQLParser::SET, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SETTINGS() { return getToken(HogQLParser::SETTINGS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SHOW() { return getToken(HogQLParser::SHOW, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SOURCE() { return getToken(HogQLParser::SOURCE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::START() { return getToken(HogQLParser::START, 0); } tree::TerminalNode* HogQLParser::KeywordContext::STOP() { return getToken(HogQLParser::STOP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SUBSTRING() { return getToken(HogQLParser::SUBSTRING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SYNC() { return getToken(HogQLParser::SYNC, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SYNTAX() { return getToken(HogQLParser::SYNTAX, 0); } tree::TerminalNode* HogQLParser::KeywordContext::SYSTEM() { return getToken(HogQLParser::SYSTEM, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TABLE() { return getToken(HogQLParser::TABLE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TABLES() { return getToken(HogQLParser::TABLES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TEMPORARY() { return getToken(HogQLParser::TEMPORARY, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TEST() { return getToken(HogQLParser::TEST, 0); } tree::TerminalNode* HogQLParser::KeywordContext::THEN() { return getToken(HogQLParser::THEN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TIES() { return getToken(HogQLParser::TIES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TIMEOUT() { return getToken(HogQLParser::TIMEOUT, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TIMESTAMP() { return getToken(HogQLParser::TIMESTAMP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TOTALS() { return getToken(HogQLParser::TOTALS, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TRAILING() { return getToken(HogQLParser::TRAILING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TRIM() { return getToken(HogQLParser::TRIM, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TRUNCATE() { return getToken(HogQLParser::TRUNCATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TO() { return getToken(HogQLParser::TO, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TOP() { return getToken(HogQLParser::TOP, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TTL() { return getToken(HogQLParser::TTL, 0); } tree::TerminalNode* HogQLParser::KeywordContext::TYPE() { return getToken(HogQLParser::TYPE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::UNBOUNDED() { return getToken(HogQLParser::UNBOUNDED, 0); } tree::TerminalNode* HogQLParser::KeywordContext::UNION() { return getToken(HogQLParser::UNION, 0); } tree::TerminalNode* HogQLParser::KeywordContext::UPDATE() { return getToken(HogQLParser::UPDATE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::USE() { return getToken(HogQLParser::USE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::USING() { return getToken(HogQLParser::USING, 0); } tree::TerminalNode* HogQLParser::KeywordContext::UUID() { return getToken(HogQLParser::UUID, 0); } tree::TerminalNode* HogQLParser::KeywordContext::VALUES() { return getToken(HogQLParser::VALUES, 0); } tree::TerminalNode* HogQLParser::KeywordContext::VIEW() { return getToken(HogQLParser::VIEW, 0); } tree::TerminalNode* HogQLParser::KeywordContext::VOLUME() { return getToken(HogQLParser::VOLUME, 0); } tree::TerminalNode* HogQLParser::KeywordContext::WATCH() { return getToken(HogQLParser::WATCH, 0); } tree::TerminalNode* HogQLParser::KeywordContext::WHEN() { return getToken(HogQLParser::WHEN, 0); } tree::TerminalNode* HogQLParser::KeywordContext::WHERE() { return getToken(HogQLParser::WHERE, 0); } tree::TerminalNode* HogQLParser::KeywordContext::WINDOW() { return getToken(HogQLParser::WINDOW, 0); } tree::TerminalNode* HogQLParser::KeywordContext::WITH() { return getToken(HogQLParser::WITH, 0); } size_t HogQLParser::KeywordContext::getRuleIndex() const { return HogQLParser::RuleKeyword; } std::any HogQLParser::KeywordContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitKeyword(this); else return visitor->visitChildren(this); } HogQLParser::KeywordContext* HogQLParser::keyword() { KeywordContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 112, HogQLParser::RuleKeyword); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(950); _la = _input->LA(1); if (!(((((_la - 2) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 2)) & -34368126977) != 0) || ((((_la - 66) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 66)) & -1288627627820033) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 130)) & 8034421735228932089) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- KeywordForAliasContext ------------------------------------------------------------------ HogQLParser::KeywordForAliasContext::KeywordForAliasContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::KeywordForAliasContext::DATE() { return getToken(HogQLParser::DATE, 0); } tree::TerminalNode* HogQLParser::KeywordForAliasContext::FIRST() { return getToken(HogQLParser::FIRST, 0); } tree::TerminalNode* HogQLParser::KeywordForAliasContext::ID() { return getToken(HogQLParser::ID, 0); } tree::TerminalNode* HogQLParser::KeywordForAliasContext::KEY() { return getToken(HogQLParser::KEY, 0); } size_t HogQLParser::KeywordForAliasContext::getRuleIndex() const { return HogQLParser::RuleKeywordForAlias; } std::any HogQLParser::KeywordForAliasContext::accept(tree::ParseTreeVisitor *visitor) { if (auto parserVisitor = dynamic_cast(visitor)) return parserVisitor->visitKeywordForAlias(this); else return visitor->visitChildren(this); } HogQLParser::KeywordForAliasContext* HogQLParser::keywordForAlias() { KeywordForAliasContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 114, HogQLParser::RuleKeywordForAlias); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(952); _la = _input->LA(1); if (!(((((_la - 36) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 36)) & 36030996109328385) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- AliasContext ------------------------------------------------------------------ HogQLParser::AliasContext::AliasContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::AliasContext::IDENTIFIER() { return getToken(HogQLParser::IDENTIFIER, 0); } HogQLParser::KeywordForAliasContext* HogQLParser::AliasContext::keywordForAlias() { return getRuleContext(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, 116, HogQLParser::RuleAlias); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(956); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::IDENTIFIER: { enterOuterAlt(_localctx, 1); setState(954); match(HogQLParser::IDENTIFIER); break; } case HogQLParser::DATE: case HogQLParser::FIRST: case HogQLParser::ID: case HogQLParser::KEY: { enterOuterAlt(_localctx, 2); setState(955); 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, 118, HogQLParser::RuleIdentifier); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(961); _errHandler->sync(this); switch (_input->LA(1)) { case HogQLParser::IDENTIFIER: { enterOuterAlt(_localctx, 1); setState(958); 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(959); interval(); break; } case HogQLParser::AFTER: case HogQLParser::ALIAS: case HogQLParser::ALL: case HogQLParser::ALTER: case HogQLParser::AND: case HogQLParser::ANTI: case HogQLParser::ANY: case HogQLParser::ARRAY: case HogQLParser::AS: case HogQLParser::ASCENDING: case HogQLParser::ASOF: case HogQLParser::AST: case HogQLParser::ASYNC: case HogQLParser::ATTACH: case HogQLParser::BETWEEN: case HogQLParser::BOTH: case HogQLParser::BY: case HogQLParser::CASE: case HogQLParser::CAST: case HogQLParser::CHECK: case HogQLParser::CLEAR: case HogQLParser::CLUSTER: case HogQLParser::CODEC: case HogQLParser::COLLATE: case HogQLParser::COLUMN: case HogQLParser::COMMENT: case HogQLParser::CONSTRAINT: case HogQLParser::CREATE: case HogQLParser::CROSS: case HogQLParser::CUBE: case HogQLParser::CURRENT: case HogQLParser::DATABASE: case HogQLParser::DATABASES: case HogQLParser::DATE: case HogQLParser::DEDUPLICATE: case HogQLParser::DEFAULT: case HogQLParser::DELAY: case HogQLParser::DELETE: case HogQLParser::DESC: case HogQLParser::DESCENDING: case HogQLParser::DESCRIBE: case HogQLParser::DETACH: case HogQLParser::DICTIONARIES: case HogQLParser::DICTIONARY: case HogQLParser::DISK: case HogQLParser::DISTINCT: case HogQLParser::DISTRIBUTED: case HogQLParser::DROP: case HogQLParser::ELSE: case HogQLParser::END: case HogQLParser::ENGINE: case HogQLParser::EVENTS: case HogQLParser::EXISTS: case HogQLParser::EXPLAIN: case HogQLParser::EXPRESSION: case HogQLParser::EXTRACT: case HogQLParser::FETCHES: case HogQLParser::FINAL: case HogQLParser::FIRST: case HogQLParser::FLUSH: case HogQLParser::FOLLOWING: case HogQLParser::FOR: case HogQLParser::FORMAT: case HogQLParser::FREEZE: case HogQLParser::FROM: case HogQLParser::FULL: case HogQLParser::FUNCTION: case HogQLParser::GLOBAL: case HogQLParser::GRANULARITY: case HogQLParser::GROUP: case HogQLParser::HAVING: case HogQLParser::HIERARCHICAL: case HogQLParser::ID: case HogQLParser::IF: case HogQLParser::ILIKE: case HogQLParser::IN: case HogQLParser::INDEX: case HogQLParser::INJECTIVE: case HogQLParser::INNER: case HogQLParser::INSERT: case HogQLParser::INTERVAL: case HogQLParser::INTO: case HogQLParser::IS: case HogQLParser::IS_OBJECT_ID: case HogQLParser::JOIN: case HogQLParser::KEY: case HogQLParser::KILL: case HogQLParser::LAST: case HogQLParser::LAYOUT: case HogQLParser::LEADING: case HogQLParser::LEFT: case HogQLParser::LIFETIME: case HogQLParser::LIKE: case HogQLParser::LIMIT: case HogQLParser::LIVE: case HogQLParser::LOCAL: case HogQLParser::LOGS: case HogQLParser::MATERIALIZE: case HogQLParser::MATERIALIZED: case HogQLParser::MAX: case HogQLParser::MERGES: case HogQLParser::MIN: case HogQLParser::MODIFY: case HogQLParser::MOVE: case HogQLParser::MUTATION: case HogQLParser::NO: case HogQLParser::NOT: case HogQLParser::NULLS: case HogQLParser::OFFSET: case HogQLParser::ON: case HogQLParser::OPTIMIZE: case HogQLParser::OR: case HogQLParser::ORDER: case HogQLParser::OUTER: case HogQLParser::OUTFILE: case HogQLParser::OVER: case HogQLParser::PARTITION: case HogQLParser::POPULATE: case HogQLParser::PRECEDING: case HogQLParser::PREWHERE: case HogQLParser::PRIMARY: case HogQLParser::RANGE: case HogQLParser::RELOAD: case HogQLParser::REMOVE: case HogQLParser::RENAME: case HogQLParser::REPLACE: case HogQLParser::REPLICA: case HogQLParser::REPLICATED: case HogQLParser::RIGHT: case HogQLParser::ROLLUP: case HogQLParser::ROW: case HogQLParser::ROWS: case HogQLParser::SAMPLE: case HogQLParser::SELECT: case HogQLParser::SEMI: case HogQLParser::SENDS: case HogQLParser::SET: case HogQLParser::SETTINGS: case HogQLParser::SHOW: case HogQLParser::SOURCE: case HogQLParser::START: case HogQLParser::STOP: case HogQLParser::SUBSTRING: case HogQLParser::SYNC: case HogQLParser::SYNTAX: case HogQLParser::SYSTEM: case HogQLParser::TABLE: case HogQLParser::TABLES: case HogQLParser::TEMPORARY: case HogQLParser::TEST: case HogQLParser::THEN: case HogQLParser::TIES: case HogQLParser::TIMEOUT: case HogQLParser::TIMESTAMP: case HogQLParser::TO: case HogQLParser::TOP: case HogQLParser::TOTALS: case HogQLParser::TRAILING: case HogQLParser::TRIM: case HogQLParser::TRUNCATE: case HogQLParser::TTL: case HogQLParser::TYPE: case HogQLParser::UNBOUNDED: case HogQLParser::UNION: case HogQLParser::UPDATE: case HogQLParser::USE: case HogQLParser::USING: case HogQLParser::UUID: case HogQLParser::VALUES: case HogQLParser::VIEW: case HogQLParser::VOLUME: case HogQLParser::WATCH: case HogQLParser::WHEN: case HogQLParser::WHERE: case HogQLParser::WINDOW: case HogQLParser::WITH: case HogQLParser::JSON_FALSE: case HogQLParser::JSON_TRUE: { enterOuterAlt(_localctx, 3); setState(960); keyword(); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- EnumValueContext ------------------------------------------------------------------ HogQLParser::EnumValueContext::EnumValueContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::EnumValueContext::STRING_LITERAL() { return getToken(HogQLParser::STRING_LITERAL, 0); } tree::TerminalNode* HogQLParser::EnumValueContext::EQ_SINGLE() { return getToken(HogQLParser::EQ_SINGLE, 0); } HogQLParser::NumberLiteralContext* HogQLParser::EnumValueContext::numberLiteral() { return getRuleContext(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, 120, HogQLParser::RuleEnumValue); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(963); match(HogQLParser::STRING_LITERAL); setState(964); match(HogQLParser::EQ_SINGLE); setState(965); numberLiteral(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- PlaceholderContext ------------------------------------------------------------------ HogQLParser::PlaceholderContext::PlaceholderContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } tree::TerminalNode* HogQLParser::PlaceholderContext::LBRACE() { return getToken(HogQLParser::LBRACE, 0); } HogQLParser::IdentifierContext* HogQLParser::PlaceholderContext::identifier() { return getRuleContext(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, 122, HogQLParser::RulePlaceholder); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(967); match(HogQLParser::LBRACE); setState(968); identifier(); setState(969); match(HogQLParser::RBRACE); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } bool HogQLParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { switch (ruleIndex) { case 18: return joinExprSempred(antlrcpp::downCast(context), predicateIndex); case 37: return columnExprSempred(antlrcpp::downCast(context), predicateIndex); case 47: 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, 17); case 3: return precpred(_ctx, 16); case 4: return precpred(_ctx, 15); case 5: return precpred(_ctx, 13); case 6: return precpred(_ctx, 11); case 7: return precpred(_ctx, 10); case 8: return precpred(_ctx, 9); case 9: return precpred(_ctx, 8); case 10: return precpred(_ctx, 21); case 11: return precpred(_ctx, 20); case 12: return precpred(_ctx, 19); case 13: return precpred(_ctx, 14); case 14: return precpred(_ctx, 7); default: break; } return true; } bool HogQLParser::tableExprSempred(TableExprContext *_localctx, size_t predicateIndex) { switch (predicateIndex) { case 15: return precpred(_ctx, 3); default: break; } return true; } void HogQLParser::initialize() { #if ANTLR4_USE_THREAD_LOCAL_CACHE hogqlparserParserInitialize(); #else ::antlr4::internal::call_once(hogqlparserParserOnceFlag, hogqlparserParserInitialize); #endif }