Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.hudi.spark.sql.parser.HoodieSqlBaseParser Maven / Gradle / Ivy
// Generated from org/apache/hudi/spark/sql/parser/HoodieSqlBase.g4 by ANTLR 4.8
package org.apache.hudi.spark.sql.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class HoodieSqlBaseParser extends Parser {
static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, ADD=7, AFTER=8, ALL=9,
ALTER=10, ANALYZE=11, AND=12, ANTI=13, ANY=14, ARCHIVE=15, ARRAY=16, AS=17,
ASC=18, AT=19, AUTHORIZATION=20, BETWEEN=21, BOTH=22, BUCKET=23, BUCKETS=24,
BY=25, CACHE=26, CASCADE=27, CASE=28, CAST=29, CHANGE=30, CHECK=31, CLEAR=32,
CLUSTER=33, CLUSTERED=34, CODEGEN=35, COLLATE=36, COLLECTION=37, COLUMN=38,
COLUMNS=39, COMMENT=40, COMMIT=41, COMPACT=42, COMPACTIONS=43, COMPUTE=44,
CONCATENATE=45, CONSTRAINT=46, COST=47, CREATE=48, CROSS=49, CUBE=50,
CURRENT=51, CURRENT_DATE=52, CURRENT_TIME=53, CURRENT_TIMESTAMP=54, CURRENT_USER=55,
DAY=56, DATA=57, DATABASE=58, DATABASES=59, DBPROPERTIES=60, DEFINED=61,
DELETE=62, DELIMITED=63, DESC=64, DESCRIBE=65, DFS=66, DIRECTORIES=67,
DIRECTORY=68, DISTINCT=69, DISTRIBUTE=70, DIV=71, DROP=72, ELSE=73, END=74,
ESCAPE=75, ESCAPED=76, EXCEPT=77, EXCHANGE=78, EXISTS=79, EXPLAIN=80,
EXPORT=81, EXTENDED=82, EXTERNAL=83, EXTRACT=84, FALSE=85, FETCH=86, FIELDS=87,
FILTER=88, FILEFORMAT=89, FIRST=90, FOLLOWING=91, FOR=92, FOREIGN=93,
FORMAT=94, FORMATTED=95, FROM=96, FULL=97, FUNCTION=98, FUNCTIONS=99,
GLOBAL=100, GRANT=101, GROUP=102, GROUPING=103, HAVING=104, HOUR=105,
IF=106, IGNORE=107, IMPORT=108, IN=109, INDEX=110, INDEXES=111, INNER=112,
INPATH=113, INPUTFORMAT=114, INSERT=115, INTERSECT=116, INTERVAL=117,
INTO=118, IS=119, ITEMS=120, JOIN=121, KEYS=122, LAST=123, LATERAL=124,
LAZY=125, LEADING=126, LEFT=127, LIKE=128, LIMIT=129, LINES=130, LIST=131,
LOAD=132, LOCAL=133, LOCATION=134, LOCK=135, LOCKS=136, LOGICAL=137, MACRO=138,
MAP=139, MATCHED=140, MERGE=141, MINUTE=142, MONTH=143, MSCK=144, NAMESPACE=145,
NAMESPACES=146, NATURAL=147, NO=148, NOT=149, NULL=150, NULLS=151, OF=152,
ON=153, ONLY=154, OPTION=155, OPTIONS=156, OR=157, ORDER=158, OUT=159,
OUTER=160, OUTPUTFORMAT=161, OVER=162, OVERLAPS=163, OVERLAY=164, OVERWRITE=165,
PARTITION=166, PARTITIONED=167, PARTITIONS=168, PERCENTLIT=169, PIVOT=170,
PLACING=171, POSITION=172, PRECEDING=173, PRIMARY=174, PRINCIPALS=175,
PROPERTIES=176, PURGE=177, QUERY=178, RANGE=179, RECORDREADER=180, RECORDWRITER=181,
RECOVER=182, REDUCE=183, REFERENCES=184, REFRESH=185, RENAME=186, REPAIR=187,
REPLACE=188, RESET=189, RESPECT=190, RESTRICT=191, REVOKE=192, RIGHT=193,
RLIKE=194, ROLE=195, ROLES=196, ROLLBACK=197, ROLLUP=198, ROW=199, ROWS=200,
SECOND=201, SCHEMA=202, SELECT=203, SEMI=204, SEPARATED=205, SERDE=206,
SERDEPROPERTIES=207, SESSION_USER=208, SET=209, SETMINUS=210, SETS=211,
SHOW=212, SKEWED=213, SOME=214, SORT=215, SORTED=216, START=217, STATISTICS=218,
STORED=219, STRATIFY=220, STRUCT=221, SUBSTR=222, SUBSTRING=223, SYNC=224,
TABLE=225, TABLES=226, TABLESAMPLE=227, TBLPROPERTIES=228, TEMPORARY=229,
TERMINATED=230, THEN=231, TIME=232, TO=233, TOUCH=234, TRAILING=235, TRANSACTION=236,
TRANSACTIONS=237, TRANSFORM=238, TRIM=239, TRUE=240, TRUNCATE=241, TRY_CAST=242,
TYPE=243, UNARCHIVE=244, UNBOUNDED=245, UNCACHE=246, UNION=247, UNIQUE=248,
UNKNOWN=249, UNLOCK=250, UNSET=251, UPDATE=252, USE=253, USER=254, USING=255,
VALUES=256, VIEW=257, VIEWS=258, WHEN=259, WHERE=260, WINDOW=261, WITH=262,
YEAR=263, ZONE=264, SYSTEM_VERSION=265, VERSION=266, SYSTEM_TIME=267,
TIMESTAMP=268, LEFT_PAREN=269, RIGHT_PAREN=270, COMMA=271, DOT=272, EQ=273,
NSEQ=274, NEQ=275, NEQJ=276, LT=277, LTE=278, GT=279, GTE=280, PLUS=281,
MINUS=282, ASTERISK=283, SLASH=284, PERCENT=285, TILDE=286, AMPERSAND=287,
PIPE=288, CONCAT_PIPE=289, HAT=290, STRING=291, BIGINT_LITERAL=292, SMALLINT_LITERAL=293,
TINYINT_LITERAL=294, INTEGER_VALUE=295, EXPONENT_VALUE=296, DECIMAL_VALUE=297,
FLOAT_LITERAL=298, DOUBLE_LITERAL=299, BIGDECIMAL_LITERAL=300, IDENTIFIER=301,
BACKQUOTED_IDENTIFIER=302, SIMPLE_COMMENT=303, BRACKETED_COMMENT=304,
WS=305, UNRECOGNIZED=306;
public static final int
RULE_singleStatement = 0, RULE_statement = 1, RULE_singleExpression = 2,
RULE_singleTableIdentifier = 3, RULE_singleMultipartIdentifier = 4, RULE_singleFunctionIdentifier = 5,
RULE_singleDataType = 6, RULE_singleTableSchema = 7, RULE_configKey = 8,
RULE_configValue = 9, RULE_unsupportedHiveNativeCommands = 10, RULE_createTableHeader = 11,
RULE_replaceTableHeader = 12, RULE_bucketSpec = 13, RULE_skewSpec = 14,
RULE_locationSpec = 15, RULE_commentSpec = 16, RULE_query = 17, RULE_insertInto = 18,
RULE_partitionSpecLocation = 19, RULE_partitionSpec = 20, RULE_partitionVal = 21,
RULE_namespace = 22, RULE_describeFuncName = 23, RULE_describeColName = 24,
RULE_ctes = 25, RULE_namedQuery = 26, RULE_tableProvider = 27, RULE_createTableClauses = 28,
RULE_tablePropertyList = 29, RULE_tableProperty = 30, RULE_tablePropertyKey = 31,
RULE_tablePropertyValue = 32, RULE_constantList = 33, RULE_nestedConstantList = 34,
RULE_createFileFormat = 35, RULE_fileFormat = 36, RULE_storageHandler = 37,
RULE_resource = 38, RULE_dmlStatementNoWith = 39, RULE_queryOrganization = 40,
RULE_multiInsertQueryBody = 41, RULE_queryTerm = 42, RULE_queryPrimary = 43,
RULE_sortItem = 44, RULE_fromStatement = 45, RULE_fromStatementBody = 46,
RULE_querySpecification = 47, RULE_transformClause = 48, RULE_selectClause = 49,
RULE_setClause = 50, RULE_matchedClause = 51, RULE_notMatchedClause = 52,
RULE_matchedAction = 53, RULE_notMatchedAction = 54, RULE_assignmentList = 55,
RULE_assignment = 56, RULE_whereClause = 57, RULE_havingClause = 58, RULE_hint = 59,
RULE_hintStatement = 60, RULE_fromClause = 61, RULE_temporalClause = 62,
RULE_aggregationClause = 63, RULE_groupByClause = 64, RULE_groupingAnalytics = 65,
RULE_groupingElement = 66, RULE_groupingSet = 67, RULE_pivotClause = 68,
RULE_pivotColumn = 69, RULE_pivotValue = 70, RULE_lateralView = 71, RULE_setQuantifier = 72,
RULE_relation = 73, RULE_joinRelation = 74, RULE_joinType = 75, RULE_joinCriteria = 76,
RULE_sample = 77, RULE_sampleMethod = 78, RULE_identifierList = 79, RULE_identifierSeq = 80,
RULE_orderedIdentifierList = 81, RULE_orderedIdentifier = 82, RULE_identifierCommentList = 83,
RULE_identifierComment = 84, RULE_relationPrimary = 85, RULE_inlineTable = 86,
RULE_functionTable = 87, RULE_tableAlias = 88, RULE_rowFormat = 89, RULE_multipartIdentifierList = 90,
RULE_multipartIdentifier = 91, RULE_tableIdentifier = 92, RULE_functionIdentifier = 93,
RULE_multipartIdentifierPropertyList = 94, RULE_multipartIdentifierProperty = 95,
RULE_propertyList = 96, RULE_property = 97, RULE_propertyKey = 98, RULE_propertyValue = 99,
RULE_namedExpression = 100, RULE_namedExpressionSeq = 101, RULE_partitionFieldList = 102,
RULE_partitionField = 103, RULE_transform = 104, RULE_transformArgument = 105,
RULE_expression = 106, RULE_expressionSeq = 107, RULE_booleanExpression = 108,
RULE_predicate = 109, RULE_valueExpression = 110, RULE_primaryExpression = 111,
RULE_constant = 112, RULE_comparisonOperator = 113, RULE_arithmeticOperator = 114,
RULE_predicateOperator = 115, RULE_booleanValue = 116, RULE_interval = 117,
RULE_errorCapturingMultiUnitsInterval = 118, RULE_multiUnitsInterval = 119,
RULE_errorCapturingUnitToUnitInterval = 120, RULE_unitToUnitInterval = 121,
RULE_intervalValue = 122, RULE_colPosition = 123, RULE_dataType = 124,
RULE_qualifiedColTypeWithPositionList = 125, RULE_qualifiedColTypeWithPosition = 126,
RULE_colTypeList = 127, RULE_colType = 128, RULE_complexColTypeList = 129,
RULE_complexColType = 130, RULE_whenClause = 131, RULE_windowClause = 132,
RULE_namedWindow = 133, RULE_windowSpec = 134, RULE_windowFrame = 135,
RULE_frameBound = 136, RULE_qualifiedNameList = 137, RULE_functionName = 138,
RULE_qualifiedName = 139, RULE_errorCapturingIdentifier = 140, RULE_errorCapturingIdentifierExtra = 141,
RULE_identifier = 142, RULE_strictIdentifier = 143, RULE_quotedIdentifier = 144,
RULE_number = 145, RULE_alterColumnAction = 146, RULE_ansiNonReserved = 147,
RULE_strictNonReserved = 148, RULE_nonReserved = 149;
private static String[] makeRuleNames() {
return new String[] {
"singleStatement", "statement", "singleExpression", "singleTableIdentifier",
"singleMultipartIdentifier", "singleFunctionIdentifier", "singleDataType",
"singleTableSchema", "configKey", "configValue", "unsupportedHiveNativeCommands",
"createTableHeader", "replaceTableHeader", "bucketSpec", "skewSpec",
"locationSpec", "commentSpec", "query", "insertInto", "partitionSpecLocation",
"partitionSpec", "partitionVal", "namespace", "describeFuncName", "describeColName",
"ctes", "namedQuery", "tableProvider", "createTableClauses", "tablePropertyList",
"tableProperty", "tablePropertyKey", "tablePropertyValue", "constantList",
"nestedConstantList", "createFileFormat", "fileFormat", "storageHandler",
"resource", "dmlStatementNoWith", "queryOrganization", "multiInsertQueryBody",
"queryTerm", "queryPrimary", "sortItem", "fromStatement", "fromStatementBody",
"querySpecification", "transformClause", "selectClause", "setClause",
"matchedClause", "notMatchedClause", "matchedAction", "notMatchedAction",
"assignmentList", "assignment", "whereClause", "havingClause", "hint",
"hintStatement", "fromClause", "temporalClause", "aggregationClause",
"groupByClause", "groupingAnalytics", "groupingElement", "groupingSet",
"pivotClause", "pivotColumn", "pivotValue", "lateralView", "setQuantifier",
"relation", "joinRelation", "joinType", "joinCriteria", "sample", "sampleMethod",
"identifierList", "identifierSeq", "orderedIdentifierList", "orderedIdentifier",
"identifierCommentList", "identifierComment", "relationPrimary", "inlineTable",
"functionTable", "tableAlias", "rowFormat", "multipartIdentifierList",
"multipartIdentifier", "tableIdentifier", "functionIdentifier", "multipartIdentifierPropertyList",
"multipartIdentifierProperty", "propertyList", "property", "propertyKey",
"propertyValue", "namedExpression", "namedExpressionSeq", "partitionFieldList",
"partitionField", "transform", "transformArgument", "expression", "expressionSeq",
"booleanExpression", "predicate", "valueExpression", "primaryExpression",
"constant", "comparisonOperator", "arithmeticOperator", "predicateOperator",
"booleanValue", "interval", "errorCapturingMultiUnitsInterval", "multiUnitsInterval",
"errorCapturingUnitToUnitInterval", "unitToUnitInterval", "intervalValue",
"colPosition", "dataType", "qualifiedColTypeWithPositionList", "qualifiedColTypeWithPosition",
"colTypeList", "colType", "complexColTypeList", "complexColType", "whenClause",
"windowClause", "namedWindow", "windowSpec", "windowFrame", "frameBound",
"qualifiedNameList", "functionName", "qualifiedName", "errorCapturingIdentifier",
"errorCapturingIdentifierExtra", "identifier", "strictIdentifier", "quotedIdentifier",
"number", "alterColumnAction", "ansiNonReserved", "strictNonReserved",
"nonReserved"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'/*+'", "'*/'", "'->'", "'['", "']'", "':'", "'ADD'", "'AFTER'",
"'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'ANTI'", "'ANY'", "'ARCHIVE'",
"'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORIZATION'", "'BETWEEN'", "'BOTH'",
"'BUCKET'", "'BUCKETS'", "'BY'", "'CACHE'", "'CASCADE'", "'CASE'", "'CAST'",
"'CHANGE'", "'CHECK'", "'CLEAR'", "'CLUSTER'", "'CLUSTERED'", "'CODEGEN'",
"'COLLATE'", "'COLLECTION'", "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'",
"'COMPACT'", "'COMPACTIONS'", "'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'",
"'COST'", "'CREATE'", "'CROSS'", "'CUBE'", "'CURRENT'", "'CURRENT_DATE'",
"'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DAY'", "'DATA'",
"'DATABASE'", null, "'DBPROPERTIES'", "'DEFINED'", "'DELETE'", "'DELIMITED'",
"'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'", "'DIRECTORY'", "'DISTINCT'",
"'DISTRIBUTE'", "'DIV'", "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'",
"'EXCEPT'", "'EXCHANGE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'",
"'EXTERNAL'", "'EXTRACT'", "'FALSE'", "'FETCH'", "'FIELDS'", "'FILTER'",
"'FILEFORMAT'", "'FIRST'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'",
"'FORMATTED'", "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GLOBAL'",
"'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", "'HOUR'", "'IF'", "'IGNORE'",
"'IMPORT'", "'IN'", "'INDEX'", "'INDEXES'", "'INNER'", "'INPATH'", "'INPUTFORMAT'",
"'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INTO'", "'IS'", "'ITEMS'",
"'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'", "'LAZY'", "'LEADING'", "'LEFT'",
"'LIKE'", "'LIMIT'", "'LINES'", "'LIST'", "'LOAD'", "'LOCAL'", "'LOCATION'",
"'LOCK'", "'LOCKS'", "'LOGICAL'", "'MACRO'", "'MAP'", "'MATCHED'", "'MERGE'",
"'MINUTE'", "'MONTH'", "'MSCK'", "'NAMESPACE'", "'NAMESPACES'", "'NATURAL'",
"'NO'", null, "'NULL'", "'NULLS'", "'OF'", "'ON'", "'ONLY'", "'OPTION'",
"'OPTIONS'", "'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTPUTFORMAT'",
"'OVER'", "'OVERLAPS'", "'OVERLAY'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONED'",
"'PARTITIONS'", "'PERCENT'", "'PIVOT'", "'PLACING'", "'POSITION'", "'PRECEDING'",
"'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", "'PURGE'", "'QUERY'", "'RANGE'",
"'RECORDREADER'", "'RECORDWRITER'", "'RECOVER'", "'REDUCE'", "'REFERENCES'",
"'REFRESH'", "'RENAME'", "'REPAIR'", "'REPLACE'", "'RESET'", "'RESPECT'",
"'RESTRICT'", "'REVOKE'", "'RIGHT'", null, "'ROLE'", "'ROLES'", "'ROLLBACK'",
"'ROLLUP'", "'ROW'", "'ROWS'", "'SECOND'", "'SCHEMA'", "'SELECT'", "'SEMI'",
"'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'", "'SET'",
"'MINUS'", "'SETS'", "'SHOW'", "'SKEWED'", "'SOME'", "'SORT'", "'SORTED'",
"'START'", "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRUCT'", "'SUBSTR'",
"'SUBSTRING'", "'SYNC'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TBLPROPERTIES'",
null, "'TERMINATED'", "'THEN'", "'TIME'", "'TO'", "'TOUCH'", "'TRAILING'",
"'TRANSACTION'", "'TRANSACTIONS'", "'TRANSFORM'", "'TRIM'", "'TRUE'",
"'TRUNCATE'", "'TRY_CAST'", "'TYPE'", "'UNARCHIVE'", "'UNBOUNDED'", "'UNCACHE'",
"'UNION'", "'UNIQUE'", "'UNKNOWN'", "'UNLOCK'", "'UNSET'", "'UPDATE'",
"'USE'", "'USER'", "'USING'", "'VALUES'", "'VIEW'", "'VIEWS'", "'WHEN'",
"'WHERE'", "'WINDOW'", "'WITH'", "'YEAR'", "'ZONE'", "'SYSTEM_VERSION'",
"'VERSION'", "'SYSTEM_TIME'", "'TIMESTAMP'", "'('", "')'", "','", "'.'",
null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'", null, "'+'", "'-'",
"'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", "'^'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, "ADD", "AFTER", "ALL", "ALTER",
"ANALYZE", "AND", "ANTI", "ANY", "ARCHIVE", "ARRAY", "AS", "ASC", "AT",
"AUTHORIZATION", "BETWEEN", "BOTH", "BUCKET", "BUCKETS", "BY", "CACHE",
"CASCADE", "CASE", "CAST", "CHANGE", "CHECK", "CLEAR", "CLUSTER", "CLUSTERED",
"CODEGEN", "COLLATE", "COLLECTION", "COLUMN", "COLUMNS", "COMMENT", "COMMIT",
"COMPACT", "COMPACTIONS", "COMPUTE", "CONCATENATE", "CONSTRAINT", "COST",
"CREATE", "CROSS", "CUBE", "CURRENT", "CURRENT_DATE", "CURRENT_TIME",
"CURRENT_TIMESTAMP", "CURRENT_USER", "DAY", "DATA", "DATABASE", "DATABASES",
"DBPROPERTIES", "DEFINED", "DELETE", "DELIMITED", "DESC", "DESCRIBE",
"DFS", "DIRECTORIES", "DIRECTORY", "DISTINCT", "DISTRIBUTE", "DIV", "DROP",
"ELSE", "END", "ESCAPE", "ESCAPED", "EXCEPT", "EXCHANGE", "EXISTS", "EXPLAIN",
"EXPORT", "EXTENDED", "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FIELDS",
"FILTER", "FILEFORMAT", "FIRST", "FOLLOWING", "FOR", "FOREIGN", "FORMAT",
"FORMATTED", "FROM", "FULL", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANT",
"GROUP", "GROUPING", "HAVING", "HOUR", "IF", "IGNORE", "IMPORT", "IN",
"INDEX", "INDEXES", "INNER", "INPATH", "INPUTFORMAT", "INSERT", "INTERSECT",
"INTERVAL", "INTO", "IS", "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL",
"LAZY", "LEADING", "LEFT", "LIKE", "LIMIT", "LINES", "LIST", "LOAD",
"LOCAL", "LOCATION", "LOCK", "LOCKS", "LOGICAL", "MACRO", "MAP", "MATCHED",
"MERGE", "MINUTE", "MONTH", "MSCK", "NAMESPACE", "NAMESPACES", "NATURAL",
"NO", "NOT", "NULL", "NULLS", "OF", "ON", "ONLY", "OPTION", "OPTIONS",
"OR", "ORDER", "OUT", "OUTER", "OUTPUTFORMAT", "OVER", "OVERLAPS", "OVERLAY",
"OVERWRITE", "PARTITION", "PARTITIONED", "PARTITIONS", "PERCENTLIT",
"PIVOT", "PLACING", "POSITION", "PRECEDING", "PRIMARY", "PRINCIPALS",
"PROPERTIES", "PURGE", "QUERY", "RANGE", "RECORDREADER", "RECORDWRITER",
"RECOVER", "REDUCE", "REFERENCES", "REFRESH", "RENAME", "REPAIR", "REPLACE",
"RESET", "RESPECT", "RESTRICT", "REVOKE", "RIGHT", "RLIKE", "ROLE", "ROLES",
"ROLLBACK", "ROLLUP", "ROW", "ROWS", "SECOND", "SCHEMA", "SELECT", "SEMI",
"SEPARATED", "SERDE", "SERDEPROPERTIES", "SESSION_USER", "SET", "SETMINUS",
"SETS", "SHOW", "SKEWED", "SOME", "SORT", "SORTED", "START", "STATISTICS",
"STORED", "STRATIFY", "STRUCT", "SUBSTR", "SUBSTRING", "SYNC", "TABLE",
"TABLES", "TABLESAMPLE", "TBLPROPERTIES", "TEMPORARY", "TERMINATED",
"THEN", "TIME", "TO", "TOUCH", "TRAILING", "TRANSACTION", "TRANSACTIONS",
"TRANSFORM", "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "UNARCHIVE",
"UNBOUNDED", "UNCACHE", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNSET",
"UPDATE", "USE", "USER", "USING", "VALUES", "VIEW", "VIEWS", "WHEN",
"WHERE", "WINDOW", "WITH", "YEAR", "ZONE", "SYSTEM_VERSION", "VERSION",
"SYSTEM_TIME", "TIMESTAMP", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT",
"EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", "GT", "GTE", "PLUS", "MINUS",
"ASTERISK", "SLASH", "PERCENT", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE",
"HAT", "STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL",
"INTEGER_VALUE", "EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL",
"DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER",
"SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", "UNRECOGNIZED"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "HoodieSqlBase.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
/**
* When false, INTERSECT is given the greater precedence over the other set
* operations (UNION, EXCEPT and MINUS) as per the SQL standard.
*/
public boolean legacy_setops_precedence_enabled = false;
/**
* When false, a literal with an exponent would be converted into
* double type rather than decimal type.
*/
public boolean legacy_exponent_literal_as_decimal_enabled = false;
/**
* When true, the behavior of keywords follows ANSI SQL standard.
*/
public boolean SQL_standard_keyword_behavior = false;
public HoodieSqlBaseParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class SingleStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SingleStatementContext singleStatement() throws RecognitionException {
SingleStatementContext _localctx = new SingleStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_singleStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(300);
statement();
setState(301);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class RefreshIndexContext extends StatementContext {
public TerminalNode REFRESH() { return getToken(HoodieSqlBaseParser.REFRESH, 0); }
public TerminalNode INDEX() { return getToken(HoodieSqlBaseParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public RefreshIndexContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterRefreshIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitRefreshIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitRefreshIndex(this);
else return visitor.visitChildren(this);
}
}
public static class PassThroughContext extends StatementContext {
public PassThroughContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPassThrough(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPassThrough(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPassThrough(this);
else return visitor.visitChildren(this);
}
}
public static class QueryStatementContext extends StatementContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public QueryStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterQueryStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitQueryStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitQueryStatement(this);
else return visitor.visitChildren(this);
}
}
public static class CreateTableContext extends StatementContext {
public CreateTableHeaderContext createTableHeader() {
return getRuleContext(CreateTableHeaderContext.class,0);
}
public CreateTableClausesContext createTableClauses() {
return getRuleContext(CreateTableClausesContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public CreateTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCreateTable(this);
else return visitor.visitChildren(this);
}
}
public static class ShowIndexesContext extends StatementContext {
public TerminalNode SHOW() { return getToken(HoodieSqlBaseParser.SHOW, 0); }
public TerminalNode INDEXES() { return getToken(HoodieSqlBaseParser.INDEXES, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(HoodieSqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(HoodieSqlBaseParser.IN, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public ShowIndexesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterShowIndexes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitShowIndexes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitShowIndexes(this);
else return visitor.visitChildren(this);
}
}
public static class DmlStatementContext extends StatementContext {
public DmlStatementNoWithContext dmlStatementNoWith() {
return getRuleContext(DmlStatementNoWithContext.class,0);
}
public CtesContext ctes() {
return getRuleContext(CtesContext.class,0);
}
public DmlStatementContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterDmlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitDmlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitDmlStatement(this);
else return visitor.visitChildren(this);
}
}
public static class CreateIndexContext extends StatementContext {
public IdentifierContext indexType;
public MultipartIdentifierPropertyListContext columns;
public PropertyListContext indexOptions;
public TerminalNode CREATE() { return getToken(HoodieSqlBaseParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(HoodieSqlBaseParser.INDEX, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public MultipartIdentifierPropertyListContext multipartIdentifierPropertyList() {
return getRuleContext(MultipartIdentifierPropertyListContext.class,0);
}
public TerminalNode IF() { return getToken(HoodieSqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(HoodieSqlBaseParser.EXISTS, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public TerminalNode USING() { return getToken(HoodieSqlBaseParser.USING, 0); }
public TerminalNode OPTIONS() { return getToken(HoodieSqlBaseParser.OPTIONS, 0); }
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public CreateIndexContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCreateIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCreateIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCreateIndex(this);
else return visitor.visitChildren(this);
}
}
public static class DropIndexContext extends StatementContext {
public TerminalNode DROP() { return getToken(HoodieSqlBaseParser.DROP, 0); }
public TerminalNode INDEX() { return getToken(HoodieSqlBaseParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(HoodieSqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(HoodieSqlBaseParser.EXISTS, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public DropIndexContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterDropIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitDropIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitDropIndex(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 2, RULE_statement);
int _la;
try {
int _alt;
setState(384);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
_localctx = new QueryStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(303);
query();
}
break;
case 2:
_localctx = new DmlStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(304);
ctes();
}
}
setState(307);
dmlStatementNoWith();
}
break;
case 3:
_localctx = new CreateTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(308);
createTableHeader();
setState(313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(309);
match(LEFT_PAREN);
setState(310);
colTypeList();
setState(311);
match(RIGHT_PAREN);
}
break;
}
setState(316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(315);
tableProvider();
}
}
setState(318);
createTableClauses();
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==FROM || _la==MAP || ((((_la - 183)) & ~0x3f) == 0 && ((1L << (_la - 183)) & ((1L << (REDUCE - 183)) | (1L << (SELECT - 183)) | (1L << (TABLE - 183)))) != 0) || ((((_la - 256)) & ~0x3f) == 0 && ((1L << (_la - 256)) & ((1L << (VALUES - 256)) | (1L << (WITH - 256)) | (1L << (LEFT_PAREN - 256)))) != 0)) {
{
setState(320);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(319);
match(AS);
}
}
setState(322);
query();
}
}
}
break;
case 4:
_localctx = new CreateIndexContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(325);
match(CREATE);
setState(326);
match(INDEX);
setState(330);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(327);
match(IF);
setState(328);
match(NOT);
setState(329);
match(EXISTS);
}
break;
}
setState(332);
identifier();
setState(333);
match(ON);
setState(335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(334);
match(TABLE);
}
break;
}
setState(337);
tableIdentifier();
setState(340);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(338);
match(USING);
setState(339);
((CreateIndexContext)_localctx).indexType = identifier();
}
}
setState(342);
match(LEFT_PAREN);
setState(343);
((CreateIndexContext)_localctx).columns = multipartIdentifierPropertyList();
setState(344);
match(RIGHT_PAREN);
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(345);
match(OPTIONS);
setState(346);
((CreateIndexContext)_localctx).indexOptions = propertyList();
}
}
}
break;
case 5:
_localctx = new DropIndexContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(349);
match(DROP);
setState(350);
match(INDEX);
setState(353);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(351);
match(IF);
setState(352);
match(EXISTS);
}
break;
}
setState(355);
identifier();
setState(356);
match(ON);
setState(358);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(357);
match(TABLE);
}
break;
}
setState(360);
tableIdentifier();
}
break;
case 6:
_localctx = new ShowIndexesContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(362);
match(SHOW);
setState(363);
match(INDEXES);
setState(364);
_la = _input.LA(1);
if ( !(_la==FROM || _la==IN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(366);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(365);
match(TABLE);
}
break;
}
setState(368);
tableIdentifier();
}
break;
case 7:
_localctx = new RefreshIndexContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(369);
match(REFRESH);
setState(370);
match(INDEX);
setState(371);
identifier();
setState(372);
match(ON);
setState(374);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(373);
match(TABLE);
}
break;
}
setState(376);
tableIdentifier();
}
break;
case 8:
_localctx = new PassThroughContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(381);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(378);
matchWildcard();
}
}
}
setState(383);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleExpressionContext extends ParserRuleContext {
public NamedExpressionContext namedExpression() {
return getRuleContext(NamedExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleExpression(this);
else return visitor.visitChildren(this);
}
}
public final SingleExpressionContext singleExpression() throws RecognitionException {
SingleExpressionContext _localctx = new SingleExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_singleExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(386);
namedExpression();
setState(387);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleTableIdentifierContext extends ParserRuleContext {
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleTableIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleTableIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleTableIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleTableIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleTableIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleTableIdentifierContext singleTableIdentifier() throws RecognitionException {
SingleTableIdentifierContext _localctx = new SingleTableIdentifierContext(_ctx, getState());
enterRule(_localctx, 6, RULE_singleTableIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(389);
tableIdentifier();
setState(390);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleMultipartIdentifierContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleMultipartIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleMultipartIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleMultipartIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleMultipartIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleMultipartIdentifierContext singleMultipartIdentifier() throws RecognitionException {
SingleMultipartIdentifierContext _localctx = new SingleMultipartIdentifierContext(_ctx, getState());
enterRule(_localctx, 8, RULE_singleMultipartIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(392);
multipartIdentifier();
setState(393);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleFunctionIdentifierContext extends ParserRuleContext {
public FunctionIdentifierContext functionIdentifier() {
return getRuleContext(FunctionIdentifierContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleFunctionIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleFunctionIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleFunctionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleFunctionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleFunctionIdentifierContext singleFunctionIdentifier() throws RecognitionException {
SingleFunctionIdentifierContext _localctx = new SingleFunctionIdentifierContext(_ctx, getState());
enterRule(_localctx, 10, RULE_singleFunctionIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(395);
functionIdentifier();
setState(396);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleDataTypeContext extends ParserRuleContext {
public DataTypeContext dataType() {
return getRuleContext(DataTypeContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleDataTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleDataType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleDataType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleDataType(this);
else return visitor.visitChildren(this);
}
}
public final SingleDataTypeContext singleDataType() throws RecognitionException {
SingleDataTypeContext _localctx = new SingleDataTypeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_singleDataType);
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
dataType();
setState(399);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleTableSchemaContext extends ParserRuleContext {
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TerminalNode EOF() { return getToken(HoodieSqlBaseParser.EOF, 0); }
public SingleTableSchemaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleTableSchema; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleTableSchema(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleTableSchema(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleTableSchema(this);
else return visitor.visitChildren(this);
}
}
public final SingleTableSchemaContext singleTableSchema() throws RecognitionException {
SingleTableSchemaContext _localctx = new SingleTableSchemaContext(_ctx, getState());
enterRule(_localctx, 14, RULE_singleTableSchema);
try {
enterOuterAlt(_localctx, 1);
{
setState(401);
colTypeList();
setState(402);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConfigKeyContext extends ParserRuleContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public ConfigKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterConfigKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitConfigKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitConfigKey(this);
else return visitor.visitChildren(this);
}
}
public final ConfigKeyContext configKey() throws RecognitionException {
ConfigKeyContext _localctx = new ConfigKeyContext(_ctx, getState());
enterRule(_localctx, 16, RULE_configKey);
try {
enterOuterAlt(_localctx, 1);
{
setState(404);
quotedIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConfigValueContext extends ParserRuleContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public ConfigValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterConfigValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitConfigValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitConfigValue(this);
else return visitor.visitChildren(this);
}
}
public final ConfigValueContext configValue() throws RecognitionException {
ConfigValueContext _localctx = new ConfigValueContext(_ctx, getState());
enterRule(_localctx, 18, RULE_configValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(406);
quotedIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnsupportedHiveNativeCommandsContext extends ParserRuleContext {
public Token kw1;
public Token kw2;
public Token kw3;
public Token kw4;
public Token kw5;
public Token kw6;
public TerminalNode CREATE() { return getToken(HoodieSqlBaseParser.CREATE, 0); }
public TerminalNode ROLE() { return getToken(HoodieSqlBaseParser.ROLE, 0); }
public TerminalNode DROP() { return getToken(HoodieSqlBaseParser.DROP, 0); }
public TerminalNode GRANT() { return getToken(HoodieSqlBaseParser.GRANT, 0); }
public TerminalNode REVOKE() { return getToken(HoodieSqlBaseParser.REVOKE, 0); }
public TerminalNode SHOW() { return getToken(HoodieSqlBaseParser.SHOW, 0); }
public TerminalNode PRINCIPALS() { return getToken(HoodieSqlBaseParser.PRINCIPALS, 0); }
public TerminalNode ROLES() { return getToken(HoodieSqlBaseParser.ROLES, 0); }
public TerminalNode CURRENT() { return getToken(HoodieSqlBaseParser.CURRENT, 0); }
public TerminalNode EXPORT() { return getToken(HoodieSqlBaseParser.EXPORT, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public TerminalNode IMPORT() { return getToken(HoodieSqlBaseParser.IMPORT, 0); }
public TerminalNode COMPACTIONS() { return getToken(HoodieSqlBaseParser.COMPACTIONS, 0); }
public TerminalNode TRANSACTIONS() { return getToken(HoodieSqlBaseParser.TRANSACTIONS, 0); }
public TerminalNode INDEXES() { return getToken(HoodieSqlBaseParser.INDEXES, 0); }
public TerminalNode LOCKS() { return getToken(HoodieSqlBaseParser.LOCKS, 0); }
public TerminalNode INDEX() { return getToken(HoodieSqlBaseParser.INDEX, 0); }
public TerminalNode ALTER() { return getToken(HoodieSqlBaseParser.ALTER, 0); }
public TerminalNode LOCK() { return getToken(HoodieSqlBaseParser.LOCK, 0); }
public TerminalNode DATABASE() { return getToken(HoodieSqlBaseParser.DATABASE, 0); }
public TerminalNode UNLOCK() { return getToken(HoodieSqlBaseParser.UNLOCK, 0); }
public TerminalNode TEMPORARY() { return getToken(HoodieSqlBaseParser.TEMPORARY, 0); }
public TerminalNode MACRO() { return getToken(HoodieSqlBaseParser.MACRO, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode CLUSTERED() { return getToken(HoodieSqlBaseParser.CLUSTERED, 0); }
public TerminalNode BY() { return getToken(HoodieSqlBaseParser.BY, 0); }
public TerminalNode SORTED() { return getToken(HoodieSqlBaseParser.SORTED, 0); }
public TerminalNode SKEWED() { return getToken(HoodieSqlBaseParser.SKEWED, 0); }
public TerminalNode STORED() { return getToken(HoodieSqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public TerminalNode DIRECTORIES() { return getToken(HoodieSqlBaseParser.DIRECTORIES, 0); }
public TerminalNode SET() { return getToken(HoodieSqlBaseParser.SET, 0); }
public TerminalNode LOCATION() { return getToken(HoodieSqlBaseParser.LOCATION, 0); }
public TerminalNode EXCHANGE() { return getToken(HoodieSqlBaseParser.EXCHANGE, 0); }
public TerminalNode PARTITION() { return getToken(HoodieSqlBaseParser.PARTITION, 0); }
public TerminalNode ARCHIVE() { return getToken(HoodieSqlBaseParser.ARCHIVE, 0); }
public TerminalNode UNARCHIVE() { return getToken(HoodieSqlBaseParser.UNARCHIVE, 0); }
public TerminalNode TOUCH() { return getToken(HoodieSqlBaseParser.TOUCH, 0); }
public TerminalNode COMPACT() { return getToken(HoodieSqlBaseParser.COMPACT, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode CONCATENATE() { return getToken(HoodieSqlBaseParser.CONCATENATE, 0); }
public TerminalNode FILEFORMAT() { return getToken(HoodieSqlBaseParser.FILEFORMAT, 0); }
public TerminalNode REPLACE() { return getToken(HoodieSqlBaseParser.REPLACE, 0); }
public TerminalNode COLUMNS() { return getToken(HoodieSqlBaseParser.COLUMNS, 0); }
public TerminalNode START() { return getToken(HoodieSqlBaseParser.START, 0); }
public TerminalNode TRANSACTION() { return getToken(HoodieSqlBaseParser.TRANSACTION, 0); }
public TerminalNode COMMIT() { return getToken(HoodieSqlBaseParser.COMMIT, 0); }
public TerminalNode ROLLBACK() { return getToken(HoodieSqlBaseParser.ROLLBACK, 0); }
public TerminalNode DFS() { return getToken(HoodieSqlBaseParser.DFS, 0); }
public UnsupportedHiveNativeCommandsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsupportedHiveNativeCommands; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterUnsupportedHiveNativeCommands(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitUnsupportedHiveNativeCommands(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitUnsupportedHiveNativeCommands(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedHiveNativeCommandsContext unsupportedHiveNativeCommands() throws RecognitionException {
UnsupportedHiveNativeCommandsContext _localctx = new UnsupportedHiveNativeCommandsContext(_ctx, getState());
enterRule(_localctx, 20, RULE_unsupportedHiveNativeCommands);
int _la;
try {
setState(576);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(408);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(409);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(410);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(411);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(412);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(GRANT);
setState(414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROLE) {
{
setState(413);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(416);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(REVOKE);
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROLE) {
{
setState(417);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(420);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(421);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(GRANT);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(422);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(423);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
setState(425);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GRANT) {
{
setState(424);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(GRANT);
}
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(427);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(428);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(PRINCIPALS);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(429);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(430);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLES);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(431);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(432);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CURRENT);
setState(433);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ROLES);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(434);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(EXPORT);
setState(435);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(436);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(IMPORT);
setState(437);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(438);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(439);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(COMPACTIONS);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(440);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(441);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CREATE);
setState(442);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TABLE);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(443);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(444);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTIONS);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(445);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(446);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEXES);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(447);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(448);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(LOCKS);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(449);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(450);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(451);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(452);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(453);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(454);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(455);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(456);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(457);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(458);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(459);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(460);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(461);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(462);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(463);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(464);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(465);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(466);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(467);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(468);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(469);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(470);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(471);
tableIdentifier();
setState(472);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(473);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(CLUSTERED);
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(475);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(476);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(477);
tableIdentifier();
setState(478);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CLUSTERED);
setState(479);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(481);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(482);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(483);
tableIdentifier();
setState(484);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(485);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SORTED);
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(487);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(488);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(489);
tableIdentifier();
setState(490);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SKEWED);
setState(491);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(493);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(494);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(495);
tableIdentifier();
setState(496);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(497);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(499);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(500);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(501);
tableIdentifier();
setState(502);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(503);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(STORED);
setState(504);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(AS);
setState(505);
((UnsupportedHiveNativeCommandsContext)_localctx).kw6 = match(DIRECTORIES);
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(507);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(508);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(509);
tableIdentifier();
setState(510);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(511);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
setState(512);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(LOCATION);
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(514);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(515);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(516);
tableIdentifier();
setState(517);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(EXCHANGE);
setState(518);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(520);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(521);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(522);
tableIdentifier();
setState(523);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ARCHIVE);
setState(524);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(526);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(527);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(528);
tableIdentifier();
setState(529);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(UNARCHIVE);
setState(530);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(532);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(533);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(534);
tableIdentifier();
setState(535);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TOUCH);
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(537);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(538);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(539);
tableIdentifier();
setState(541);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(540);
partitionSpec();
}
}
setState(543);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(COMPACT);
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(545);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(546);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(547);
tableIdentifier();
setState(549);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(548);
partitionSpec();
}
}
setState(551);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CONCATENATE);
}
break;
case 39:
enterOuterAlt(_localctx, 39);
{
setState(553);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(554);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(555);
tableIdentifier();
setState(557);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(556);
partitionSpec();
}
}
setState(559);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(560);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(FILEFORMAT);
}
break;
case 40:
enterOuterAlt(_localctx, 40);
{
setState(562);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(563);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(564);
tableIdentifier();
setState(566);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(565);
partitionSpec();
}
}
setState(568);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(REPLACE);
setState(569);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(COLUMNS);
}
break;
case 41:
enterOuterAlt(_localctx, 41);
{
setState(571);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(START);
setState(572);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTION);
}
break;
case 42:
enterOuterAlt(_localctx, 42);
{
setState(573);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(COMMIT);
}
break;
case 43:
enterOuterAlt(_localctx, 43);
{
setState(574);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ROLLBACK);
}
break;
case 44:
enterOuterAlt(_localctx, 44);
{
setState(575);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DFS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableHeaderContext extends ParserRuleContext {
public TerminalNode CREATE() { return getToken(HoodieSqlBaseParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(HoodieSqlBaseParser.TEMPORARY, 0); }
public TerminalNode EXTERNAL() { return getToken(HoodieSqlBaseParser.EXTERNAL, 0); }
public TerminalNode IF() { return getToken(HoodieSqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(HoodieSqlBaseParser.EXISTS, 0); }
public CreateTableHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCreateTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCreateTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCreateTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableHeaderContext createTableHeader() throws RecognitionException {
CreateTableHeaderContext _localctx = new CreateTableHeaderContext(_ctx, getState());
enterRule(_localctx, 22, RULE_createTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(578);
match(CREATE);
setState(580);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(579);
match(TEMPORARY);
}
}
setState(583);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL) {
{
setState(582);
match(EXTERNAL);
}
}
setState(585);
match(TABLE);
setState(589);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(586);
match(IF);
setState(587);
match(NOT);
setState(588);
match(EXISTS);
}
break;
}
setState(591);
multipartIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReplaceTableHeaderContext extends ParserRuleContext {
public TerminalNode REPLACE() { return getToken(HoodieSqlBaseParser.REPLACE, 0); }
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode CREATE() { return getToken(HoodieSqlBaseParser.CREATE, 0); }
public TerminalNode OR() { return getToken(HoodieSqlBaseParser.OR, 0); }
public ReplaceTableHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_replaceTableHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterReplaceTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitReplaceTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitReplaceTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final ReplaceTableHeaderContext replaceTableHeader() throws RecognitionException {
ReplaceTableHeaderContext _localctx = new ReplaceTableHeaderContext(_ctx, getState());
enterRule(_localctx, 24, RULE_replaceTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(595);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(593);
match(CREATE);
setState(594);
match(OR);
}
}
setState(597);
match(REPLACE);
setState(598);
match(TABLE);
setState(599);
multipartIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BucketSpecContext extends ParserRuleContext {
public TerminalNode CLUSTERED() { return getToken(HoodieSqlBaseParser.CLUSTERED, 0); }
public List BY() { return getTokens(HoodieSqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(HoodieSqlBaseParser.BY, i);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode INTO() { return getToken(HoodieSqlBaseParser.INTO, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(HoodieSqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode BUCKETS() { return getToken(HoodieSqlBaseParser.BUCKETS, 0); }
public TerminalNode SORTED() { return getToken(HoodieSqlBaseParser.SORTED, 0); }
public OrderedIdentifierListContext orderedIdentifierList() {
return getRuleContext(OrderedIdentifierListContext.class,0);
}
public BucketSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bucketSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterBucketSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitBucketSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitBucketSpec(this);
else return visitor.visitChildren(this);
}
}
public final BucketSpecContext bucketSpec() throws RecognitionException {
BucketSpecContext _localctx = new BucketSpecContext(_ctx, getState());
enterRule(_localctx, 26, RULE_bucketSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(601);
match(CLUSTERED);
setState(602);
match(BY);
setState(603);
identifierList();
setState(607);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SORTED) {
{
setState(604);
match(SORTED);
setState(605);
match(BY);
setState(606);
orderedIdentifierList();
}
}
setState(609);
match(INTO);
setState(610);
match(INTEGER_VALUE);
setState(611);
match(BUCKETS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SkewSpecContext extends ParserRuleContext {
public TerminalNode SKEWED() { return getToken(HoodieSqlBaseParser.SKEWED, 0); }
public TerminalNode BY() { return getToken(HoodieSqlBaseParser.BY, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public ConstantListContext constantList() {
return getRuleContext(ConstantListContext.class,0);
}
public NestedConstantListContext nestedConstantList() {
return getRuleContext(NestedConstantListContext.class,0);
}
public TerminalNode STORED() { return getToken(HoodieSqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public TerminalNode DIRECTORIES() { return getToken(HoodieSqlBaseParser.DIRECTORIES, 0); }
public SkewSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_skewSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSkewSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSkewSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSkewSpec(this);
else return visitor.visitChildren(this);
}
}
public final SkewSpecContext skewSpec() throws RecognitionException {
SkewSpecContext _localctx = new SkewSpecContext(_ctx, getState());
enterRule(_localctx, 28, RULE_skewSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(613);
match(SKEWED);
setState(614);
match(BY);
setState(615);
identifierList();
setState(616);
match(ON);
setState(619);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
{
setState(617);
constantList();
}
break;
case 2:
{
setState(618);
nestedConstantList();
}
break;
}
setState(624);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(621);
match(STORED);
setState(622);
match(AS);
setState(623);
match(DIRECTORIES);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocationSpecContext extends ParserRuleContext {
public TerminalNode LOCATION() { return getToken(HoodieSqlBaseParser.LOCATION, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public LocationSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_locationSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterLocationSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitLocationSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitLocationSpec(this);
else return visitor.visitChildren(this);
}
}
public final LocationSpecContext locationSpec() throws RecognitionException {
LocationSpecContext _localctx = new LocationSpecContext(_ctx, getState());
enterRule(_localctx, 30, RULE_locationSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(626);
match(LOCATION);
setState(627);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CommentSpecContext extends ParserRuleContext {
public TerminalNode COMMENT() { return getToken(HoodieSqlBaseParser.COMMENT, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public CommentSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCommentSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCommentSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCommentSpec(this);
else return visitor.visitChildren(this);
}
}
public final CommentSpecContext commentSpec() throws RecognitionException {
CommentSpecContext _localctx = new CommentSpecContext(_ctx, getState());
enterRule(_localctx, 32, RULE_commentSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(629);
match(COMMENT);
setState(630);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryContext extends ParserRuleContext {
public QueryTermContext queryTerm() {
return getRuleContext(QueryTermContext.class,0);
}
public QueryOrganizationContext queryOrganization() {
return getRuleContext(QueryOrganizationContext.class,0);
}
public CtesContext ctes() {
return getRuleContext(CtesContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 34, RULE_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(632);
ctes();
}
}
setState(635);
queryTerm(0);
setState(636);
queryOrganization();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertIntoContext extends ParserRuleContext {
public InsertIntoContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertInto; }
public InsertIntoContext() { }
public void copyFrom(InsertIntoContext ctx) {
super.copyFrom(ctx);
}
}
public static class InsertOverwriteHiveDirContext extends InsertIntoContext {
public Token path;
public TerminalNode INSERT() { return getToken(HoodieSqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(HoodieSqlBaseParser.OVERWRITE, 0); }
public TerminalNode DIRECTORY() { return getToken(HoodieSqlBaseParser.DIRECTORY, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TerminalNode LOCAL() { return getToken(HoodieSqlBaseParser.LOCAL, 0); }
public RowFormatContext rowFormat() {
return getRuleContext(RowFormatContext.class,0);
}
public CreateFileFormatContext createFileFormat() {
return getRuleContext(CreateFileFormatContext.class,0);
}
public InsertOverwriteHiveDirContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInsertOverwriteHiveDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInsertOverwriteHiveDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInsertOverwriteHiveDir(this);
else return visitor.visitChildren(this);
}
}
public static class InsertOverwriteDirContext extends InsertIntoContext {
public Token path;
public TablePropertyListContext options;
public TerminalNode INSERT() { return getToken(HoodieSqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(HoodieSqlBaseParser.OVERWRITE, 0); }
public TerminalNode DIRECTORY() { return getToken(HoodieSqlBaseParser.DIRECTORY, 0); }
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public TerminalNode LOCAL() { return getToken(HoodieSqlBaseParser.LOCAL, 0); }
public TerminalNode OPTIONS() { return getToken(HoodieSqlBaseParser.OPTIONS, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public InsertOverwriteDirContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInsertOverwriteDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInsertOverwriteDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInsertOverwriteDir(this);
else return visitor.visitChildren(this);
}
}
public static class InsertOverwriteTableContext extends InsertIntoContext {
public TerminalNode INSERT() { return getToken(HoodieSqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(HoodieSqlBaseParser.OVERWRITE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode IF() { return getToken(HoodieSqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(HoodieSqlBaseParser.EXISTS, 0); }
public InsertOverwriteTableContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInsertOverwriteTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInsertOverwriteTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInsertOverwriteTable(this);
else return visitor.visitChildren(this);
}
}
public static class InsertIntoTableContext extends InsertIntoContext {
public TerminalNode INSERT() { return getToken(HoodieSqlBaseParser.INSERT, 0); }
public TerminalNode INTO() { return getToken(HoodieSqlBaseParser.INTO, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode IF() { return getToken(HoodieSqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(HoodieSqlBaseParser.EXISTS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public InsertIntoTableContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInsertIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInsertIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInsertIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final InsertIntoContext insertInto() throws RecognitionException {
InsertIntoContext _localctx = new InsertIntoContext(_ctx, getState());
enterRule(_localctx, 36, RULE_insertInto);
int _la;
try {
setState(699);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
_localctx = new InsertOverwriteTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(638);
match(INSERT);
setState(639);
match(OVERWRITE);
setState(641);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(640);
match(TABLE);
}
break;
}
setState(643);
multipartIdentifier();
setState(650);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(644);
partitionSpec();
setState(648);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(645);
match(IF);
setState(646);
match(NOT);
setState(647);
match(EXISTS);
}
}
}
}
setState(653);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(652);
identifierList();
}
break;
}
}
break;
case 2:
_localctx = new InsertIntoTableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(655);
match(INSERT);
setState(656);
match(INTO);
setState(658);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
{
setState(657);
match(TABLE);
}
break;
}
setState(660);
multipartIdentifier();
setState(662);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(661);
partitionSpec();
}
}
setState(667);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(664);
match(IF);
setState(665);
match(NOT);
setState(666);
match(EXISTS);
}
}
setState(670);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(669);
identifierList();
}
break;
}
}
break;
case 3:
_localctx = new InsertOverwriteHiveDirContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(672);
match(INSERT);
setState(673);
match(OVERWRITE);
setState(675);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(674);
match(LOCAL);
}
}
setState(677);
match(DIRECTORY);
setState(678);
((InsertOverwriteHiveDirContext)_localctx).path = match(STRING);
setState(680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(679);
rowFormat();
}
}
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORED) {
{
setState(682);
createFileFormat();
}
}
}
break;
case 4:
_localctx = new InsertOverwriteDirContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(685);
match(INSERT);
setState(686);
match(OVERWRITE);
setState(688);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(687);
match(LOCAL);
}
}
setState(690);
match(DIRECTORY);
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING) {
{
setState(691);
((InsertOverwriteDirContext)_localctx).path = match(STRING);
}
}
setState(694);
tableProvider();
setState(697);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(695);
match(OPTIONS);
setState(696);
((InsertOverwriteDirContext)_localctx).options = tablePropertyList();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionSpecLocationContext extends ParserRuleContext {
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public LocationSpecContext locationSpec() {
return getRuleContext(LocationSpecContext.class,0);
}
public PartitionSpecLocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionSpecLocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPartitionSpecLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPartitionSpecLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPartitionSpecLocation(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecLocationContext partitionSpecLocation() throws RecognitionException {
PartitionSpecLocationContext _localctx = new PartitionSpecLocationContext(_ctx, getState());
enterRule(_localctx, 38, RULE_partitionSpecLocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(701);
partitionSpec();
setState(703);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCATION) {
{
setState(702);
locationSpec();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionSpecContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(HoodieSqlBaseParser.PARTITION, 0); }
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List partitionVal() {
return getRuleContexts(PartitionValContext.class);
}
public PartitionValContext partitionVal(int i) {
return getRuleContext(PartitionValContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public PartitionSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPartitionSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPartitionSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPartitionSpec(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecContext partitionSpec() throws RecognitionException {
PartitionSpecContext _localctx = new PartitionSpecContext(_ctx, getState());
enterRule(_localctx, 40, RULE_partitionSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(705);
match(PARTITION);
setState(706);
match(LEFT_PAREN);
setState(707);
partitionVal();
setState(712);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(708);
match(COMMA);
setState(709);
partitionVal();
}
}
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(715);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionValContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(HoodieSqlBaseParser.EQ, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public PartitionValContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionVal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPartitionVal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPartitionVal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPartitionVal(this);
else return visitor.visitChildren(this);
}
}
public final PartitionValContext partitionVal() throws RecognitionException {
PartitionValContext _localctx = new PartitionValContext(_ctx, getState());
enterRule(_localctx, 42, RULE_partitionVal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(717);
identifier();
setState(720);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(718);
match(EQ);
setState(719);
constant();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespaceContext extends ParserRuleContext {
public TerminalNode NAMESPACE() { return getToken(HoodieSqlBaseParser.NAMESPACE, 0); }
public TerminalNode DATABASE() { return getToken(HoodieSqlBaseParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(HoodieSqlBaseParser.SCHEMA, 0); }
public NamespaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitNamespace(this);
else return visitor.visitChildren(this);
}
}
public final NamespaceContext namespace() throws RecognitionException {
NamespaceContext _localctx = new NamespaceContext(_ctx, getState());
enterRule(_localctx, 44, RULE_namespace);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(722);
_la = _input.LA(1);
if ( !(_la==DATABASE || _la==NAMESPACE || _la==SCHEMA) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescribeFuncNameContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ArithmeticOperatorContext arithmeticOperator() {
return getRuleContext(ArithmeticOperatorContext.class,0);
}
public PredicateOperatorContext predicateOperator() {
return getRuleContext(PredicateOperatorContext.class,0);
}
public DescribeFuncNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_describeFuncName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterDescribeFuncName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitDescribeFuncName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitDescribeFuncName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeFuncNameContext describeFuncName() throws RecognitionException {
DescribeFuncNameContext _localctx = new DescribeFuncNameContext(_ctx, getState());
enterRule(_localctx, 46, RULE_describeFuncName);
try {
setState(729);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(724);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(725);
match(STRING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(726);
comparisonOperator();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(727);
arithmeticOperator();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(728);
predicateOperator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescribeColNameContext extends ParserRuleContext {
public IdentifierContext identifier;
public List nameParts = new ArrayList();
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(HoodieSqlBaseParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(HoodieSqlBaseParser.DOT, i);
}
public DescribeColNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_describeColName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterDescribeColName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitDescribeColName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitDescribeColName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeColNameContext describeColName() throws RecognitionException {
DescribeColNameContext _localctx = new DescribeColNameContext(_ctx, getState());
enterRule(_localctx, 48, RULE_describeColName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(731);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
setState(736);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(732);
match(DOT);
setState(733);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
}
}
setState(738);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CtesContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(HoodieSqlBaseParser.WITH, 0); }
public List namedQuery() {
return getRuleContexts(NamedQueryContext.class);
}
public NamedQueryContext namedQuery(int i) {
return getRuleContext(NamedQueryContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public CtesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCtes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCtes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCtes(this);
else return visitor.visitChildren(this);
}
}
public final CtesContext ctes() throws RecognitionException {
CtesContext _localctx = new CtesContext(_ctx, getState());
enterRule(_localctx, 50, RULE_ctes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(739);
match(WITH);
setState(740);
namedQuery();
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(741);
match(COMMA);
setState(742);
namedQuery();
}
}
setState(747);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedQueryContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext name;
public IdentifierListContext columnAliases;
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public NamedQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterNamedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitNamedQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitNamedQuery(this);
else return visitor.visitChildren(this);
}
}
public final NamedQueryContext namedQuery() throws RecognitionException {
NamedQueryContext _localctx = new NamedQueryContext(_ctx, getState());
enterRule(_localctx, 52, RULE_namedQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(748);
((NamedQueryContext)_localctx).name = errorCapturingIdentifier();
setState(750);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
{
setState(749);
((NamedQueryContext)_localctx).columnAliases = identifierList();
}
break;
}
setState(753);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(752);
match(AS);
}
}
setState(755);
match(LEFT_PAREN);
setState(756);
query();
setState(757);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TableProviderContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(HoodieSqlBaseParser.USING, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableProviderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableProvider; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableProvider(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableProvider(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableProvider(this);
else return visitor.visitChildren(this);
}
}
public final TableProviderContext tableProvider() throws RecognitionException {
TableProviderContext _localctx = new TableProviderContext(_ctx, getState());
enterRule(_localctx, 54, RULE_tableProvider);
try {
enterOuterAlt(_localctx, 1);
{
setState(759);
match(USING);
setState(760);
multipartIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateTableClausesContext extends ParserRuleContext {
public TablePropertyListContext options;
public PartitionFieldListContext partitioning;
public TablePropertyListContext tableProps;
public List skewSpec() {
return getRuleContexts(SkewSpecContext.class);
}
public SkewSpecContext skewSpec(int i) {
return getRuleContext(SkewSpecContext.class,i);
}
public List bucketSpec() {
return getRuleContexts(BucketSpecContext.class);
}
public BucketSpecContext bucketSpec(int i) {
return getRuleContext(BucketSpecContext.class,i);
}
public List rowFormat() {
return getRuleContexts(RowFormatContext.class);
}
public RowFormatContext rowFormat(int i) {
return getRuleContext(RowFormatContext.class,i);
}
public List createFileFormat() {
return getRuleContexts(CreateFileFormatContext.class);
}
public CreateFileFormatContext createFileFormat(int i) {
return getRuleContext(CreateFileFormatContext.class,i);
}
public List locationSpec() {
return getRuleContexts(LocationSpecContext.class);
}
public LocationSpecContext locationSpec(int i) {
return getRuleContext(LocationSpecContext.class,i);
}
public List commentSpec() {
return getRuleContexts(CommentSpecContext.class);
}
public CommentSpecContext commentSpec(int i) {
return getRuleContext(CommentSpecContext.class,i);
}
public List OPTIONS() { return getTokens(HoodieSqlBaseParser.OPTIONS); }
public TerminalNode OPTIONS(int i) {
return getToken(HoodieSqlBaseParser.OPTIONS, i);
}
public List PARTITIONED() { return getTokens(HoodieSqlBaseParser.PARTITIONED); }
public TerminalNode PARTITIONED(int i) {
return getToken(HoodieSqlBaseParser.PARTITIONED, i);
}
public List BY() { return getTokens(HoodieSqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(HoodieSqlBaseParser.BY, i);
}
public List TBLPROPERTIES() { return getTokens(HoodieSqlBaseParser.TBLPROPERTIES); }
public TerminalNode TBLPROPERTIES(int i) {
return getToken(HoodieSqlBaseParser.TBLPROPERTIES, i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public List partitionFieldList() {
return getRuleContexts(PartitionFieldListContext.class);
}
public PartitionFieldListContext partitionFieldList(int i) {
return getRuleContext(PartitionFieldListContext.class,i);
}
public CreateTableClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCreateTableClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCreateTableClauses(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCreateTableClauses(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableClausesContext createTableClauses() throws RecognitionException {
CreateTableClausesContext _localctx = new CreateTableClausesContext(_ctx, getState());
enterRule(_localctx, 56, RULE_createTableClauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(777);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CLUSTERED || _la==COMMENT || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (LOCATION - 134)) | (1L << (OPTIONS - 134)) | (1L << (PARTITIONED - 134)))) != 0) || ((((_la - 199)) & ~0x3f) == 0 && ((1L << (_la - 199)) & ((1L << (ROW - 199)) | (1L << (SKEWED - 199)) | (1L << (STORED - 199)) | (1L << (TBLPROPERTIES - 199)))) != 0)) {
{
setState(775);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPTIONS:
{
{
setState(762);
match(OPTIONS);
setState(763);
((CreateTableClausesContext)_localctx).options = tablePropertyList();
}
}
break;
case PARTITIONED:
{
{
setState(764);
match(PARTITIONED);
setState(765);
match(BY);
setState(766);
((CreateTableClausesContext)_localctx).partitioning = partitionFieldList();
}
}
break;
case SKEWED:
{
setState(767);
skewSpec();
}
break;
case CLUSTERED:
{
setState(768);
bucketSpec();
}
break;
case ROW:
{
setState(769);
rowFormat();
}
break;
case STORED:
{
setState(770);
createFileFormat();
}
break;
case LOCATION:
{
setState(771);
locationSpec();
}
break;
case COMMENT:
{
setState(772);
commentSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(773);
match(TBLPROPERTIES);
setState(774);
((CreateTableClausesContext)_localctx).tableProps = tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TablePropertyListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List tableProperty() {
return getRuleContexts(TablePropertyContext.class);
}
public TablePropertyContext tableProperty(int i) {
return getRuleContext(TablePropertyContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public TablePropertyListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tablePropertyList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTablePropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTablePropertyList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTablePropertyList(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyListContext tablePropertyList() throws RecognitionException {
TablePropertyListContext _localctx = new TablePropertyListContext(_ctx, getState());
enterRule(_localctx, 58, RULE_tablePropertyList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(780);
match(LEFT_PAREN);
setState(781);
tableProperty();
setState(786);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(782);
match(COMMA);
setState(783);
tableProperty();
}
}
setState(788);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(789);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TablePropertyContext extends ParserRuleContext {
public TablePropertyKeyContext key;
public TablePropertyValueContext value;
public TablePropertyKeyContext tablePropertyKey() {
return getRuleContext(TablePropertyKeyContext.class,0);
}
public TablePropertyValueContext tablePropertyValue() {
return getRuleContext(TablePropertyValueContext.class,0);
}
public TerminalNode EQ() { return getToken(HoodieSqlBaseParser.EQ, 0); }
public TablePropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableProperty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableProperty(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyContext tableProperty() throws RecognitionException {
TablePropertyContext _localctx = new TablePropertyContext(_ctx, getState());
enterRule(_localctx, 60, RULE_tableProperty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(791);
((TablePropertyContext)_localctx).key = tablePropertyKey();
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FALSE || ((((_la - 240)) & ~0x3f) == 0 && ((1L << (_la - 240)) & ((1L << (TRUE - 240)) | (1L << (EQ - 240)) | (1L << (STRING - 240)) | (1L << (INTEGER_VALUE - 240)) | (1L << (DECIMAL_VALUE - 240)))) != 0)) {
{
setState(793);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(792);
match(EQ);
}
}
setState(795);
((TablePropertyContext)_localctx).value = tablePropertyValue();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TablePropertyKeyContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(HoodieSqlBaseParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(HoodieSqlBaseParser.DOT, i);
}
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TablePropertyKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tablePropertyKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTablePropertyKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTablePropertyKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTablePropertyKey(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyKeyContext tablePropertyKey() throws RecognitionException {
TablePropertyKeyContext _localctx = new TablePropertyKeyContext(_ctx, getState());
enterRule(_localctx, 62, RULE_tablePropertyKey);
int _la;
try {
setState(807);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(798);
identifier();
setState(803);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(799);
match(DOT);
setState(800);
identifier();
}
}
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(806);
match(STRING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TablePropertyValueContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(HoodieSqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode DECIMAL_VALUE() { return getToken(HoodieSqlBaseParser.DECIMAL_VALUE, 0); }
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TablePropertyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tablePropertyValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTablePropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTablePropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTablePropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyValueContext tablePropertyValue() throws RecognitionException {
TablePropertyValueContext _localctx = new TablePropertyValueContext(_ctx, getState());
enterRule(_localctx, 64, RULE_tablePropertyValue);
try {
setState(813);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(809);
match(INTEGER_VALUE);
}
break;
case DECIMAL_VALUE:
enterOuterAlt(_localctx, 2);
{
setState(810);
match(DECIMAL_VALUE);
}
break;
case FALSE:
case TRUE:
enterOuterAlt(_localctx, 3);
{
setState(811);
booleanValue();
}
break;
case STRING:
enterOuterAlt(_localctx, 4);
{
setState(812);
match(STRING);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public ConstantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitConstantList(this);
else return visitor.visitChildren(this);
}
}
public final ConstantListContext constantList() throws RecognitionException {
ConstantListContext _localctx = new ConstantListContext(_ctx, getState());
enterRule(_localctx, 66, RULE_constantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(815);
match(LEFT_PAREN);
setState(816);
constant();
setState(821);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(817);
match(COMMA);
setState(818);
constant();
}
}
setState(823);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(824);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NestedConstantListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List constantList() {
return getRuleContexts(ConstantListContext.class);
}
public ConstantListContext constantList(int i) {
return getRuleContext(ConstantListContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public NestedConstantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nestedConstantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterNestedConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitNestedConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitNestedConstantList(this);
else return visitor.visitChildren(this);
}
}
public final NestedConstantListContext nestedConstantList() throws RecognitionException {
NestedConstantListContext _localctx = new NestedConstantListContext(_ctx, getState());
enterRule(_localctx, 68, RULE_nestedConstantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(826);
match(LEFT_PAREN);
setState(827);
constantList();
setState(832);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(828);
match(COMMA);
setState(829);
constantList();
}
}
setState(834);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(835);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateFileFormatContext extends ParserRuleContext {
public TerminalNode STORED() { return getToken(HoodieSqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public FileFormatContext fileFormat() {
return getRuleContext(FileFormatContext.class,0);
}
public TerminalNode BY() { return getToken(HoodieSqlBaseParser.BY, 0); }
public StorageHandlerContext storageHandler() {
return getRuleContext(StorageHandlerContext.class,0);
}
public CreateFileFormatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createFileFormat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterCreateFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitCreateFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitCreateFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final CreateFileFormatContext createFileFormat() throws RecognitionException {
CreateFileFormatContext _localctx = new CreateFileFormatContext(_ctx, getState());
enterRule(_localctx, 70, RULE_createFileFormat);
try {
setState(843);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(837);
match(STORED);
setState(838);
match(AS);
setState(839);
fileFormat();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(840);
match(STORED);
setState(841);
match(BY);
setState(842);
storageHandler();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FileFormatContext extends ParserRuleContext {
public FileFormatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fileFormat; }
public FileFormatContext() { }
public void copyFrom(FileFormatContext ctx) {
super.copyFrom(ctx);
}
}
public static class TableFileFormatContext extends FileFormatContext {
public Token inFmt;
public Token outFmt;
public TerminalNode INPUTFORMAT() { return getToken(HoodieSqlBaseParser.INPUTFORMAT, 0); }
public TerminalNode OUTPUTFORMAT() { return getToken(HoodieSqlBaseParser.OUTPUTFORMAT, 0); }
public List STRING() { return getTokens(HoodieSqlBaseParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(HoodieSqlBaseParser.STRING, i);
}
public TableFileFormatContext(FileFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableFileFormat(this);
else return visitor.visitChildren(this);
}
}
public static class GenericFileFormatContext extends FileFormatContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public GenericFileFormatContext(FileFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterGenericFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitGenericFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitGenericFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final FileFormatContext fileFormat() throws RecognitionException {
FileFormatContext _localctx = new FileFormatContext(_ctx, getState());
enterRule(_localctx, 72, RULE_fileFormat);
try {
setState(850);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
_localctx = new TableFileFormatContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(845);
match(INPUTFORMAT);
setState(846);
((TableFileFormatContext)_localctx).inFmt = match(STRING);
setState(847);
match(OUTPUTFORMAT);
setState(848);
((TableFileFormatContext)_localctx).outFmt = match(STRING);
}
break;
case 2:
_localctx = new GenericFileFormatContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(849);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StorageHandlerContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TerminalNode WITH() { return getToken(HoodieSqlBaseParser.WITH, 0); }
public TerminalNode SERDEPROPERTIES() { return getToken(HoodieSqlBaseParser.SERDEPROPERTIES, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public StorageHandlerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_storageHandler; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterStorageHandler(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitStorageHandler(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitStorageHandler(this);
else return visitor.visitChildren(this);
}
}
public final StorageHandlerContext storageHandler() throws RecognitionException {
StorageHandlerContext _localctx = new StorageHandlerContext(_ctx, getState());
enterRule(_localctx, 74, RULE_storageHandler);
try {
enterOuterAlt(_localctx, 1);
{
setState(852);
match(STRING);
setState(856);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(853);
match(WITH);
setState(854);
match(SERDEPROPERTIES);
setState(855);
tablePropertyList();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitResource(this);
else return visitor.visitChildren(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 76, RULE_resource);
try {
enterOuterAlt(_localctx, 1);
{
setState(858);
identifier();
setState(859);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DmlStatementNoWithContext extends ParserRuleContext {
public DmlStatementNoWithContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dmlStatementNoWith; }
public DmlStatementNoWithContext() { }
public void copyFrom(DmlStatementNoWithContext ctx) {
super.copyFrom(ctx);
}
}
public static class DeleteFromTableContext extends DmlStatementNoWithContext {
public TerminalNode DELETE() { return getToken(HoodieSqlBaseParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(HoodieSqlBaseParser.FROM, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public DeleteFromTableContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterDeleteFromTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitDeleteFromTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitDeleteFromTable(this);
else return visitor.visitChildren(this);
}
}
public static class SingleInsertQueryContext extends DmlStatementNoWithContext {
public InsertIntoContext insertInto() {
return getRuleContext(InsertIntoContext.class,0);
}
public QueryTermContext queryTerm() {
return getRuleContext(QueryTermContext.class,0);
}
public QueryOrganizationContext queryOrganization() {
return getRuleContext(QueryOrganizationContext.class,0);
}
public SingleInsertQueryContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSingleInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSingleInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSingleInsertQuery(this);
else return visitor.visitChildren(this);
}
}
public static class MultiInsertQueryContext extends DmlStatementNoWithContext {
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public List multiInsertQueryBody() {
return getRuleContexts(MultiInsertQueryBodyContext.class);
}
public MultiInsertQueryBodyContext multiInsertQueryBody(int i) {
return getRuleContext(MultiInsertQueryBodyContext.class,i);
}
public MultiInsertQueryContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMultiInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMultiInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMultiInsertQuery(this);
else return visitor.visitChildren(this);
}
}
public static class UpdateTableContext extends DmlStatementNoWithContext {
public TerminalNode UPDATE() { return getToken(HoodieSqlBaseParser.UPDATE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public SetClauseContext setClause() {
return getRuleContext(SetClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public UpdateTableContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterUpdateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitUpdateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitUpdateTable(this);
else return visitor.visitChildren(this);
}
}
public static class MergeIntoTableContext extends DmlStatementNoWithContext {
public MultipartIdentifierContext target;
public TableAliasContext targetAlias;
public MultipartIdentifierContext source;
public QueryContext sourceQuery;
public TableAliasContext sourceAlias;
public BooleanExpressionContext mergeCondition;
public TerminalNode MERGE() { return getToken(HoodieSqlBaseParser.MERGE, 0); }
public TerminalNode INTO() { return getToken(HoodieSqlBaseParser.INTO, 0); }
public TerminalNode USING() { return getToken(HoodieSqlBaseParser.USING, 0); }
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public List tableAlias() {
return getRuleContexts(TableAliasContext.class);
}
public TableAliasContext tableAlias(int i) {
return getRuleContext(TableAliasContext.class,i);
}
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public List matchedClause() {
return getRuleContexts(MatchedClauseContext.class);
}
public MatchedClauseContext matchedClause(int i) {
return getRuleContext(MatchedClauseContext.class,i);
}
public List notMatchedClause() {
return getRuleContexts(NotMatchedClauseContext.class);
}
public NotMatchedClauseContext notMatchedClause(int i) {
return getRuleContext(NotMatchedClauseContext.class,i);
}
public MergeIntoTableContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMergeIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMergeIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMergeIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final DmlStatementNoWithContext dmlStatementNoWith() throws RecognitionException {
DmlStatementNoWithContext _localctx = new DmlStatementNoWithContext(_ctx, getState());
enterRule(_localctx, 78, RULE_dmlStatementNoWith);
int _la;
try {
int _alt;
setState(912);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INSERT:
_localctx = new SingleInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(861);
insertInto();
setState(862);
queryTerm(0);
setState(863);
queryOrganization();
}
break;
case FROM:
_localctx = new MultiInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(865);
fromClause();
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(866);
multiInsertQueryBody();
}
}
setState(869);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
}
break;
case DELETE:
_localctx = new DeleteFromTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(871);
match(DELETE);
setState(872);
match(FROM);
setState(873);
multipartIdentifier();
setState(874);
tableAlias();
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(875);
whereClause();
}
}
}
break;
case UPDATE:
_localctx = new UpdateTableContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(878);
match(UPDATE);
setState(879);
multipartIdentifier();
setState(880);
tableAlias();
setState(881);
setClause();
setState(883);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(882);
whereClause();
}
}
}
break;
case MERGE:
_localctx = new MergeIntoTableContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(885);
match(MERGE);
setState(886);
match(INTO);
setState(887);
((MergeIntoTableContext)_localctx).target = multipartIdentifier();
setState(888);
((MergeIntoTableContext)_localctx).targetAlias = tableAlias();
setState(889);
match(USING);
setState(895);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(890);
((MergeIntoTableContext)_localctx).source = multipartIdentifier();
}
break;
case 2:
{
setState(891);
match(LEFT_PAREN);
setState(892);
((MergeIntoTableContext)_localctx).sourceQuery = query();
setState(893);
match(RIGHT_PAREN);
}
break;
}
setState(897);
((MergeIntoTableContext)_localctx).sourceAlias = tableAlias();
setState(898);
match(ON);
setState(899);
((MergeIntoTableContext)_localctx).mergeCondition = booleanExpression(0);
setState(903);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(900);
matchedClause();
}
}
}
setState(905);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
}
setState(909);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WHEN) {
{
{
setState(906);
notMatchedClause();
}
}
setState(911);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryOrganizationContext extends ParserRuleContext {
public SortItemContext sortItem;
public List order = new ArrayList();
public ExpressionContext expression;
public List clusterBy = new ArrayList();
public List distributeBy = new ArrayList();
public List sort = new ArrayList();
public ExpressionContext limit;
public TerminalNode ORDER() { return getToken(HoodieSqlBaseParser.ORDER, 0); }
public List BY() { return getTokens(HoodieSqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(HoodieSqlBaseParser.BY, i);
}
public TerminalNode CLUSTER() { return getToken(HoodieSqlBaseParser.CLUSTER, 0); }
public TerminalNode DISTRIBUTE() { return getToken(HoodieSqlBaseParser.DISTRIBUTE, 0); }
public TerminalNode SORT() { return getToken(HoodieSqlBaseParser.SORT, 0); }
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public TerminalNode LIMIT() { return getToken(HoodieSqlBaseParser.LIMIT, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ALL() { return getToken(HoodieSqlBaseParser.ALL, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public QueryOrganizationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOrganization; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterQueryOrganization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitQueryOrganization(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitQueryOrganization(this);
else return visitor.visitChildren(this);
}
}
public final QueryOrganizationContext queryOrganization() throws RecognitionException {
QueryOrganizationContext _localctx = new QueryOrganizationContext(_ctx, getState());
enterRule(_localctx, 80, RULE_queryOrganization);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(924);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(914);
match(ORDER);
setState(915);
match(BY);
setState(916);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
setState(921);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(917);
match(COMMA);
setState(918);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(923);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
}
}
break;
}
setState(936);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(926);
match(CLUSTER);
setState(927);
match(BY);
setState(928);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
setState(933);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(929);
match(COMMA);
setState(930);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(935);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
}
}
break;
}
setState(948);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(938);
match(DISTRIBUTE);
setState(939);
match(BY);
setState(940);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
setState(945);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(941);
match(COMMA);
setState(942);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(947);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
}
}
break;
}
setState(960);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
{
setState(950);
match(SORT);
setState(951);
match(BY);
setState(952);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
setState(957);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(953);
match(COMMA);
setState(954);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(959);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
}
}
break;
}
setState(963);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(962);
windowClause();
}
break;
}
setState(970);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(965);
match(LIMIT);
setState(968);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(966);
match(ALL);
}
break;
case 2:
{
setState(967);
((QueryOrganizationContext)_localctx).limit = expression();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiInsertQueryBodyContext extends ParserRuleContext {
public InsertIntoContext insertInto() {
return getRuleContext(InsertIntoContext.class,0);
}
public FromStatementBodyContext fromStatementBody() {
return getRuleContext(FromStatementBodyContext.class,0);
}
public MultiInsertQueryBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiInsertQueryBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMultiInsertQueryBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMultiInsertQueryBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMultiInsertQueryBody(this);
else return visitor.visitChildren(this);
}
}
public final MultiInsertQueryBodyContext multiInsertQueryBody() throws RecognitionException {
MultiInsertQueryBodyContext _localctx = new MultiInsertQueryBodyContext(_ctx, getState());
enterRule(_localctx, 82, RULE_multiInsertQueryBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(972);
insertInto();
setState(973);
fromStatementBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QueryTermContext extends ParserRuleContext {
public QueryTermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryTerm; }
public QueryTermContext() { }
public void copyFrom(QueryTermContext ctx) {
super.copyFrom(ctx);
}
}
public static class QueryTermDefaultContext extends QueryTermContext {
public QueryPrimaryContext queryPrimary() {
return getRuleContext(QueryPrimaryContext.class,0);
}
public QueryTermDefaultContext(QueryTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterQueryTermDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitQueryTermDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitQueryTermDefault(this);
else return visitor.visitChildren(this);
}
}
public static class SetOperationContext extends QueryTermContext {
public QueryTermContext left;
public Token operator;
public QueryTermContext right;
public List queryTerm() {
return getRuleContexts(QueryTermContext.class);
}
public QueryTermContext queryTerm(int i) {
return getRuleContext(QueryTermContext.class,i);
}
public TerminalNode INTERSECT() { return getToken(HoodieSqlBaseParser.INTERSECT, 0); }
public TerminalNode UNION() { return getToken(HoodieSqlBaseParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(HoodieSqlBaseParser.EXCEPT, 0); }
public TerminalNode SETMINUS() { return getToken(HoodieSqlBaseParser.SETMINUS, 0); }
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public SetOperationContext(QueryTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSetOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSetOperation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSetOperation(this);
else return visitor.visitChildren(this);
}
}
public final QueryTermContext queryTerm() throws RecognitionException {
return queryTerm(0);
}
private QueryTermContext queryTerm(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
QueryTermContext _localctx = new QueryTermContext(_ctx, _parentState);
QueryTermContext _prevctx = _localctx;
int _startState = 84;
enterRecursionRule(_localctx, 84, RULE_queryTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new QueryTermDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(976);
queryPrimary();
}
_ctx.stop = _input.LT(-1);
setState(1001);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(999);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(978);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(979);
if (!(legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "legacy_setops_precedence_enabled");
setState(980);
((SetOperationContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==SETMINUS || _la==UNION) ) {
((SetOperationContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(982);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(981);
setQuantifier();
}
}
setState(984);
((SetOperationContext)_localctx).right = queryTerm(4);
}
break;
case 2:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(985);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(986);
if (!(!legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enabled");
setState(987);
((SetOperationContext)_localctx).operator = match(INTERSECT);
setState(989);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(988);
setQuantifier();
}
}
setState(991);
((SetOperationContext)_localctx).right = queryTerm(3);
}
break;
case 3:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(992);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(993);
if (!(!legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enabled");
setState(994);
((SetOperationContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==SETMINUS || _la==UNION) ) {
((SetOperationContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(996);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(995);
setQuantifier();
}
}
setState(998);
((SetOperationContext)_localctx).right = queryTerm(2);
}
break;
}
}
}
setState(1003);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class QueryPrimaryContext extends ParserRuleContext {
public QueryPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryPrimary; }
public QueryPrimaryContext() { }
public void copyFrom(QueryPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
public static class SubqueryContext extends QueryPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public SubqueryContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSubquery(this);
else return visitor.visitChildren(this);
}
}
public static class QueryPrimaryDefaultContext extends QueryPrimaryContext {
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public QueryPrimaryDefaultContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterQueryPrimaryDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitQueryPrimaryDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitQueryPrimaryDefault(this);
else return visitor.visitChildren(this);
}
}
public static class InlineTableDefault1Context extends QueryPrimaryContext {
public InlineTableContext inlineTable() {
return getRuleContext(InlineTableContext.class,0);
}
public InlineTableDefault1Context(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInlineTableDefault1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInlineTableDefault1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInlineTableDefault1(this);
else return visitor.visitChildren(this);
}
}
public static class FromStmtContext extends QueryPrimaryContext {
public FromStatementContext fromStatement() {
return getRuleContext(FromStatementContext.class,0);
}
public FromStmtContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterFromStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitFromStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitFromStmt(this);
else return visitor.visitChildren(this);
}
}
public static class TableContext extends QueryPrimaryContext {
public TerminalNode TABLE() { return getToken(HoodieSqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTable(this);
else return visitor.visitChildren(this);
}
}
public final QueryPrimaryContext queryPrimary() throws RecognitionException {
QueryPrimaryContext _localctx = new QueryPrimaryContext(_ctx, getState());
enterRule(_localctx, 86, RULE_queryPrimary);
try {
setState(1013);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MAP:
case REDUCE:
case SELECT:
_localctx = new QueryPrimaryDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1004);
querySpecification();
}
break;
case FROM:
_localctx = new FromStmtContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1005);
fromStatement();
}
break;
case TABLE:
_localctx = new TableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1006);
match(TABLE);
setState(1007);
multipartIdentifier();
}
break;
case VALUES:
_localctx = new InlineTableDefault1Context(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1008);
inlineTable();
}
break;
case LEFT_PAREN:
_localctx = new SubqueryContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1009);
match(LEFT_PAREN);
setState(1010);
query();
setState(1011);
match(RIGHT_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SortItemContext extends ParserRuleContext {
public Token ordering;
public Token nullOrder;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NULLS() { return getToken(HoodieSqlBaseParser.NULLS, 0); }
public TerminalNode ASC() { return getToken(HoodieSqlBaseParser.ASC, 0); }
public TerminalNode DESC() { return getToken(HoodieSqlBaseParser.DESC, 0); }
public TerminalNode LAST() { return getToken(HoodieSqlBaseParser.LAST, 0); }
public TerminalNode FIRST() { return getToken(HoodieSqlBaseParser.FIRST, 0); }
public SortItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sortItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSortItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSortItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSortItem(this);
else return visitor.visitChildren(this);
}
}
public final SortItemContext sortItem() throws RecognitionException {
SortItemContext _localctx = new SortItemContext(_ctx, getState());
enterRule(_localctx, 88, RULE_sortItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1015);
expression();
setState(1017);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(1016);
((SortItemContext)_localctx).ordering = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
((SortItemContext)_localctx).ordering = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1021);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
{
setState(1019);
match(NULLS);
setState(1020);
((SortItemContext)_localctx).nullOrder = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
((SortItemContext)_localctx).nullOrder = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromStatementContext extends ParserRuleContext {
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public List fromStatementBody() {
return getRuleContexts(FromStatementBodyContext.class);
}
public FromStatementBodyContext fromStatementBody(int i) {
return getRuleContext(FromStatementBodyContext.class,i);
}
public FromStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterFromStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitFromStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitFromStatement(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementContext fromStatement() throws RecognitionException {
FromStatementContext _localctx = new FromStatementContext(_ctx, getState());
enterRule(_localctx, 90, RULE_fromStatement);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1023);
fromClause();
setState(1025);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1024);
fromStatementBody();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1027);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromStatementBodyContext extends ParserRuleContext {
public TransformClauseContext transformClause() {
return getRuleContext(TransformClauseContext.class,0);
}
public QueryOrganizationContext queryOrganization() {
return getRuleContext(QueryOrganizationContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public List lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public AggregationClauseContext aggregationClause() {
return getRuleContext(AggregationClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public FromStatementBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromStatementBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterFromStatementBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitFromStatementBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitFromStatementBody(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementBodyContext fromStatementBody() throws RecognitionException {
FromStatementBodyContext _localctx = new FromStatementBodyContext(_ctx, getState());
enterRule(_localctx, 92, RULE_fromStatementBody);
try {
int _alt;
setState(1056);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1029);
transformClause();
setState(1031);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(1030);
whereClause();
}
break;
}
setState(1033);
queryOrganization();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1035);
selectClause();
setState(1039);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1036);
lateralView();
}
}
}
setState(1041);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
}
setState(1043);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(1042);
whereClause();
}
break;
}
setState(1046);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(1045);
aggregationClause();
}
break;
}
setState(1049);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(1048);
havingClause();
}
break;
}
setState(1052);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
{
setState(1051);
windowClause();
}
break;
}
setState(1054);
queryOrganization();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuerySpecificationContext extends ParserRuleContext {
public QuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySpecification; }
public QuerySpecificationContext() { }
public void copyFrom(QuerySpecificationContext ctx) {
super.copyFrom(ctx);
}
}
public static class RegularQuerySpecificationContext extends QuerySpecificationContext {
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public List lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public AggregationClauseContext aggregationClause() {
return getRuleContext(AggregationClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public RegularQuerySpecificationContext(QuerySpecificationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterRegularQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitRegularQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitRegularQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public static class TransformQuerySpecificationContext extends QuerySpecificationContext {
public TransformClauseContext transformClause() {
return getRuleContext(TransformClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public List lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public AggregationClauseContext aggregationClause() {
return getRuleContext(AggregationClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public TransformQuerySpecificationContext(QuerySpecificationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTransformQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTransformQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTransformQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 94, RULE_querySpecification);
try {
int _alt;
setState(1102);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
_localctx = new TransformQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1058);
transformClause();
setState(1060);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(1059);
fromClause();
}
break;
}
setState(1065);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,102,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1062);
lateralView();
}
}
}
setState(1067);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,102,_ctx);
}
setState(1069);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
{
setState(1068);
whereClause();
}
break;
}
setState(1072);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
{
setState(1071);
aggregationClause();
}
break;
}
setState(1075);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
{
setState(1074);
havingClause();
}
break;
}
setState(1078);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(1077);
windowClause();
}
break;
}
}
break;
case 2:
_localctx = new RegularQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1080);
selectClause();
setState(1082);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
{
setState(1081);
fromClause();
}
break;
}
setState(1087);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1084);
lateralView();
}
}
}
setState(1089);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
}
setState(1091);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
{
setState(1090);
whereClause();
}
break;
}
setState(1094);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
setState(1093);
aggregationClause();
}
break;
}
setState(1097);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(1096);
havingClause();
}
break;
}
setState(1100);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(1099);
windowClause();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformClauseContext extends ParserRuleContext {
public Token kind;
public RowFormatContext inRowFormat;
public Token recordWriter;
public Token script;
public RowFormatContext outRowFormat;
public Token recordReader;
public TerminalNode USING() { return getToken(HoodieSqlBaseParser.USING, 0); }
public List STRING() { return getTokens(HoodieSqlBaseParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(HoodieSqlBaseParser.STRING, i);
}
public TerminalNode SELECT() { return getToken(HoodieSqlBaseParser.SELECT, 0); }
public List LEFT_PAREN() { return getTokens(HoodieSqlBaseParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.LEFT_PAREN, i);
}
public ExpressionSeqContext expressionSeq() {
return getRuleContext(ExpressionSeqContext.class,0);
}
public List RIGHT_PAREN() { return getTokens(HoodieSqlBaseParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.RIGHT_PAREN, i);
}
public TerminalNode TRANSFORM() { return getToken(HoodieSqlBaseParser.TRANSFORM, 0); }
public TerminalNode MAP() { return getToken(HoodieSqlBaseParser.MAP, 0); }
public TerminalNode REDUCE() { return getToken(HoodieSqlBaseParser.REDUCE, 0); }
public TerminalNode RECORDWRITER() { return getToken(HoodieSqlBaseParser.RECORDWRITER, 0); }
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public TerminalNode RECORDREADER() { return getToken(HoodieSqlBaseParser.RECORDREADER, 0); }
public List rowFormat() {
return getRuleContexts(RowFormatContext.class);
}
public RowFormatContext rowFormat(int i) {
return getRuleContext(RowFormatContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TransformClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transformClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTransformClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTransformClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTransformClause(this);
else return visitor.visitChildren(this);
}
}
public final TransformClauseContext transformClause() throws RecognitionException {
TransformClauseContext _localctx = new TransformClauseContext(_ctx, getState());
enterRule(_localctx, 96, RULE_transformClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1123);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(1104);
match(SELECT);
setState(1105);
((TransformClauseContext)_localctx).kind = match(TRANSFORM);
setState(1106);
match(LEFT_PAREN);
setState(1108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(1107);
setQuantifier();
}
break;
}
setState(1110);
expressionSeq();
setState(1111);
match(RIGHT_PAREN);
}
break;
case MAP:
{
setState(1113);
((TransformClauseContext)_localctx).kind = match(MAP);
setState(1115);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(1114);
setQuantifier();
}
break;
}
setState(1117);
expressionSeq();
}
break;
case REDUCE:
{
setState(1118);
((TransformClauseContext)_localctx).kind = match(REDUCE);
setState(1120);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
setState(1119);
setQuantifier();
}
break;
}
setState(1122);
expressionSeq();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1126);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(1125);
((TransformClauseContext)_localctx).inRowFormat = rowFormat();
}
}
setState(1130);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORDWRITER) {
{
setState(1128);
match(RECORDWRITER);
setState(1129);
((TransformClauseContext)_localctx).recordWriter = match(STRING);
}
}
setState(1132);
match(USING);
setState(1133);
((TransformClauseContext)_localctx).script = match(STRING);
setState(1146);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1134);
match(AS);
setState(1144);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(1135);
identifierSeq();
}
break;
case 2:
{
setState(1136);
colTypeList();
}
break;
case 3:
{
{
setState(1137);
match(LEFT_PAREN);
setState(1140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
case 1:
{
setState(1138);
identifierSeq();
}
break;
case 2:
{
setState(1139);
colTypeList();
}
break;
}
setState(1142);
match(RIGHT_PAREN);
}
}
break;
}
}
break;
}
setState(1149);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1148);
((TransformClauseContext)_localctx).outRowFormat = rowFormat();
}
break;
}
setState(1153);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1151);
match(RECORDREADER);
setState(1152);
((TransformClauseContext)_localctx).recordReader = match(STRING);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseContext extends ParserRuleContext {
public HintContext hint;
public List hints = new ArrayList();
public TerminalNode SELECT() { return getToken(HoodieSqlBaseParser.SELECT, 0); }
public NamedExpressionSeqContext namedExpressionSeq() {
return getRuleContext(NamedExpressionSeqContext.class,0);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public List hint() {
return getRuleContexts(HintContext.class);
}
public HintContext hint(int i) {
return getRuleContext(HintContext.class,i);
}
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 98, RULE_selectClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1155);
match(SELECT);
setState(1159);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1156);
((SelectClauseContext)_localctx).hint = hint();
((SelectClauseContext)_localctx).hints.add(((SelectClauseContext)_localctx).hint);
}
}
}
setState(1161);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
}
setState(1163);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(1162);
setQuantifier();
}
break;
}
setState(1165);
namedExpressionSeq();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetClauseContext extends ParserRuleContext {
public TerminalNode SET() { return getToken(HoodieSqlBaseParser.SET, 0); }
public AssignmentListContext assignmentList() {
return getRuleContext(AssignmentListContext.class,0);
}
public SetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSetClause(this);
else return visitor.visitChildren(this);
}
}
public final SetClauseContext setClause() throws RecognitionException {
SetClauseContext _localctx = new SetClauseContext(_ctx, getState());
enterRule(_localctx, 100, RULE_setClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1167);
match(SET);
setState(1168);
assignmentList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchedClauseContext extends ParserRuleContext {
public BooleanExpressionContext matchedCond;
public TerminalNode WHEN() { return getToken(HoodieSqlBaseParser.WHEN, 0); }
public TerminalNode MATCHED() { return getToken(HoodieSqlBaseParser.MATCHED, 0); }
public TerminalNode THEN() { return getToken(HoodieSqlBaseParser.THEN, 0); }
public MatchedActionContext matchedAction() {
return getRuleContext(MatchedActionContext.class,0);
}
public TerminalNode AND() { return getToken(HoodieSqlBaseParser.AND, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public MatchedClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchedClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final MatchedClauseContext matchedClause() throws RecognitionException {
MatchedClauseContext _localctx = new MatchedClauseContext(_ctx, getState());
enterRule(_localctx, 102, RULE_matchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1170);
match(WHEN);
setState(1171);
match(MATCHED);
setState(1174);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1172);
match(AND);
setState(1173);
((MatchedClauseContext)_localctx).matchedCond = booleanExpression(0);
}
}
setState(1176);
match(THEN);
setState(1177);
matchedAction();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotMatchedClauseContext extends ParserRuleContext {
public BooleanExpressionContext notMatchedCond;
public TerminalNode WHEN() { return getToken(HoodieSqlBaseParser.WHEN, 0); }
public TerminalNode NOT() { return getToken(HoodieSqlBaseParser.NOT, 0); }
public TerminalNode MATCHED() { return getToken(HoodieSqlBaseParser.MATCHED, 0); }
public TerminalNode THEN() { return getToken(HoodieSqlBaseParser.THEN, 0); }
public NotMatchedActionContext notMatchedAction() {
return getRuleContext(NotMatchedActionContext.class,0);
}
public TerminalNode AND() { return getToken(HoodieSqlBaseParser.AND, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public NotMatchedClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterNotMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitNotMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitNotMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedClauseContext notMatchedClause() throws RecognitionException {
NotMatchedClauseContext _localctx = new NotMatchedClauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_notMatchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1179);
match(WHEN);
setState(1180);
match(NOT);
setState(1181);
match(MATCHED);
setState(1184);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1182);
match(AND);
setState(1183);
((NotMatchedClauseContext)_localctx).notMatchedCond = booleanExpression(0);
}
}
setState(1186);
match(THEN);
setState(1187);
notMatchedAction();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MatchedActionContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(HoodieSqlBaseParser.DELETE, 0); }
public TerminalNode UPDATE() { return getToken(HoodieSqlBaseParser.UPDATE, 0); }
public TerminalNode SET() { return getToken(HoodieSqlBaseParser.SET, 0); }
public TerminalNode ASTERISK() { return getToken(HoodieSqlBaseParser.ASTERISK, 0); }
public AssignmentListContext assignmentList() {
return getRuleContext(AssignmentListContext.class,0);
}
public MatchedActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchedAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final MatchedActionContext matchedAction() throws RecognitionException {
MatchedActionContext _localctx = new MatchedActionContext(_ctx, getState());
enterRule(_localctx, 106, RULE_matchedAction);
try {
setState(1196);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1189);
match(DELETE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1190);
match(UPDATE);
setState(1191);
match(SET);
setState(1192);
match(ASTERISK);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1193);
match(UPDATE);
setState(1194);
match(SET);
setState(1195);
assignmentList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotMatchedActionContext extends ParserRuleContext {
public MultipartIdentifierListContext columns;
public TerminalNode INSERT() { return getToken(HoodieSqlBaseParser.INSERT, 0); }
public TerminalNode ASTERISK() { return getToken(HoodieSqlBaseParser.ASTERISK, 0); }
public List LEFT_PAREN() { return getTokens(HoodieSqlBaseParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.LEFT_PAREN, i);
}
public List RIGHT_PAREN() { return getTokens(HoodieSqlBaseParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.RIGHT_PAREN, i);
}
public TerminalNode VALUES() { return getToken(HoodieSqlBaseParser.VALUES, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public MultipartIdentifierListContext multipartIdentifierList() {
return getRuleContext(MultipartIdentifierListContext.class,0);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public NotMatchedActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterNotMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitNotMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitNotMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedActionContext notMatchedAction() throws RecognitionException {
NotMatchedActionContext _localctx = new NotMatchedActionContext(_ctx, getState());
enterRule(_localctx, 108, RULE_notMatchedAction);
int _la;
try {
setState(1216);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1198);
match(INSERT);
setState(1199);
match(ASTERISK);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1200);
match(INSERT);
setState(1201);
match(LEFT_PAREN);
setState(1202);
((NotMatchedActionContext)_localctx).columns = multipartIdentifierList();
setState(1203);
match(RIGHT_PAREN);
setState(1204);
match(VALUES);
setState(1205);
match(LEFT_PAREN);
setState(1206);
expression();
setState(1211);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1207);
match(COMMA);
setState(1208);
expression();
}
}
setState(1213);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1214);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentListContext extends ParserRuleContext {
public List assignment() {
return getRuleContexts(AssignmentContext.class);
}
public AssignmentContext assignment(int i) {
return getRuleContext(AssignmentContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public AssignmentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterAssignmentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitAssignmentList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitAssignmentList(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentListContext assignmentList() throws RecognitionException {
AssignmentListContext _localctx = new AssignmentListContext(_ctx, getState());
enterRule(_localctx, 110, RULE_assignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1218);
assignment();
setState(1223);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1219);
match(COMMA);
setState(1220);
assignment();
}
}
setState(1225);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentContext extends ParserRuleContext {
public MultipartIdentifierContext key;
public ExpressionContext value;
public TerminalNode EQ() { return getToken(HoodieSqlBaseParser.EQ, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitAssignment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitAssignment(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 112, RULE_assignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(1226);
((AssignmentContext)_localctx).key = multipartIdentifier();
setState(1227);
match(EQ);
setState(1228);
((AssignmentContext)_localctx).value = expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereClauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(HoodieSqlBaseParser.WHERE, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 114, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1230);
match(WHERE);
setState(1231);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(HoodieSqlBaseParser.HAVING, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitHavingClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 116, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1233);
match(HAVING);
setState(1234);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HintContext extends ParserRuleContext {
public HintStatementContext hintStatement;
public List hintStatements = new ArrayList();
public List hintStatement() {
return getRuleContexts(HintStatementContext.class);
}
public HintStatementContext hintStatement(int i) {
return getRuleContext(HintStatementContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public HintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterHint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitHint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitHint(this);
else return visitor.visitChildren(this);
}
}
public final HintContext hint() throws RecognitionException {
HintContext _localctx = new HintContext(_ctx, getState());
enterRule(_localctx, 118, RULE_hint);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1236);
match(T__0);
setState(1237);
((HintContext)_localctx).hintStatement = hintStatement();
((HintContext)_localctx).hintStatements.add(((HintContext)_localctx).hintStatement);
setState(1244);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1239);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1238);
match(COMMA);
}
break;
}
setState(1241);
((HintContext)_localctx).hintStatement = hintStatement();
((HintContext)_localctx).hintStatements.add(((HintContext)_localctx).hintStatement);
}
}
}
setState(1246);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
}
setState(1247);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HintStatementContext extends ParserRuleContext {
public IdentifierContext hintName;
public PrimaryExpressionContext primaryExpression;
public List parameters = new ArrayList();
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List primaryExpression() {
return getRuleContexts(PrimaryExpressionContext.class);
}
public PrimaryExpressionContext primaryExpression(int i) {
return getRuleContext(PrimaryExpressionContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public HintStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hintStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterHintStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitHintStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitHintStatement(this);
else return visitor.visitChildren(this);
}
}
public final HintStatementContext hintStatement() throws RecognitionException {
HintStatementContext _localctx = new HintStatementContext(_ctx, getState());
enterRule(_localctx, 120, RULE_hintStatement);
int _la;
try {
setState(1262);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1249);
((HintStatementContext)_localctx).hintName = identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1250);
((HintStatementContext)_localctx).hintName = identifier();
setState(1251);
match(LEFT_PAREN);
setState(1252);
((HintStatementContext)_localctx).primaryExpression = primaryExpression(0);
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).primaryExpression);
setState(1257);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1253);
match(COMMA);
setState(1254);
((HintStatementContext)_localctx).primaryExpression = primaryExpression(0);
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).primaryExpression);
}
}
setState(1259);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1260);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(HoodieSqlBaseParser.FROM, 0); }
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public List lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public PivotClauseContext pivotClause() {
return getRuleContext(PivotClauseContext.class,0);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 122, RULE_fromClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1264);
match(FROM);
setState(1265);
relation();
setState(1270);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1266);
match(COMMA);
setState(1267);
relation();
}
}
}
setState(1272);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
}
setState(1276);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1273);
lateralView();
}
}
}
setState(1278);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
}
setState(1280);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1279);
pivotClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemporalClauseContext extends ParserRuleContext {
public ValueExpressionContext timestamp;
public Token version;
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public TerminalNode OF() { return getToken(HoodieSqlBaseParser.OF, 0); }
public TerminalNode SYSTEM_TIME() { return getToken(HoodieSqlBaseParser.SYSTEM_TIME, 0); }
public TerminalNode TIMESTAMP() { return getToken(HoodieSqlBaseParser.TIMESTAMP, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode FOR() { return getToken(HoodieSqlBaseParser.FOR, 0); }
public TerminalNode SYSTEM_VERSION() { return getToken(HoodieSqlBaseParser.SYSTEM_VERSION, 0); }
public TerminalNode VERSION() { return getToken(HoodieSqlBaseParser.VERSION, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(HoodieSqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TemporalClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_temporalClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTemporalClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTemporalClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTemporalClause(this);
else return visitor.visitChildren(this);
}
}
public final TemporalClauseContext temporalClause() throws RecognitionException {
TemporalClauseContext _localctx = new TemporalClauseContext(_ctx, getState());
enterRule(_localctx, 124, RULE_temporalClause);
int _la;
try {
setState(1296);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1282);
match(FOR);
}
}
setState(1285);
_la = _input.LA(1);
if ( !(_la==SYSTEM_TIME || _la==TIMESTAMP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1286);
match(AS);
setState(1287);
match(OF);
setState(1288);
((TemporalClauseContext)_localctx).timestamp = valueExpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1289);
match(FOR);
}
}
setState(1292);
_la = _input.LA(1);
if ( !(_la==SYSTEM_VERSION || _la==VERSION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1293);
match(AS);
setState(1294);
match(OF);
setState(1295);
((TemporalClauseContext)_localctx).version = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==STRING || _la==INTEGER_VALUE) ) {
((TemporalClauseContext)_localctx).version = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AggregationClauseContext extends ParserRuleContext {
public GroupByClauseContext groupByClause;
public List groupingExpressionsWithGroupingAnalytics = new ArrayList();
public ExpressionContext expression;
public List groupingExpressions = new ArrayList();
public Token kind;
public TerminalNode GROUP() { return getToken(HoodieSqlBaseParser.GROUP, 0); }
public TerminalNode BY() { return getToken(HoodieSqlBaseParser.BY, 0); }
public List groupByClause() {
return getRuleContexts(GroupByClauseContext.class);
}
public GroupByClauseContext groupByClause(int i) {
return getRuleContext(GroupByClauseContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode WITH() { return getToken(HoodieSqlBaseParser.WITH, 0); }
public TerminalNode SETS() { return getToken(HoodieSqlBaseParser.SETS, 0); }
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TerminalNode ROLLUP() { return getToken(HoodieSqlBaseParser.ROLLUP, 0); }
public TerminalNode CUBE() { return getToken(HoodieSqlBaseParser.CUBE, 0); }
public TerminalNode GROUPING() { return getToken(HoodieSqlBaseParser.GROUPING, 0); }
public AggregationClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aggregationClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterAggregationClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitAggregationClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitAggregationClause(this);
else return visitor.visitChildren(this);
}
}
public final AggregationClauseContext aggregationClause() throws RecognitionException {
AggregationClauseContext _localctx = new AggregationClauseContext(_ctx, getState());
enterRule(_localctx, 126, RULE_aggregationClause);
int _la;
try {
int _alt;
setState(1337);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1298);
match(GROUP);
setState(1299);
match(BY);
setState(1300);
((AggregationClauseContext)_localctx).groupByClause = groupByClause();
((AggregationClauseContext)_localctx).groupingExpressionsWithGroupingAnalytics.add(((AggregationClauseContext)_localctx).groupByClause);
setState(1305);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1301);
match(COMMA);
setState(1302);
((AggregationClauseContext)_localctx).groupByClause = groupByClause();
((AggregationClauseContext)_localctx).groupingExpressionsWithGroupingAnalytics.add(((AggregationClauseContext)_localctx).groupByClause);
}
}
}
setState(1307);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1308);
match(GROUP);
setState(1309);
match(BY);
setState(1310);
((AggregationClauseContext)_localctx).expression = expression();
((AggregationClauseContext)_localctx).groupingExpressions.add(((AggregationClauseContext)_localctx).expression);
setState(1315);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1311);
match(COMMA);
setState(1312);
((AggregationClauseContext)_localctx).expression = expression();
((AggregationClauseContext)_localctx).groupingExpressions.add(((AggregationClauseContext)_localctx).expression);
}
}
}
setState(1317);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
}
setState(1335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1318);
match(WITH);
setState(1319);
((AggregationClauseContext)_localctx).kind = match(ROLLUP);
}
break;
case 2:
{
setState(1320);
match(WITH);
setState(1321);
((AggregationClauseContext)_localctx).kind = match(CUBE);
}
break;
case 3:
{
setState(1322);
((AggregationClauseContext)_localctx).kind = match(GROUPING);
setState(1323);
match(SETS);
setState(1324);
match(LEFT_PAREN);
setState(1325);
groupingSet();
setState(1330);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1326);
match(COMMA);
setState(1327);
groupingSet();
}
}
setState(1332);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1333);
match(RIGHT_PAREN);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByClauseContext extends ParserRuleContext {
public GroupingAnalyticsContext groupingAnalytics() {
return getRuleContext(GroupingAnalyticsContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GroupByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterGroupByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitGroupByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitGroupByClause(this);
else return visitor.visitChildren(this);
}
}
public final GroupByClauseContext groupByClause() throws RecognitionException {
GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_groupByClause);
try {
setState(1341);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1339);
groupingAnalytics();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1340);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupingAnalyticsContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TerminalNode ROLLUP() { return getToken(HoodieSqlBaseParser.ROLLUP, 0); }
public TerminalNode CUBE() { return getToken(HoodieSqlBaseParser.CUBE, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public TerminalNode GROUPING() { return getToken(HoodieSqlBaseParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(HoodieSqlBaseParser.SETS, 0); }
public List groupingElement() {
return getRuleContexts(GroupingElementContext.class);
}
public GroupingElementContext groupingElement(int i) {
return getRuleContext(GroupingElementContext.class,i);
}
public GroupingAnalyticsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingAnalytics; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterGroupingAnalytics(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitGroupingAnalytics(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitGroupingAnalytics(this);
else return visitor.visitChildren(this);
}
}
public final GroupingAnalyticsContext groupingAnalytics() throws RecognitionException {
GroupingAnalyticsContext _localctx = new GroupingAnalyticsContext(_ctx, getState());
enterRule(_localctx, 130, RULE_groupingAnalytics);
int _la;
try {
setState(1368);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CUBE:
case ROLLUP:
enterOuterAlt(_localctx, 1);
{
setState(1343);
_la = _input.LA(1);
if ( !(_la==CUBE || _la==ROLLUP) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1344);
match(LEFT_PAREN);
setState(1345);
groupingSet();
setState(1350);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1346);
match(COMMA);
setState(1347);
groupingSet();
}
}
setState(1352);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1353);
match(RIGHT_PAREN);
}
break;
case GROUPING:
enterOuterAlt(_localctx, 2);
{
setState(1355);
match(GROUPING);
setState(1356);
match(SETS);
setState(1357);
match(LEFT_PAREN);
setState(1358);
groupingElement();
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1359);
match(COMMA);
setState(1360);
groupingElement();
}
}
setState(1365);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1366);
match(RIGHT_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupingElementContext extends ParserRuleContext {
public GroupingAnalyticsContext groupingAnalytics() {
return getRuleContext(GroupingAnalyticsContext.class,0);
}
public GroupingSetContext groupingSet() {
return getRuleContext(GroupingSetContext.class,0);
}
public GroupingElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterGroupingElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitGroupingElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitGroupingElement(this);
else return visitor.visitChildren(this);
}
}
public final GroupingElementContext groupingElement() throws RecognitionException {
GroupingElementContext _localctx = new GroupingElementContext(_ctx, getState());
enterRule(_localctx, 132, RULE_groupingElement);
try {
setState(1372);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1370);
groupingAnalytics();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1371);
groupingSet();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupingSetContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public GroupingSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterGroupingSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitGroupingSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitGroupingSet(this);
else return visitor.visitChildren(this);
}
}
public final GroupingSetContext groupingSet() throws RecognitionException {
GroupingSetContext _localctx = new GroupingSetContext(_ctx, getState());
enterRule(_localctx, 134, RULE_groupingSet);
int _la;
try {
setState(1387);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1374);
match(LEFT_PAREN);
setState(1383);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
{
setState(1375);
expression();
setState(1380);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1376);
match(COMMA);
setState(1377);
expression();
}
}
setState(1382);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1385);
match(RIGHT_PAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1386);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PivotClauseContext extends ParserRuleContext {
public NamedExpressionSeqContext aggregates;
public PivotValueContext pivotValue;
public List pivotValues = new ArrayList();
public TerminalNode PIVOT() { return getToken(HoodieSqlBaseParser.PIVOT, 0); }
public List LEFT_PAREN() { return getTokens(HoodieSqlBaseParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.LEFT_PAREN, i);
}
public TerminalNode FOR() { return getToken(HoodieSqlBaseParser.FOR, 0); }
public PivotColumnContext pivotColumn() {
return getRuleContext(PivotColumnContext.class,0);
}
public TerminalNode IN() { return getToken(HoodieSqlBaseParser.IN, 0); }
public List RIGHT_PAREN() { return getTokens(HoodieSqlBaseParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(HoodieSqlBaseParser.RIGHT_PAREN, i);
}
public NamedExpressionSeqContext namedExpressionSeq() {
return getRuleContext(NamedExpressionSeqContext.class,0);
}
public List pivotValue() {
return getRuleContexts(PivotValueContext.class);
}
public PivotValueContext pivotValue(int i) {
return getRuleContext(PivotValueContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public PivotClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pivotClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPivotClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPivotClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPivotClause(this);
else return visitor.visitChildren(this);
}
}
public final PivotClauseContext pivotClause() throws RecognitionException {
PivotClauseContext _localctx = new PivotClauseContext(_ctx, getState());
enterRule(_localctx, 136, RULE_pivotClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1389);
match(PIVOT);
setState(1390);
match(LEFT_PAREN);
setState(1391);
((PivotClauseContext)_localctx).aggregates = namedExpressionSeq();
setState(1392);
match(FOR);
setState(1393);
pivotColumn();
setState(1394);
match(IN);
setState(1395);
match(LEFT_PAREN);
setState(1396);
((PivotClauseContext)_localctx).pivotValue = pivotValue();
((PivotClauseContext)_localctx).pivotValues.add(((PivotClauseContext)_localctx).pivotValue);
setState(1401);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1397);
match(COMMA);
setState(1398);
((PivotClauseContext)_localctx).pivotValue = pivotValue();
((PivotClauseContext)_localctx).pivotValues.add(((PivotClauseContext)_localctx).pivotValue);
}
}
setState(1403);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1404);
match(RIGHT_PAREN);
setState(1405);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PivotColumnContext extends ParserRuleContext {
public IdentifierContext identifier;
public List identifiers = new ArrayList();
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public PivotColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pivotColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPivotColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPivotColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPivotColumn(this);
else return visitor.visitChildren(this);
}
}
public final PivotColumnContext pivotColumn() throws RecognitionException {
PivotColumnContext _localctx = new PivotColumnContext(_ctx, getState());
enterRule(_localctx, 138, RULE_pivotColumn);
int _la;
try {
setState(1419);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1407);
((PivotColumnContext)_localctx).identifier = identifier();
((PivotColumnContext)_localctx).identifiers.add(((PivotColumnContext)_localctx).identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1408);
match(LEFT_PAREN);
setState(1409);
((PivotColumnContext)_localctx).identifier = identifier();
((PivotColumnContext)_localctx).identifiers.add(((PivotColumnContext)_localctx).identifier);
setState(1414);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1410);
match(COMMA);
setState(1411);
((PivotColumnContext)_localctx).identifier = identifier();
((PivotColumnContext)_localctx).identifiers.add(((PivotColumnContext)_localctx).identifier);
}
}
setState(1416);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1417);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PivotValueContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public PivotValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pivotValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterPivotValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitPivotValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitPivotValue(this);
else return visitor.visitChildren(this);
}
}
public final PivotValueContext pivotValue() throws RecognitionException {
PivotValueContext _localctx = new PivotValueContext(_ctx, getState());
enterRule(_localctx, 140, RULE_pivotValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(1421);
expression();
setState(1426);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1423);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1422);
match(AS);
}
break;
}
setState(1425);
identifier();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LateralViewContext extends ParserRuleContext {
public IdentifierContext tblName;
public IdentifierContext identifier;
public List colName = new ArrayList();
public TerminalNode LATERAL() { return getToken(HoodieSqlBaseParser.LATERAL, 0); }
public TerminalNode VIEW() { return getToken(HoodieSqlBaseParser.VIEW, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode OUTER() { return getToken(HoodieSqlBaseParser.OUTER, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public LateralViewContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lateralView; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterLateralView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitLateralView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitLateralView(this);
else return visitor.visitChildren(this);
}
}
public final LateralViewContext lateralView() throws RecognitionException {
LateralViewContext _localctx = new LateralViewContext(_ctx, getState());
enterRule(_localctx, 142, RULE_lateralView);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1428);
match(LATERAL);
setState(1429);
match(VIEW);
setState(1431);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1430);
match(OUTER);
}
break;
}
setState(1433);
qualifiedName();
setState(1434);
match(LEFT_PAREN);
setState(1443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
setState(1435);
expression();
setState(1440);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1436);
match(COMMA);
setState(1437);
expression();
}
}
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1445);
match(RIGHT_PAREN);
setState(1446);
((LateralViewContext)_localctx).tblName = identifier();
setState(1458);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
setState(1448);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
{
setState(1447);
match(AS);
}
break;
}
setState(1450);
((LateralViewContext)_localctx).identifier = identifier();
((LateralViewContext)_localctx).colName.add(((LateralViewContext)_localctx).identifier);
setState(1455);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1451);
match(COMMA);
setState(1452);
((LateralViewContext)_localctx).identifier = identifier();
((LateralViewContext)_localctx).colName.add(((LateralViewContext)_localctx).identifier);
}
}
}
setState(1457);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetQuantifierContext extends ParserRuleContext {
public TerminalNode DISTINCT() { return getToken(HoodieSqlBaseParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(HoodieSqlBaseParser.ALL, 0); }
public SetQuantifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setQuantifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSetQuantifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSetQuantifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSetQuantifier(this);
else return visitor.visitChildren(this);
}
}
public final SetQuantifierContext setQuantifier() throws RecognitionException {
SetQuantifierContext _localctx = new SetQuantifierContext(_ctx, getState());
enterRule(_localctx, 144, RULE_setQuantifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1460);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationContext extends ParserRuleContext {
public RelationPrimaryContext relationPrimary() {
return getRuleContext(RelationPrimaryContext.class,0);
}
public TerminalNode LATERAL() { return getToken(HoodieSqlBaseParser.LATERAL, 0); }
public List joinRelation() {
return getRuleContexts(JoinRelationContext.class);
}
public JoinRelationContext joinRelation(int i) {
return getRuleContext(JoinRelationContext.class,i);
}
public RelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitRelation(this);
else return visitor.visitChildren(this);
}
}
public final RelationContext relation() throws RecognitionException {
RelationContext _localctx = new RelationContext(_ctx, getState());
enterRule(_localctx, 146, RULE_relation);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1463);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
{
setState(1462);
match(LATERAL);
}
break;
}
setState(1465);
relationPrimary();
setState(1469);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1466);
joinRelation();
}
}
}
setState(1471);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinRelationContext extends ParserRuleContext {
public RelationPrimaryContext right;
public TerminalNode JOIN() { return getToken(HoodieSqlBaseParser.JOIN, 0); }
public RelationPrimaryContext relationPrimary() {
return getRuleContext(RelationPrimaryContext.class,0);
}
public JoinTypeContext joinType() {
return getRuleContext(JoinTypeContext.class,0);
}
public TerminalNode LATERAL() { return getToken(HoodieSqlBaseParser.LATERAL, 0); }
public JoinCriteriaContext joinCriteria() {
return getRuleContext(JoinCriteriaContext.class,0);
}
public TerminalNode NATURAL() { return getToken(HoodieSqlBaseParser.NATURAL, 0); }
public JoinRelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinRelation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterJoinRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitJoinRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitJoinRelation(this);
else return visitor.visitChildren(this);
}
}
public final JoinRelationContext joinRelation() throws RecognitionException {
JoinRelationContext _localctx = new JoinRelationContext(_ctx, getState());
enterRule(_localctx, 148, RULE_joinRelation);
try {
setState(1489);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ANTI:
case CROSS:
case FULL:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
case SEMI:
enterOuterAlt(_localctx, 1);
{
{
setState(1472);
joinType();
}
setState(1473);
match(JOIN);
setState(1475);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(1474);
match(LATERAL);
}
break;
}
setState(1477);
((JoinRelationContext)_localctx).right = relationPrimary();
setState(1479);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
{
setState(1478);
joinCriteria();
}
break;
}
}
break;
case NATURAL:
enterOuterAlt(_localctx, 2);
{
setState(1481);
match(NATURAL);
setState(1482);
joinType();
setState(1483);
match(JOIN);
setState(1485);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
{
setState(1484);
match(LATERAL);
}
break;
}
setState(1487);
((JoinRelationContext)_localctx).right = relationPrimary();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinTypeContext extends ParserRuleContext {
public TerminalNode INNER() { return getToken(HoodieSqlBaseParser.INNER, 0); }
public TerminalNode CROSS() { return getToken(HoodieSqlBaseParser.CROSS, 0); }
public TerminalNode LEFT() { return getToken(HoodieSqlBaseParser.LEFT, 0); }
public TerminalNode OUTER() { return getToken(HoodieSqlBaseParser.OUTER, 0); }
public TerminalNode SEMI() { return getToken(HoodieSqlBaseParser.SEMI, 0); }
public TerminalNode RIGHT() { return getToken(HoodieSqlBaseParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(HoodieSqlBaseParser.FULL, 0); }
public TerminalNode ANTI() { return getToken(HoodieSqlBaseParser.ANTI, 0); }
public JoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterJoinType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitJoinType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitJoinType(this);
else return visitor.visitChildren(this);
}
}
public final JoinTypeContext joinType() throws RecognitionException {
JoinTypeContext _localctx = new JoinTypeContext(_ctx, getState());
enterRule(_localctx, 150, RULE_joinType);
int _la;
try {
setState(1515);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1492);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(1491);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1494);
match(CROSS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1495);
match(LEFT);
setState(1497);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(1496);
match(OUTER);
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1500);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT) {
{
setState(1499);
match(LEFT);
}
}
setState(1502);
match(SEMI);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1503);
match(RIGHT);
setState(1505);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(1504);
match(OUTER);
}
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1507);
match(FULL);
setState(1509);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(1508);
match(OUTER);
}
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1512);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT) {
{
setState(1511);
match(LEFT);
}
}
setState(1514);
match(ANTI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinCriteriaContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode USING() { return getToken(HoodieSqlBaseParser.USING, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public JoinCriteriaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinCriteria; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterJoinCriteria(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitJoinCriteria(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitJoinCriteria(this);
else return visitor.visitChildren(this);
}
}
public final JoinCriteriaContext joinCriteria() throws RecognitionException {
JoinCriteriaContext _localctx = new JoinCriteriaContext(_ctx, getState());
enterRule(_localctx, 152, RULE_joinCriteria);
try {
setState(1521);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ON:
enterOuterAlt(_localctx, 1);
{
setState(1517);
match(ON);
setState(1518);
booleanExpression(0);
}
break;
case USING:
enterOuterAlt(_localctx, 2);
{
setState(1519);
match(USING);
setState(1520);
identifierList();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SampleContext extends ParserRuleContext {
public TerminalNode TABLESAMPLE() { return getToken(HoodieSqlBaseParser.TABLESAMPLE, 0); }
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public SampleMethodContext sampleMethod() {
return getRuleContext(SampleMethodContext.class,0);
}
public SampleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sample; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSample(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSample(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSample(this);
else return visitor.visitChildren(this);
}
}
public final SampleContext sample() throws RecognitionException {
SampleContext _localctx = new SampleContext(_ctx, getState());
enterRule(_localctx, 154, RULE_sample);
try {
enterOuterAlt(_localctx, 1);
{
setState(1523);
match(TABLESAMPLE);
setState(1524);
match(LEFT_PAREN);
setState(1526);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
case 1:
{
setState(1525);
sampleMethod();
}
break;
}
setState(1528);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SampleMethodContext extends ParserRuleContext {
public SampleMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampleMethod; }
public SampleMethodContext() { }
public void copyFrom(SampleMethodContext ctx) {
super.copyFrom(ctx);
}
}
public static class SampleByRowsContext extends SampleMethodContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode ROWS() { return getToken(HoodieSqlBaseParser.ROWS, 0); }
public SampleByRowsContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSampleByRows(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSampleByRows(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSampleByRows(this);
else return visitor.visitChildren(this);
}
}
public static class SampleByPercentileContext extends SampleMethodContext {
public Token negativeSign;
public Token percentage;
public TerminalNode PERCENTLIT() { return getToken(HoodieSqlBaseParser.PERCENTLIT, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(HoodieSqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode DECIMAL_VALUE() { return getToken(HoodieSqlBaseParser.DECIMAL_VALUE, 0); }
public TerminalNode MINUS() { return getToken(HoodieSqlBaseParser.MINUS, 0); }
public SampleByPercentileContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSampleByPercentile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSampleByPercentile(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSampleByPercentile(this);
else return visitor.visitChildren(this);
}
}
public static class SampleByBucketContext extends SampleMethodContext {
public Token sampleType;
public Token numerator;
public Token denominator;
public TerminalNode OUT() { return getToken(HoodieSqlBaseParser.OUT, 0); }
public TerminalNode OF() { return getToken(HoodieSqlBaseParser.OF, 0); }
public TerminalNode BUCKET() { return getToken(HoodieSqlBaseParser.BUCKET, 0); }
public List INTEGER_VALUE() { return getTokens(HoodieSqlBaseParser.INTEGER_VALUE); }
public TerminalNode INTEGER_VALUE(int i) {
return getToken(HoodieSqlBaseParser.INTEGER_VALUE, i);
}
public TerminalNode ON() { return getToken(HoodieSqlBaseParser.ON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public SampleByBucketContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSampleByBucket(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSampleByBucket(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSampleByBucket(this);
else return visitor.visitChildren(this);
}
}
public static class SampleByBytesContext extends SampleMethodContext {
public ExpressionContext bytes;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SampleByBytesContext(SampleMethodContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterSampleByBytes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitSampleByBytes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitSampleByBytes(this);
else return visitor.visitChildren(this);
}
}
public final SampleMethodContext sampleMethod() throws RecognitionException {
SampleMethodContext _localctx = new SampleMethodContext(_ctx, getState());
enterRule(_localctx, 156, RULE_sampleMethod);
int _la;
try {
setState(1554);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
_localctx = new SampleByPercentileContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1531);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(1530);
((SampleByPercentileContext)_localctx).negativeSign = match(MINUS);
}
}
setState(1533);
((SampleByPercentileContext)_localctx).percentage = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INTEGER_VALUE || _la==DECIMAL_VALUE) ) {
((SampleByPercentileContext)_localctx).percentage = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1534);
match(PERCENTLIT);
}
break;
case 2:
_localctx = new SampleByRowsContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1535);
expression();
setState(1536);
match(ROWS);
}
break;
case 3:
_localctx = new SampleByBucketContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1538);
((SampleByBucketContext)_localctx).sampleType = match(BUCKET);
setState(1539);
((SampleByBucketContext)_localctx).numerator = match(INTEGER_VALUE);
setState(1540);
match(OUT);
setState(1541);
match(OF);
setState(1542);
((SampleByBucketContext)_localctx).denominator = match(INTEGER_VALUE);
setState(1551);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1543);
match(ON);
setState(1549);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
case 1:
{
setState(1544);
identifier();
}
break;
case 2:
{
setState(1545);
qualifiedName();
setState(1546);
match(LEFT_PAREN);
setState(1547);
match(RIGHT_PAREN);
}
break;
}
}
}
}
break;
case 4:
_localctx = new SampleByBytesContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1553);
((SampleByBytesContext)_localctx).bytes = expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public IdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitIdentifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitIdentifierList(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierListContext identifierList() throws RecognitionException {
IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState());
enterRule(_localctx, 158, RULE_identifierList);
try {
enterOuterAlt(_localctx, 1);
{
setState(1556);
match(LEFT_PAREN);
setState(1557);
identifierSeq();
setState(1558);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierSeqContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext errorCapturingIdentifier;
public List ident = new ArrayList();
public List errorCapturingIdentifier() {
return getRuleContexts(ErrorCapturingIdentifierContext.class);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier(int i) {
return getRuleContext(ErrorCapturingIdentifierContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public IdentifierSeqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierSeq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterIdentifierSeq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitIdentifierSeq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitIdentifierSeq(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierSeqContext identifierSeq() throws RecognitionException {
IdentifierSeqContext _localctx = new IdentifierSeqContext(_ctx, getState());
enterRule(_localctx, 160, RULE_identifierSeq);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1560);
((IdentifierSeqContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((IdentifierSeqContext)_localctx).ident.add(((IdentifierSeqContext)_localctx).errorCapturingIdentifier);
setState(1565);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,186,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1561);
match(COMMA);
setState(1562);
((IdentifierSeqContext)_localctx).errorCapturingIdentifier = errorCapturingIdentifier();
((IdentifierSeqContext)_localctx).ident.add(((IdentifierSeqContext)_localctx).errorCapturingIdentifier);
}
}
}
setState(1567);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,186,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderedIdentifierListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List orderedIdentifier() {
return getRuleContexts(OrderedIdentifierContext.class);
}
public OrderedIdentifierContext orderedIdentifier(int i) {
return getRuleContext(OrderedIdentifierContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public OrderedIdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderedIdentifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterOrderedIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitOrderedIdentifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitOrderedIdentifierList(this);
else return visitor.visitChildren(this);
}
}
public final OrderedIdentifierListContext orderedIdentifierList() throws RecognitionException {
OrderedIdentifierListContext _localctx = new OrderedIdentifierListContext(_ctx, getState());
enterRule(_localctx, 162, RULE_orderedIdentifierList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1568);
match(LEFT_PAREN);
setState(1569);
orderedIdentifier();
setState(1574);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1570);
match(COMMA);
setState(1571);
orderedIdentifier();
}
}
setState(1576);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1577);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderedIdentifierContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext ident;
public Token ordering;
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public TerminalNode ASC() { return getToken(HoodieSqlBaseParser.ASC, 0); }
public TerminalNode DESC() { return getToken(HoodieSqlBaseParser.DESC, 0); }
public OrderedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterOrderedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitOrderedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitOrderedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final OrderedIdentifierContext orderedIdentifier() throws RecognitionException {
OrderedIdentifierContext _localctx = new OrderedIdentifierContext(_ctx, getState());
enterRule(_localctx, 164, RULE_orderedIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1579);
((OrderedIdentifierContext)_localctx).ident = errorCapturingIdentifier();
setState(1581);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(1580);
((OrderedIdentifierContext)_localctx).ordering = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
((OrderedIdentifierContext)_localctx).ordering = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierCommentListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public List identifierComment() {
return getRuleContexts(IdentifierCommentContext.class);
}
public IdentifierCommentContext identifierComment(int i) {
return getRuleContext(IdentifierCommentContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public IdentifierCommentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierCommentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterIdentifierCommentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitIdentifierCommentList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitIdentifierCommentList(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierCommentListContext identifierCommentList() throws RecognitionException {
IdentifierCommentListContext _localctx = new IdentifierCommentListContext(_ctx, getState());
enterRule(_localctx, 166, RULE_identifierCommentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1583);
match(LEFT_PAREN);
setState(1584);
identifierComment();
setState(1589);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1585);
match(COMMA);
setState(1586);
identifierComment();
}
}
setState(1591);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1592);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierCommentContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public CommentSpecContext commentSpec() {
return getRuleContext(CommentSpecContext.class,0);
}
public IdentifierCommentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierComment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterIdentifierComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitIdentifierComment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitIdentifierComment(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierCommentContext identifierComment() throws RecognitionException {
IdentifierCommentContext _localctx = new IdentifierCommentContext(_ctx, getState());
enterRule(_localctx, 168, RULE_identifierComment);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1594);
identifier();
setState(1596);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(1595);
commentSpec();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationPrimaryContext extends ParserRuleContext {
public RelationPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationPrimary; }
public RelationPrimaryContext() { }
public void copyFrom(RelationPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
public static class TableValuedFunctionContext extends RelationPrimaryContext {
public FunctionTableContext functionTable() {
return getRuleContext(FunctionTableContext.class,0);
}
public TableValuedFunctionContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableValuedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableValuedFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableValuedFunction(this);
else return visitor.visitChildren(this);
}
}
public static class InlineTableDefault2Context extends RelationPrimaryContext {
public InlineTableContext inlineTable() {
return getRuleContext(InlineTableContext.class,0);
}
public InlineTableDefault2Context(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInlineTableDefault2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInlineTableDefault2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInlineTableDefault2(this);
else return visitor.visitChildren(this);
}
}
public static class AliasedRelationContext extends RelationPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public RelationContext relation() {
return getRuleContext(RelationContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public SampleContext sample() {
return getRuleContext(SampleContext.class,0);
}
public AliasedRelationContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterAliasedRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitAliasedRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitAliasedRelation(this);
else return visitor.visitChildren(this);
}
}
public static class AliasedQueryContext extends RelationPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public SampleContext sample() {
return getRuleContext(SampleContext.class,0);
}
public AliasedQueryContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterAliasedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitAliasedQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitAliasedQuery(this);
else return visitor.visitChildren(this);
}
}
public static class TableNameContext extends RelationPrimaryContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public TemporalClauseContext temporalClause() {
return getRuleContext(TemporalClauseContext.class,0);
}
public SampleContext sample() {
return getRuleContext(SampleContext.class,0);
}
public TableNameContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableName(this);
else return visitor.visitChildren(this);
}
}
public final RelationPrimaryContext relationPrimary() throws RecognitionException {
RelationPrimaryContext _localctx = new RelationPrimaryContext(_ctx, getState());
enterRule(_localctx, 170, RULE_relationPrimary);
try {
setState(1625);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
_localctx = new TableNameContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1598);
multipartIdentifier();
setState(1600);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(1599);
temporalClause();
}
break;
}
setState(1603);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1602);
sample();
}
break;
}
setState(1605);
tableAlias();
}
break;
case 2:
_localctx = new AliasedQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1607);
match(LEFT_PAREN);
setState(1608);
query();
setState(1609);
match(RIGHT_PAREN);
setState(1611);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1610);
sample();
}
break;
}
setState(1613);
tableAlias();
}
break;
case 3:
_localctx = new AliasedRelationContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1615);
match(LEFT_PAREN);
setState(1616);
relation();
setState(1617);
match(RIGHT_PAREN);
setState(1619);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
{
setState(1618);
sample();
}
break;
}
setState(1621);
tableAlias();
}
break;
case 4:
_localctx = new InlineTableDefault2Context(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1623);
inlineTable();
}
break;
case 5:
_localctx = new TableValuedFunctionContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1624);
functionTable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InlineTableContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(HoodieSqlBaseParser.VALUES, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public InlineTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inlineTable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterInlineTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitInlineTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitInlineTable(this);
else return visitor.visitChildren(this);
}
}
public final InlineTableContext inlineTable() throws RecognitionException {
InlineTableContext _localctx = new InlineTableContext(_ctx, getState());
enterRule(_localctx, 172, RULE_inlineTable);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1627);
match(VALUES);
setState(1628);
expression();
setState(1633);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1629);
match(COMMA);
setState(1630);
expression();
}
}
}
setState(1635);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_ctx);
}
setState(1636);
tableAlias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionTableContext extends ParserRuleContext {
public FunctionNameContext funcName;
public TerminalNode LEFT_PAREN() { return getToken(HoodieSqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(HoodieSqlBaseParser.RIGHT_PAREN, 0); }
public TableAliasContext tableAlias() {
return getRuleContext(TableAliasContext.class,0);
}
public FunctionNameContext functionName() {
return getRuleContext(FunctionNameContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public FunctionTableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionTable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterFunctionTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitFunctionTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitFunctionTable(this);
else return visitor.visitChildren(this);
}
}
public final FunctionTableContext functionTable() throws RecognitionException {
FunctionTableContext _localctx = new FunctionTableContext(_ctx, getState());
enterRule(_localctx, 174, RULE_functionTable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1638);
((FunctionTableContext)_localctx).funcName = functionName();
setState(1639);
match(LEFT_PAREN);
setState(1648);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
case 1:
{
setState(1640);
expression();
setState(1645);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1641);
match(COMMA);
setState(1642);
expression();
}
}
setState(1647);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1650);
match(RIGHT_PAREN);
setState(1651);
tableAlias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TableAliasContext extends ParserRuleContext {
public StrictIdentifierContext strictIdentifier() {
return getRuleContext(StrictIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TableAliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableAlias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterTableAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitTableAlias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitTableAlias(this);
else return visitor.visitChildren(this);
}
}
public final TableAliasContext tableAlias() throws RecognitionException {
TableAliasContext _localctx = new TableAliasContext(_ctx, getState());
enterRule(_localctx, 176, RULE_tableAlias);
try {
enterOuterAlt(_localctx, 1);
{
setState(1660);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
{
setState(1654);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
case 1:
{
setState(1653);
match(AS);
}
break;
}
setState(1656);
strictIdentifier();
setState(1658);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
setState(1657);
identifierList();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RowFormatContext extends ParserRuleContext {
public RowFormatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowFormat; }
public RowFormatContext() { }
public void copyFrom(RowFormatContext ctx) {
super.copyFrom(ctx);
}
}
public static class RowFormatSerdeContext extends RowFormatContext {
public Token name;
public TablePropertyListContext props;
public TerminalNode ROW() { return getToken(HoodieSqlBaseParser.ROW, 0); }
public TerminalNode FORMAT() { return getToken(HoodieSqlBaseParser.FORMAT, 0); }
public TerminalNode SERDE() { return getToken(HoodieSqlBaseParser.SERDE, 0); }
public TerminalNode STRING() { return getToken(HoodieSqlBaseParser.STRING, 0); }
public TerminalNode WITH() { return getToken(HoodieSqlBaseParser.WITH, 0); }
public TerminalNode SERDEPROPERTIES() { return getToken(HoodieSqlBaseParser.SERDEPROPERTIES, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public RowFormatSerdeContext(RowFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterRowFormatSerde(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitRowFormatSerde(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitRowFormatSerde(this);
else return visitor.visitChildren(this);
}
}
public static class RowFormatDelimitedContext extends RowFormatContext {
public Token fieldsTerminatedBy;
public Token escapedBy;
public Token collectionItemsTerminatedBy;
public Token keysTerminatedBy;
public Token linesSeparatedBy;
public Token nullDefinedAs;
public TerminalNode ROW() { return getToken(HoodieSqlBaseParser.ROW, 0); }
public TerminalNode FORMAT() { return getToken(HoodieSqlBaseParser.FORMAT, 0); }
public TerminalNode DELIMITED() { return getToken(HoodieSqlBaseParser.DELIMITED, 0); }
public TerminalNode FIELDS() { return getToken(HoodieSqlBaseParser.FIELDS, 0); }
public List TERMINATED() { return getTokens(HoodieSqlBaseParser.TERMINATED); }
public TerminalNode TERMINATED(int i) {
return getToken(HoodieSqlBaseParser.TERMINATED, i);
}
public List BY() { return getTokens(HoodieSqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(HoodieSqlBaseParser.BY, i);
}
public TerminalNode COLLECTION() { return getToken(HoodieSqlBaseParser.COLLECTION, 0); }
public TerminalNode ITEMS() { return getToken(HoodieSqlBaseParser.ITEMS, 0); }
public TerminalNode MAP() { return getToken(HoodieSqlBaseParser.MAP, 0); }
public TerminalNode KEYS() { return getToken(HoodieSqlBaseParser.KEYS, 0); }
public TerminalNode LINES() { return getToken(HoodieSqlBaseParser.LINES, 0); }
public TerminalNode NULL() { return getToken(HoodieSqlBaseParser.NULL, 0); }
public TerminalNode DEFINED() { return getToken(HoodieSqlBaseParser.DEFINED, 0); }
public TerminalNode AS() { return getToken(HoodieSqlBaseParser.AS, 0); }
public List STRING() { return getTokens(HoodieSqlBaseParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(HoodieSqlBaseParser.STRING, i);
}
public TerminalNode ESCAPED() { return getToken(HoodieSqlBaseParser.ESCAPED, 0); }
public RowFormatDelimitedContext(RowFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterRowFormatDelimited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitRowFormatDelimited(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitRowFormatDelimited(this);
else return visitor.visitChildren(this);
}
}
public final RowFormatContext rowFormat() throws RecognitionException {
RowFormatContext _localctx = new RowFormatContext(_ctx, getState());
enterRule(_localctx, 178, RULE_rowFormat);
try {
setState(1711);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
case 1:
_localctx = new RowFormatSerdeContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1662);
match(ROW);
setState(1663);
match(FORMAT);
setState(1664);
match(SERDE);
setState(1665);
((RowFormatSerdeContext)_localctx).name = match(STRING);
setState(1669);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
setState(1666);
match(WITH);
setState(1667);
match(SERDEPROPERTIES);
setState(1668);
((RowFormatSerdeContext)_localctx).props = tablePropertyList();
}
break;
}
}
break;
case 2:
_localctx = new RowFormatDelimitedContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1671);
match(ROW);
setState(1672);
match(FORMAT);
setState(1673);
match(DELIMITED);
setState(1683);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
case 1:
{
setState(1674);
match(FIELDS);
setState(1675);
match(TERMINATED);
setState(1676);
match(BY);
setState(1677);
((RowFormatDelimitedContext)_localctx).fieldsTerminatedBy = match(STRING);
setState(1681);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
{
setState(1678);
match(ESCAPED);
setState(1679);
match(BY);
setState(1680);
((RowFormatDelimitedContext)_localctx).escapedBy = match(STRING);
}
break;
}
}
break;
}
setState(1690);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
case 1:
{
setState(1685);
match(COLLECTION);
setState(1686);
match(ITEMS);
setState(1687);
match(TERMINATED);
setState(1688);
match(BY);
setState(1689);
((RowFormatDelimitedContext)_localctx).collectionItemsTerminatedBy = match(STRING);
}
break;
}
setState(1697);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
{
setState(1692);
match(MAP);
setState(1693);
match(KEYS);
setState(1694);
match(TERMINATED);
setState(1695);
match(BY);
setState(1696);
((RowFormatDelimitedContext)_localctx).keysTerminatedBy = match(STRING);
}
break;
}
setState(1703);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
{
setState(1699);
match(LINES);
setState(1700);
match(TERMINATED);
setState(1701);
match(BY);
setState(1702);
((RowFormatDelimitedContext)_localctx).linesSeparatedBy = match(STRING);
}
break;
}
setState(1709);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
{
setState(1705);
match(NULL);
setState(1706);
match(DEFINED);
setState(1707);
match(AS);
setState(1708);
((RowFormatDelimitedContext)_localctx).nullDefinedAs = match(STRING);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultipartIdentifierListContext extends ParserRuleContext {
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public List COMMA() { return getTokens(HoodieSqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(HoodieSqlBaseParser.COMMA, i);
}
public MultipartIdentifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMultipartIdentifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMultipartIdentifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof HoodieSqlBaseVisitor ) return ((HoodieSqlBaseVisitor)visitor).visitMultipartIdentifierList(this);
else return visitor.visitChildren(this);
}
}
public final MultipartIdentifierListContext multipartIdentifierList() throws RecognitionException {
MultipartIdentifierListContext _localctx = new MultipartIdentifierListContext(_ctx, getState());
enterRule(_localctx, 180, RULE_multipartIdentifierList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1713);
multipartIdentifier();
setState(1718);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1714);
match(COMMA);
setState(1715);
multipartIdentifier();
}
}
setState(1720);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultipartIdentifierContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext errorCapturingIdentifier;
public List parts = new ArrayList();
public List errorCapturingIdentifier() {
return getRuleContexts(ErrorCapturingIdentifierContext.class);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier(int i) {
return getRuleContext(ErrorCapturingIdentifierContext.class,i);
}
public List DOT() { return getTokens(HoodieSqlBaseParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(HoodieSqlBaseParser.DOT, i);
}
public MultipartIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).enterMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof HoodieSqlBaseListener ) ((HoodieSqlBaseListener)listener).exitMultipartIdentifier(this);
}
@Override
public 