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.spark.sql.catalyst.parser.SqlBaseParser Maven / Gradle / Ivy
// Generated from org/apache/spark/sql/catalyst/parser/SqlBase.g4 by ANTLR 4.7.1
package org.apache.spark.sql.catalyst.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 SqlBaseParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", 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, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, ADD=12, AFTER=13, ALL=14, ALTER=15, ANALYZE=16, AND=17,
ANTI=18, ANY=19, ARCHIVE=20, ARRAY=21, AS=22, ASC=23, AT=24, AUTHORIZATION=25,
BETWEEN=26, BOTH=27, BUCKET=28, BUCKETS=29, BY=30, CACHE=31, CASCADE=32,
CASE=33, CAST=34, CHANGE=35, CHECK=36, CLEAR=37, CLUSTER=38, CLUSTERED=39,
CODEGEN=40, COLLATE=41, COLLECTION=42, COLUMN=43, COLUMNS=44, COMMENT=45,
COMMIT=46, COMPACT=47, COMPACTIONS=48, COMPUTE=49, CONCATENATE=50, CONSTRAINT=51,
COST=52, CREATE=53, CROSS=54, CUBE=55, CURRENT=56, CURRENT_DATE=57, CURRENT_TIME=58,
CURRENT_TIMESTAMP=59, CURRENT_USER=60, DATA=61, DATABASE=62, DATABASES=63,
DAY=64, DBPROPERTIES=65, DEFINED=66, DELETE=67, DELIMITED=68, DESC=69,
DESCRIBE=70, DFS=71, DIRECTORIES=72, DIRECTORY=73, DISTINCT=74, DISTRIBUTE=75,
DROP=76, ELSE=77, END=78, ESCAPE=79, ESCAPED=80, EXCEPT=81, EXCHANGE=82,
EXISTS=83, EXPLAIN=84, EXPORT=85, EXTENDED=86, EXTERNAL=87, EXTRACT=88,
FALSE=89, FETCH=90, FIELDS=91, FILTER=92, FILEFORMAT=93, FIRST=94, FOLLOWING=95,
FOR=96, FOREIGN=97, FORMAT=98, FORMATTED=99, FROM=100, FULL=101, FUNCTION=102,
FUNCTIONS=103, GLOBAL=104, GRANT=105, GROUP=106, GROUPING=107, HAVING=108,
HOUR=109, IF=110, IGNORE=111, IMPORT=112, IN=113, INDEX=114, INDEXES=115,
INNER=116, INPATH=117, INPUTFORMAT=118, INSERT=119, INTERSECT=120, INTERVAL=121,
INTO=122, IS=123, ITEMS=124, JOIN=125, KEYS=126, LAST=127, LATERAL=128,
LAZY=129, LEADING=130, LEFT=131, LIKE=132, LIMIT=133, LINES=134, LIST=135,
LOAD=136, LOCAL=137, LOCATION=138, LOCK=139, LOCKS=140, LOGICAL=141, MACRO=142,
MAP=143, MATCHED=144, MERGE=145, MINUTE=146, MONTH=147, MSCK=148, NAMESPACE=149,
NAMESPACES=150, NATURAL=151, NO=152, NOT=153, NULL=154, NULLS=155, OF=156,
ON=157, ONLY=158, OPTION=159, OPTIONS=160, OR=161, ORDER=162, OUT=163,
OUTER=164, OUTPUTFORMAT=165, OVER=166, OVERLAPS=167, OVERLAY=168, OVERWRITE=169,
PARTITION=170, PARTITIONED=171, PARTITIONS=172, PERCENTLIT=173, PIVOT=174,
PLACING=175, POSITION=176, PRECEDING=177, PRIMARY=178, PRINCIPALS=179,
PROPERTIES=180, PURGE=181, QUERY=182, RANGE=183, RECORDREADER=184, RECORDWRITER=185,
RECOVER=186, REDUCE=187, REFERENCES=188, REFRESH=189, RENAME=190, REPAIR=191,
REPLACE=192, RESET=193, RESTRICT=194, REVOKE=195, RIGHT=196, RLIKE=197,
ROLE=198, ROLES=199, ROLLBACK=200, ROLLUP=201, ROW=202, ROWS=203, SCHEMA=204,
SECOND=205, SELECT=206, SEMI=207, SEPARATED=208, SERDE=209, SERDEPROPERTIES=210,
SESSION_USER=211, SET=212, SETMINUS=213, SETS=214, SHOW=215, SKEWED=216,
SOME=217, SORT=218, SORTED=219, START=220, STATISTICS=221, STORED=222,
STRATIFY=223, STRUCT=224, SUBSTR=225, SUBSTRING=226, TABLE=227, TABLES=228,
TABLESAMPLE=229, TBLPROPERTIES=230, TEMPORARY=231, TERMINATED=232, THEN=233,
TO=234, TOUCH=235, TRAILING=236, TRANSACTION=237, TRANSACTIONS=238, TRANSFORM=239,
TRIM=240, TRUE=241, TRUNCATE=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, EQ=264, NSEQ=265,
NEQ=266, NEQJ=267, LT=268, LTE=269, GT=270, GTE=271, PLUS=272, MINUS=273,
ASTERISK=274, SLASH=275, PERCENT=276, DIV=277, TILDE=278, AMPERSAND=279,
PIPE=280, CONCAT_PIPE=281, HAT=282, STRING=283, BIGINT_LITERAL=284, SMALLINT_LITERAL=285,
TINYINT_LITERAL=286, INTEGER_VALUE=287, EXPONENT_VALUE=288, DECIMAL_VALUE=289,
DOUBLE_LITERAL=290, BIGDECIMAL_LITERAL=291, IDENTIFIER=292, BACKQUOTED_IDENTIFIER=293,
SIMPLE_COMMENT=294, BRACKETED_COMMENT=295, WS=296, UNRECOGNIZED=297;
public static final int
RULE_singleStatement = 0, RULE_singleExpression = 1, RULE_singleTableIdentifier = 2,
RULE_singleMultipartIdentifier = 3, RULE_singleFunctionIdentifier = 4,
RULE_singleDataType = 5, RULE_singleTableSchema = 6, RULE_statement = 7,
RULE_unsupportedHiveNativeCommands = 8, RULE_createTableHeader = 9, RULE_replaceTableHeader = 10,
RULE_bucketSpec = 11, RULE_skewSpec = 12, RULE_locationSpec = 13, RULE_commentSpec = 14,
RULE_query = 15, RULE_insertInto = 16, RULE_partitionSpecLocation = 17,
RULE_partitionSpec = 18, RULE_partitionVal = 19, RULE_namespace = 20,
RULE_describeFuncName = 21, RULE_describeColName = 22, RULE_ctes = 23,
RULE_namedQuery = 24, RULE_tableProvider = 25, RULE_createTableClauses = 26,
RULE_tablePropertyList = 27, RULE_tableProperty = 28, RULE_tablePropertyKey = 29,
RULE_tablePropertyValue = 30, RULE_constantList = 31, RULE_nestedConstantList = 32,
RULE_createFileFormat = 33, RULE_fileFormat = 34, RULE_storageHandler = 35,
RULE_resource = 36, RULE_dmlStatementNoWith = 37, RULE_queryOrganization = 38,
RULE_multiInsertQueryBody = 39, RULE_queryTerm = 40, RULE_queryPrimary = 41,
RULE_sortItem = 42, RULE_fromStatement = 43, RULE_fromStatementBody = 44,
RULE_querySpecification = 45, RULE_transformClause = 46, RULE_selectClause = 47,
RULE_setClause = 48, RULE_matchedClause = 49, RULE_notMatchedClause = 50,
RULE_matchedAction = 51, RULE_notMatchedAction = 52, RULE_assignmentList = 53,
RULE_assignment = 54, RULE_whereClause = 55, RULE_havingClause = 56, RULE_hint = 57,
RULE_hintStatement = 58, RULE_fromClause = 59, RULE_aggregationClause = 60,
RULE_groupingSet = 61, RULE_pivotClause = 62, RULE_pivotColumn = 63, RULE_pivotValue = 64,
RULE_lateralView = 65, RULE_setQuantifier = 66, RULE_relation = 67, RULE_joinRelation = 68,
RULE_joinType = 69, RULE_joinCriteria = 70, RULE_sample = 71, RULE_sampleMethod = 72,
RULE_identifierList = 73, RULE_identifierSeq = 74, RULE_orderedIdentifierList = 75,
RULE_orderedIdentifier = 76, RULE_identifierCommentList = 77, RULE_identifierComment = 78,
RULE_relationPrimary = 79, RULE_inlineTable = 80, RULE_functionTable = 81,
RULE_tableAlias = 82, RULE_rowFormat = 83, RULE_multipartIdentifierList = 84,
RULE_multipartIdentifier = 85, RULE_tableIdentifier = 86, RULE_functionIdentifier = 87,
RULE_namedExpression = 88, RULE_namedExpressionSeq = 89, RULE_transformList = 90,
RULE_transform = 91, RULE_transformArgument = 92, RULE_expression = 93,
RULE_booleanExpression = 94, RULE_predicate = 95, RULE_valueExpression = 96,
RULE_primaryExpression = 97, RULE_constant = 98, RULE_comparisonOperator = 99,
RULE_arithmeticOperator = 100, RULE_predicateOperator = 101, RULE_booleanValue = 102,
RULE_interval = 103, RULE_errorCapturingMultiUnitsInterval = 104, RULE_multiUnitsInterval = 105,
RULE_errorCapturingUnitToUnitInterval = 106, RULE_unitToUnitInterval = 107,
RULE_intervalValue = 108, RULE_intervalUnit = 109, RULE_colPosition = 110,
RULE_dataType = 111, RULE_qualifiedColTypeWithPositionList = 112, RULE_qualifiedColTypeWithPosition = 113,
RULE_colTypeList = 114, RULE_colType = 115, RULE_complexColTypeList = 116,
RULE_complexColType = 117, RULE_whenClause = 118, RULE_windowClause = 119,
RULE_namedWindow = 120, RULE_windowSpec = 121, RULE_windowFrame = 122,
RULE_frameBound = 123, RULE_qualifiedNameList = 124, RULE_functionName = 125,
RULE_qualifiedName = 126, RULE_errorCapturingIdentifier = 127, RULE_errorCapturingIdentifierExtra = 128,
RULE_identifier = 129, RULE_strictIdentifier = 130, RULE_quotedIdentifier = 131,
RULE_number = 132, RULE_alterColumnAction = 133, RULE_ansiNonReserved = 134,
RULE_strictNonReserved = 135, RULE_nonReserved = 136;
public static final String[] ruleNames = {
"singleStatement", "singleExpression", "singleTableIdentifier", "singleMultipartIdentifier",
"singleFunctionIdentifier", "singleDataType", "singleTableSchema", "statement",
"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", "aggregationClause", "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", "namedExpression",
"namedExpressionSeq", "transformList", "transform", "transformArgument",
"expression", "booleanExpression", "predicate", "valueExpression", "primaryExpression",
"constant", "comparisonOperator", "arithmeticOperator", "predicateOperator",
"booleanValue", "interval", "errorCapturingMultiUnitsInterval", "multiUnitsInterval",
"errorCapturingUnitToUnitInterval", "unitToUnitInterval", "intervalValue",
"intervalUnit", "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"
};
private static final String[] _LITERAL_NAMES = {
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'",
"'DATA'", "'DATABASE'", null, "'DAY'", "'DBPROPERTIES'", "'DEFINED'",
"'DELETE'", "'DELIMITED'", "'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'",
"'DIRECTORY'", "'DISTINCT'", "'DISTRIBUTE'", "'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'", "'RESTRICT'", "'REVOKE'", "'RIGHT'", null, "'ROLE'",
"'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'SCHEMA'", "'SECOND'",
"'SELECT'", "'SEMI'", "'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'",
"'SET'", "'MINUS'", "'SETS'", "'SHOW'", "'SKEWED'", "'SOME'", "'SORT'",
"'SORTED'", "'START'", "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRUCT'",
"'SUBSTR'", "'SUBSTRING'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TBLPROPERTIES'",
null, "'TERMINATED'", "'THEN'", "'TO'", "'TOUCH'", "'TRAILING'", "'TRANSACTION'",
"'TRANSACTIONS'", "'TRANSFORM'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TYPE'",
"'UNARCHIVE'", "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'",
"'UNLOCK'", "'UNSET'", "'UPDATE'", "'USE'", "'USER'", "'USING'", "'VALUES'",
"'VIEW'", "'VIEWS'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'YEAR'",
null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'", null, "'+'", "'-'",
"'*'", "'/'", "'%'", "'DIV'", "'~'", "'&'", "'|'", "'||'", "'^'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, 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", "DATA", "DATABASE",
"DATABASES", "DAY", "DBPROPERTIES", "DEFINED", "DELETE", "DELIMITED",
"DESC", "DESCRIBE", "DFS", "DIRECTORIES", "DIRECTORY", "DISTINCT", "DISTRIBUTE",
"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", "RESTRICT", "REVOKE", "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK",
"ROLLUP", "ROW", "ROWS", "SCHEMA", "SECOND", "SELECT", "SEMI", "SEPARATED",
"SERDE", "SERDEPROPERTIES", "SESSION_USER", "SET", "SETMINUS", "SETS",
"SHOW", "SKEWED", "SOME", "SORT", "SORTED", "START", "STATISTICS", "STORED",
"STRATIFY", "STRUCT", "SUBSTR", "SUBSTRING", "TABLE", "TABLES", "TABLESAMPLE",
"TBLPROPERTIES", "TEMPORARY", "TERMINATED", "THEN", "TO", "TOUCH", "TRAILING",
"TRANSACTION", "TRANSACTIONS", "TRANSFORM", "TRIM", "TRUE", "TRUNCATE",
"TYPE", "UNARCHIVE", "UNBOUNDED", "UNCACHE", "UNION", "UNIQUE", "UNKNOWN",
"UNLOCK", "UNSET", "UPDATE", "USE", "USER", "USING", "VALUES", "VIEW",
"VIEWS", "WHEN", "WHERE", "WINDOW", "WITH", "YEAR", "EQ", "NSEQ", "NEQ",
"NEQJ", "LT", "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH",
"PERCENT", "DIV", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT",
"STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE",
"EXPONENT_VALUE", "DECIMAL_VALUE", "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL",
"IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT",
"WS", "UNRECOGNIZED"
};
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 "SqlBase.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_enbled = 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 false, CREATE TABLE syntax without a provider will use
* the value of spark.sql.sources.default as its provider.
*/
public boolean legacy_create_hive_table_by_default_enabled = false;
/**
* Verify whether current token is a valid decimal token (which contains dot).
* Returns true if the character that follows the token is not a digit or letter or underscore.
*
* For example:
* For char stream "2.3", "2." is not a valid decimal token, because it is followed by digit '3'.
* For char stream "2.3_", "2.3" is not a valid decimal token, because it is followed by '_'.
* For char stream "2.3W", "2.3" is not a valid decimal token, because it is followed by 'W'.
* For char stream "12.0D 34.E2+0.12 " 12.0D is a valid decimal token because it is followed
* by a space. 34.E2 is a valid decimal token because it is followed by symbol '+'
* which is not a digit or letter or underscore.
*/
public boolean isValidDecimal() {
int nextChar = _input.LA(1);
if (nextChar >= 'A' && nextChar <= 'Z' || nextChar >= '0' && nextChar <= '9' ||
nextChar == '_') {
return false;
} else {
return true;
}
}
/**
* When true, the behavior of keywords follows ANSI SQL standard.
*/
public boolean SQL_standard_keyword_behavior = false;
/**
* This method will be called when we see '/*' and try to match it as a bracketed comment.
* If the next character is '+', it should be parsed as hint later, and we cannot match
* it as a bracketed comment.
*
* Returns true if the next character is '+'.
*/
public boolean isHint() {
int nextChar = _input.LA(1);
if (nextChar == '+') {
return true;
} else {
return false;
}
}
public SqlBaseParser(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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(274);
statement();
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(275);
match(T__0);
}
}
setState(280);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(281);
match(EOF);
}
}
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleExpression(this);
else return visitor.visitChildren(this);
}
}
public final SingleExpressionContext singleExpression() throws RecognitionException {
SingleExpressionContext _localctx = new SingleExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_singleExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(283);
namedExpression();
setState(284);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleTableIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleTableIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleTableIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleTableIdentifierContext singleTableIdentifier() throws RecognitionException {
SingleTableIdentifierContext _localctx = new SingleTableIdentifierContext(_ctx, getState());
enterRule(_localctx, 4, RULE_singleTableIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(286);
tableIdentifier();
setState(287);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleMultipartIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleMultipartIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleMultipartIdentifierContext singleMultipartIdentifier() throws RecognitionException {
SingleMultipartIdentifierContext _localctx = new SingleMultipartIdentifierContext(_ctx, getState());
enterRule(_localctx, 6, RULE_singleMultipartIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(289);
multipartIdentifier();
setState(290);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleFunctionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleFunctionIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final SingleFunctionIdentifierContext singleFunctionIdentifier() throws RecognitionException {
SingleFunctionIdentifierContext _localctx = new SingleFunctionIdentifierContext(_ctx, getState());
enterRule(_localctx, 8, RULE_singleFunctionIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(292);
functionIdentifier();
setState(293);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleDataType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleDataType(this);
else return visitor.visitChildren(this);
}
}
public final SingleDataTypeContext singleDataType() throws RecognitionException {
SingleDataTypeContext _localctx = new SingleDataTypeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_singleDataType);
try {
enterOuterAlt(_localctx, 1);
{
setState(295);
dataType();
setState(296);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleTableSchema(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleTableSchema(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleTableSchema(this);
else return visitor.visitChildren(this);
}
}
public final SingleTableSchemaContext singleTableSchema() throws RecognitionException {
SingleTableSchemaContext _localctx = new SingleTableSchemaContext(_ctx, getState());
enterRule(_localctx, 12, RULE_singleTableSchema);
try {
enterOuterAlt(_localctx, 1);
{
setState(298);
colTypeList();
setState(299);
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 ExplainContext extends StatementContext {
public TerminalNode EXPLAIN() { return getToken(SqlBaseParser.EXPLAIN, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode LOGICAL() { return getToken(SqlBaseParser.LOGICAL, 0); }
public TerminalNode FORMATTED() { return getToken(SqlBaseParser.FORMATTED, 0); }
public TerminalNode EXTENDED() { return getToken(SqlBaseParser.EXTENDED, 0); }
public TerminalNode CODEGEN() { return getToken(SqlBaseParser.CODEGEN, 0); }
public TerminalNode COST() { return getToken(SqlBaseParser.COST, 0); }
public ExplainContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterExplain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitExplain(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitExplain(this);
else return visitor.visitChildren(this);
}
}
public static class ResetConfigurationContext extends StatementContext {
public TerminalNode RESET() { return getToken(SqlBaseParser.RESET, 0); }
public ResetConfigurationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterResetConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitResetConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitResetConfiguration(this);
else return visitor.visitChildren(this);
}
}
public static class AlterViewQueryContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public AlterViewQueryContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAlterViewQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAlterViewQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAlterViewQuery(this);
else return visitor.visitChildren(this);
}
}
public static class UseContext extends StatementContext {
public TerminalNode USE() { return getToken(SqlBaseParser.USE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode NAMESPACE() { return getToken(SqlBaseParser.NAMESPACE, 0); }
public UseContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUse(this);
else return visitor.visitChildren(this);
}
}
public static class DropNamespaceContext extends StatementContext {
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public TerminalNode RESTRICT() { return getToken(SqlBaseParser.RESTRICT, 0); }
public TerminalNode CASCADE() { return getToken(SqlBaseParser.CASCADE, 0); }
public DropNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class CreateTempViewUsingContext extends StatementContext {
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public TerminalNode OR() { return getToken(SqlBaseParser.OR, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode GLOBAL() { return getToken(SqlBaseParser.GLOBAL, 0); }
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TerminalNode OPTIONS() { return getToken(SqlBaseParser.OPTIONS, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public CreateTempViewUsingContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateTempViewUsing(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateTempViewUsing(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateTempViewUsing(this);
else return visitor.visitChildren(this);
}
}
public static class RenameTableContext extends StatementContext {
public MultipartIdentifierContext from;
public MultipartIdentifierContext to;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode RENAME() { return getToken(SqlBaseParser.RENAME, 0); }
public TerminalNode TO() { return getToken(SqlBaseParser.TO, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public RenameTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRenameTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRenameTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRenameTable(this);
else return visitor.visitChildren(this);
}
}
public static class FailNativeCommandContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode ROLE() { return getToken(SqlBaseParser.ROLE, 0); }
public UnsupportedHiveNativeCommandsContext unsupportedHiveNativeCommands() {
return getRuleContext(UnsupportedHiveNativeCommandsContext.class,0);
}
public FailNativeCommandContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterFailNativeCommand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFailNativeCommand(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFailNativeCommand(this);
else return visitor.visitChildren(this);
}
}
public static class ClearCacheContext extends StatementContext {
public TerminalNode CLEAR() { return getToken(SqlBaseParser.CLEAR, 0); }
public TerminalNode CACHE() { return getToken(SqlBaseParser.CACHE, 0); }
public ClearCacheContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterClearCache(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitClearCache(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitClearCache(this);
else return visitor.visitChildren(this);
}
}
public static class DropViewContext extends StatementContext {
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public DropViewContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropView(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTablesContext extends StatementContext {
public Token pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode TABLES() { return getToken(SqlBaseParser.TABLES, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowTablesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowTables(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowTables(this);
else return visitor.visitChildren(this);
}
}
public static class RecoverPartitionsContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode RECOVER() { return getToken(SqlBaseParser.RECOVER, 0); }
public TerminalNode PARTITIONS() { return getToken(SqlBaseParser.PARTITIONS, 0); }
public RecoverPartitionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRecoverPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRecoverPartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRecoverPartitions(this);
else return visitor.visitChildren(this);
}
}
public static class ShowCurrentNamespaceContext extends StatementContext {
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode CURRENT() { return getToken(SqlBaseParser.CURRENT, 0); }
public TerminalNode NAMESPACE() { return getToken(SqlBaseParser.NAMESPACE, 0); }
public ShowCurrentNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowCurrentNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowCurrentNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowCurrentNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class RenameTablePartitionContext extends StatementContext {
public PartitionSpecContext from;
public PartitionSpecContext to;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode RENAME() { return getToken(SqlBaseParser.RENAME, 0); }
public TerminalNode TO() { return getToken(SqlBaseParser.TO, 0); }
public List partitionSpec() {
return getRuleContexts(PartitionSpecContext.class);
}
public PartitionSpecContext partitionSpec(int i) {
return getRuleContext(PartitionSpecContext.class,i);
}
public RenameTablePartitionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRenameTablePartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRenameTablePartition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRenameTablePartition(this);
else return visitor.visitChildren(this);
}
}
public static class RepairTableContext extends StatementContext {
public TerminalNode MSCK() { return getToken(SqlBaseParser.MSCK, 0); }
public TerminalNode REPAIR() { return getToken(SqlBaseParser.REPAIR, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public RepairTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRepairTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRepairTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRepairTable(this);
else return visitor.visitChildren(this);
}
}
public static class RefreshResourceContext extends StatementContext {
public TerminalNode REFRESH() { return getToken(SqlBaseParser.REFRESH, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public RefreshResourceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRefreshResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRefreshResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRefreshResource(this);
else return visitor.visitChildren(this);
}
}
public static class ShowCreateTableContext extends StatementContext {
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public TerminalNode SERDE() { return getToken(SqlBaseParser.SERDE, 0); }
public ShowCreateTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowCreateTable(this);
else return visitor.visitChildren(this);
}
}
public static class ShowNamespacesContext extends StatementContext {
public Token pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode DATABASES() { return getToken(SqlBaseParser.DATABASES, 0); }
public TerminalNode NAMESPACES() { return getToken(SqlBaseParser.NAMESPACES, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowNamespacesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowNamespaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowNamespaces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowNamespaces(this);
else return visitor.visitChildren(this);
}
}
public static class ShowColumnsContext extends StatementContext {
public MultipartIdentifierContext table;
public MultipartIdentifierContext ns;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public List FROM() { return getTokens(SqlBaseParser.FROM); }
public TerminalNode FROM(int i) {
return getToken(SqlBaseParser.FROM, i);
}
public List IN() { return getTokens(SqlBaseParser.IN); }
public TerminalNode IN(int i) {
return getToken(SqlBaseParser.IN, i);
}
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public ShowColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowColumns(this);
else return visitor.visitChildren(this);
}
}
public static class ReplaceTableContext extends StatementContext {
public ReplaceTableHeaderContext replaceTableHeader() {
return getRuleContext(ReplaceTableHeaderContext.class,0);
}
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public CreateTableClausesContext createTableClauses() {
return getRuleContext(CreateTableClausesContext.class,0);
}
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public ReplaceTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterReplaceTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitReplaceTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitReplaceTable(this);
else return visitor.visitChildren(this);
}
}
public static class AddTablePartitionContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(SqlBaseParser.ADD, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public List partitionSpecLocation() {
return getRuleContexts(PartitionSpecLocationContext.class);
}
public PartitionSpecLocationContext partitionSpecLocation(int i) {
return getRuleContext(PartitionSpecLocationContext.class,i);
}
public AddTablePartitionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAddTablePartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAddTablePartition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAddTablePartition(this);
else return visitor.visitChildren(this);
}
}
public static class SetNamespaceLocationContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public LocationSpecContext locationSpec() {
return getRuleContext(LocationSpecContext.class,0);
}
public SetNamespaceLocationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetNamespaceLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetNamespaceLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetNamespaceLocation(this);
else return visitor.visitChildren(this);
}
}
public static class RefreshTableContext extends StatementContext {
public TerminalNode REFRESH() { return getToken(SqlBaseParser.REFRESH, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public RefreshTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRefreshTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRefreshTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRefreshTable(this);
else return visitor.visitChildren(this);
}
}
public static class SetNamespacePropertiesContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public TerminalNode DBPROPERTIES() { return getToken(SqlBaseParser.DBPROPERTIES, 0); }
public TerminalNode PROPERTIES() { return getToken(SqlBaseParser.PROPERTIES, 0); }
public SetNamespacePropertiesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetNamespaceProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetNamespaceProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetNamespaceProperties(this);
else return visitor.visitChildren(this);
}
}
public static class ManageResourceContext extends StatementContext {
public Token op;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(SqlBaseParser.ADD, 0); }
public TerminalNode LIST() { return getToken(SqlBaseParser.LIST, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public ManageResourceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterManageResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitManageResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitManageResource(this);
else return visitor.visitChildren(this);
}
}
public static class AnalyzeContext extends StatementContext {
public TerminalNode ANALYZE() { return getToken(SqlBaseParser.ANALYZE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode COMPUTE() { return getToken(SqlBaseParser.COMPUTE, 0); }
public TerminalNode STATISTICS() { return getToken(SqlBaseParser.STATISTICS, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode FOR() { return getToken(SqlBaseParser.FOR, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public TerminalNode ALL() { return getToken(SqlBaseParser.ALL, 0); }
public AnalyzeContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAnalyze(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAnalyze(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAnalyze(this);
else return visitor.visitChildren(this);
}
}
public static class CreateHiveTableContext extends StatementContext {
public ColTypeListContext columns;
public ColTypeListContext partitionColumns;
public IdentifierListContext partitionColumnNames;
public TablePropertyListContext tableProps;
public CreateTableHeaderContext createTableHeader() {
return getRuleContext(CreateTableHeaderContext.class,0);
}
public List commentSpec() {
return getRuleContexts(CommentSpecContext.class);
}
public CommentSpecContext commentSpec(int i) {
return getRuleContext(CommentSpecContext.class,i);
}
public List bucketSpec() {
return getRuleContexts(BucketSpecContext.class);
}
public BucketSpecContext bucketSpec(int i) {
return getRuleContext(BucketSpecContext.class,i);
}
public List skewSpec() {
return getRuleContexts(SkewSpecContext.class);
}
public SkewSpecContext skewSpec(int i) {
return getRuleContext(SkewSpecContext.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 QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public List colTypeList() {
return getRuleContexts(ColTypeListContext.class);
}
public ColTypeListContext colTypeList(int i) {
return getRuleContext(ColTypeListContext.class,i);
}
public List PARTITIONED() { return getTokens(SqlBaseParser.PARTITIONED); }
public TerminalNode PARTITIONED(int i) {
return getToken(SqlBaseParser.PARTITIONED, i);
}
public List BY() { return getTokens(SqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(SqlBaseParser.BY, i);
}
public List TBLPROPERTIES() { return getTokens(SqlBaseParser.TBLPROPERTIES); }
public TerminalNode TBLPROPERTIES(int i) {
return getToken(SqlBaseParser.TBLPROPERTIES, i);
}
public List identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public CreateHiveTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateHiveTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateHiveTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateHiveTable(this);
else return visitor.visitChildren(this);
}
}
public static class CreateFunctionContext extends StatementContext {
public Token className;
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode FUNCTION() { return getToken(SqlBaseParser.FUNCTION, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode OR() { return getToken(SqlBaseParser.OR, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public TerminalNode USING() { return getToken(SqlBaseParser.USING, 0); }
public List resource() {
return getRuleContexts(ResourceContext.class);
}
public ResourceContext resource(int i) {
return getRuleContext(ResourceContext.class,i);
}
public CreateFunctionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateFunction(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTableContext extends StatementContext {
public MultipartIdentifierContext ns;
public Token pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode EXTENDED() { return getToken(SqlBaseParser.EXTENDED, 0); }
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ShowTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowTable(this);
else return visitor.visitChildren(this);
}
}
public static class HiveReplaceColumnsContext extends StatementContext {
public MultipartIdentifierContext table;
public QualifiedColTypeWithPositionListContext columns;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public QualifiedColTypeWithPositionListContext qualifiedColTypeWithPositionList() {
return getRuleContext(QualifiedColTypeWithPositionListContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public HiveReplaceColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterHiveReplaceColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitHiveReplaceColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitHiveReplaceColumns(this);
else return visitor.visitChildren(this);
}
}
public static class CommentNamespaceContext extends StatementContext {
public Token comment;
public TerminalNode COMMENT() { return getToken(SqlBaseParser.COMMENT, 0); }
public TerminalNode ON() { return getToken(SqlBaseParser.ON, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IS() { return getToken(SqlBaseParser.IS, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode NULL() { return getToken(SqlBaseParser.NULL, 0); }
public CommentNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCommentNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCommentNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCommentNamespace(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 ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public CreateTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateTable(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 SqlBaseListener ) ((SqlBaseListener)listener).enterDmlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDmlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDmlStatement(this);
else return visitor.visitChildren(this);
}
}
public static class CreateTableLikeContext extends StatementContext {
public TableIdentifierContext target;
public TableIdentifierContext source;
public TablePropertyListContext tableProps;
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public List tableIdentifier() {
return getRuleContexts(TableIdentifierContext.class);
}
public TableIdentifierContext tableIdentifier(int i) {
return getRuleContext(TableIdentifierContext.class,i);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public List tableProvider() {
return getRuleContexts(TableProviderContext.class);
}
public TableProviderContext tableProvider(int i) {
return getRuleContext(TableProviderContext.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 TBLPROPERTIES() { return getTokens(SqlBaseParser.TBLPROPERTIES); }
public TerminalNode TBLPROPERTIES(int i) {
return getToken(SqlBaseParser.TBLPROPERTIES, i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public CreateTableLikeContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateTableLike(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateTableLike(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateTableLike(this);
else return visitor.visitChildren(this);
}
}
public static class UncacheTableContext extends StatementContext {
public TerminalNode UNCACHE() { return getToken(SqlBaseParser.UNCACHE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public UncacheTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUncacheTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUncacheTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUncacheTable(this);
else return visitor.visitChildren(this);
}
}
public static class DropFunctionContext extends StatementContext {
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode FUNCTION() { return getToken(SqlBaseParser.FUNCTION, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public DropFunctionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropFunction(this);
else return visitor.visitChildren(this);
}
}
public static class DescribeRelationContext extends StatementContext {
public Token option;
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode DESCRIBE() { return getToken(SqlBaseParser.DESCRIBE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public DescribeColNameContext describeColName() {
return getRuleContext(DescribeColNameContext.class,0);
}
public TerminalNode EXTENDED() { return getToken(SqlBaseParser.EXTENDED, 0); }
public TerminalNode FORMATTED() { return getToken(SqlBaseParser.FORMATTED, 0); }
public DescribeRelationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeRelation(this);
else return visitor.visitChildren(this);
}
}
public static class LoadDataContext extends StatementContext {
public Token path;
public TerminalNode LOAD() { return getToken(SqlBaseParser.LOAD, 0); }
public TerminalNode DATA() { return getToken(SqlBaseParser.DATA, 0); }
public TerminalNode INPATH() { return getToken(SqlBaseParser.INPATH, 0); }
public TerminalNode INTO() { return getToken(SqlBaseParser.INTO, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode LOCAL() { return getToken(SqlBaseParser.LOCAL, 0); }
public TerminalNode OVERWRITE() { return getToken(SqlBaseParser.OVERWRITE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public LoadDataContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterLoadData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitLoadData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitLoadData(this);
else return visitor.visitChildren(this);
}
}
public static class ShowPartitionsContext extends StatementContext {
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode PARTITIONS() { return getToken(SqlBaseParser.PARTITIONS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public ShowPartitionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowPartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowPartitions(this);
else return visitor.visitChildren(this);
}
}
public static class DescribeFunctionContext extends StatementContext {
public TerminalNode FUNCTION() { return getToken(SqlBaseParser.FUNCTION, 0); }
public DescribeFuncNameContext describeFuncName() {
return getRuleContext(DescribeFuncNameContext.class,0);
}
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode DESCRIBE() { return getToken(SqlBaseParser.DESCRIBE, 0); }
public TerminalNode EXTENDED() { return getToken(SqlBaseParser.EXTENDED, 0); }
public DescribeFunctionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeFunction(this);
else return visitor.visitChildren(this);
}
}
public static class RenameTableColumnContext extends StatementContext {
public MultipartIdentifierContext table;
public MultipartIdentifierContext from;
public ErrorCapturingIdentifierContext to;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode RENAME() { return getToken(SqlBaseParser.RENAME, 0); }
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public TerminalNode TO() { return getToken(SqlBaseParser.TO, 0); }
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public RenameTableColumnContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterRenameTableColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRenameTableColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitRenameTableColumn(this);
else return visitor.visitChildren(this);
}
}
public static class StatementDefaultContext extends StatementContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public StatementDefaultContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterStatementDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitStatementDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitStatementDefault(this);
else return visitor.visitChildren(this);
}
}
public static class HiveChangeColumnContext extends StatementContext {
public MultipartIdentifierContext table;
public MultipartIdentifierContext colName;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode CHANGE() { return getToken(SqlBaseParser.CHANGE, 0); }
public ColTypeContext colType() {
return getRuleContext(ColTypeContext.class,0);
}
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public ColPositionContext colPosition() {
return getRuleContext(ColPositionContext.class,0);
}
public HiveChangeColumnContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterHiveChangeColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitHiveChangeColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitHiveChangeColumn(this);
else return visitor.visitChildren(this);
}
}
public static class DescribeQueryContext extends StatementContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode DESCRIBE() { return getToken(SqlBaseParser.DESCRIBE, 0); }
public TerminalNode QUERY() { return getToken(SqlBaseParser.QUERY, 0); }
public DescribeQueryContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeQuery(this);
else return visitor.visitChildren(this);
}
}
public static class TruncateTableContext extends StatementContext {
public TerminalNode TRUNCATE() { return getToken(SqlBaseParser.TRUNCATE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TruncateTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterTruncateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTruncateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTruncateTable(this);
else return visitor.visitChildren(this);
}
}
public static class SetTableSerDeContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode SERDE() { return getToken(SqlBaseParser.SERDE, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode WITH() { return getToken(SqlBaseParser.WITH, 0); }
public TerminalNode SERDEPROPERTIES() { return getToken(SqlBaseParser.SERDEPROPERTIES, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public SetTableSerDeContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetTableSerDe(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetTableSerDe(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetTableSerDe(this);
else return visitor.visitChildren(this);
}
}
public static class CreateViewContext extends StatementContext {
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode OR() { return getToken(SqlBaseParser.OR, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public IdentifierCommentListContext identifierCommentList() {
return getRuleContext(IdentifierCommentListContext.class,0);
}
public List commentSpec() {
return getRuleContexts(CommentSpecContext.class);
}
public CommentSpecContext commentSpec(int i) {
return getRuleContext(CommentSpecContext.class,i);
}
public List PARTITIONED() { return getTokens(SqlBaseParser.PARTITIONED); }
public TerminalNode PARTITIONED(int i) {
return getToken(SqlBaseParser.PARTITIONED, i);
}
public List ON() { return getTokens(SqlBaseParser.ON); }
public TerminalNode ON(int i) {
return getToken(SqlBaseParser.ON, i);
}
public List identifierList() {
return getRuleContexts(IdentifierListContext.class);
}
public IdentifierListContext identifierList(int i) {
return getRuleContext(IdentifierListContext.class,i);
}
public List TBLPROPERTIES() { return getTokens(SqlBaseParser.TBLPROPERTIES); }
public TerminalNode TBLPROPERTIES(int i) {
return getToken(SqlBaseParser.TBLPROPERTIES, i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public TerminalNode GLOBAL() { return getToken(SqlBaseParser.GLOBAL, 0); }
public CreateViewContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateView(this);
else return visitor.visitChildren(this);
}
}
public static class DropTablePartitionsContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public List partitionSpec() {
return getRuleContexts(PartitionSpecContext.class);
}
public PartitionSpecContext partitionSpec(int i) {
return getRuleContext(PartitionSpecContext.class,i);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public TerminalNode PURGE() { return getToken(SqlBaseParser.PURGE, 0); }
public DropTablePartitionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropTablePartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropTablePartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropTablePartitions(this);
else return visitor.visitChildren(this);
}
}
public static class SetConfigurationContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public SetConfigurationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetConfiguration(this);
else return visitor.visitChildren(this);
}
}
public static class DropTableContext extends StatementContext {
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public TerminalNode PURGE() { return getToken(SqlBaseParser.PURGE, 0); }
public DropTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropTable(this);
else return visitor.visitChildren(this);
}
}
public static class DescribeNamespaceContext extends StatementContext {
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode DESCRIBE() { return getToken(SqlBaseParser.DESCRIBE, 0); }
public TerminalNode EXTENDED() { return getToken(SqlBaseParser.EXTENDED, 0); }
public DescribeNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class AlterTableAlterColumnContext extends StatementContext {
public MultipartIdentifierContext table;
public MultipartIdentifierContext column;
public List ALTER() { return getTokens(SqlBaseParser.ALTER); }
public TerminalNode ALTER(int i) {
return getToken(SqlBaseParser.ALTER, i);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public TerminalNode CHANGE() { return getToken(SqlBaseParser.CHANGE, 0); }
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public AlterColumnActionContext alterColumnAction() {
return getRuleContext(AlterColumnActionContext.class,0);
}
public AlterTableAlterColumnContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAlterTableAlterColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAlterTableAlterColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAlterTableAlterColumn(this);
else return visitor.visitChildren(this);
}
}
public static class CommentTableContext extends StatementContext {
public Token comment;
public TerminalNode COMMENT() { return getToken(SqlBaseParser.COMMENT, 0); }
public TerminalNode ON() { return getToken(SqlBaseParser.ON, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IS() { return getToken(SqlBaseParser.IS, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode NULL() { return getToken(SqlBaseParser.NULL, 0); }
public CommentTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCommentTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCommentTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCommentTable(this);
else return visitor.visitChildren(this);
}
}
public static class CreateNamespaceContext extends StatementContext {
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public List commentSpec() {
return getRuleContexts(CommentSpecContext.class);
}
public CommentSpecContext commentSpec(int i) {
return getRuleContext(CommentSpecContext.class,i);
}
public List locationSpec() {
return getRuleContexts(LocationSpecContext.class);
}
public LocationSpecContext locationSpec(int i) {
return getRuleContext(LocationSpecContext.class,i);
}
public List WITH() { return getTokens(SqlBaseParser.WITH); }
public TerminalNode WITH(int i) {
return getToken(SqlBaseParser.WITH, i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public List DBPROPERTIES() { return getTokens(SqlBaseParser.DBPROPERTIES); }
public TerminalNode DBPROPERTIES(int i) {
return getToken(SqlBaseParser.DBPROPERTIES, i);
}
public List PROPERTIES() { return getTokens(SqlBaseParser.PROPERTIES); }
public TerminalNode PROPERTIES(int i) {
return getToken(SqlBaseParser.PROPERTIES, i);
}
public CreateNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCreateNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTblPropertiesContext extends StatementContext {
public MultipartIdentifierContext table;
public TablePropertyKeyContext key;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode TBLPROPERTIES() { return getToken(SqlBaseParser.TBLPROPERTIES, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TablePropertyKeyContext tablePropertyKey() {
return getRuleContext(TablePropertyKeyContext.class,0);
}
public ShowTblPropertiesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowTblProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowTblProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowTblProperties(this);
else return visitor.visitChildren(this);
}
}
public static class UnsetTablePropertiesContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode UNSET() { return getToken(SqlBaseParser.UNSET, 0); }
public TerminalNode TBLPROPERTIES() { return getToken(SqlBaseParser.TBLPROPERTIES, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public UnsetTablePropertiesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUnsetTableProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUnsetTableProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUnsetTableProperties(this);
else return visitor.visitChildren(this);
}
}
public static class SetTableLocationContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public LocationSpecContext locationSpec() {
return getRuleContext(LocationSpecContext.class,0);
}
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public SetTableLocationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetTableLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetTableLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetTableLocation(this);
else return visitor.visitChildren(this);
}
}
public static class DropTableColumnsContext extends StatementContext {
public MultipartIdentifierListContext columns;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public MultipartIdentifierListContext multipartIdentifierList() {
return getRuleContext(MultipartIdentifierListContext.class,0);
}
public DropTableColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDropTableColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDropTableColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDropTableColumns(this);
else return visitor.visitChildren(this);
}
}
public static class ShowViewsContext extends StatementContext {
public Token pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode VIEWS() { return getToken(SqlBaseParser.VIEWS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowViewsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowViews(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowViews(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowViews(this);
else return visitor.visitChildren(this);
}
}
public static class ShowFunctionsContext extends StatementContext {
public Token pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode FUNCTIONS() { return getToken(SqlBaseParser.FUNCTIONS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public ShowFunctionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterShowFunctions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitShowFunctions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitShowFunctions(this);
else return visitor.visitChildren(this);
}
}
public static class CacheTableContext extends StatementContext {
public TablePropertyListContext options;
public TerminalNode CACHE() { return getToken(SqlBaseParser.CACHE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LAZY() { return getToken(SqlBaseParser.LAZY, 0); }
public TerminalNode OPTIONS() { return getToken(SqlBaseParser.OPTIONS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public CacheTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCacheTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCacheTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCacheTable(this);
else return visitor.visitChildren(this);
}
}
public static class AddTableColumnsContext extends StatementContext {
public QualifiedColTypeWithPositionListContext columns;
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(SqlBaseParser.ADD, 0); }
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public QualifiedColTypeWithPositionListContext qualifiedColTypeWithPositionList() {
return getRuleContext(QualifiedColTypeWithPositionListContext.class,0);
}
public AddTableColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAddTableColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAddTableColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAddTableColumns(this);
else return visitor.visitChildren(this);
}
}
public static class SetTablePropertiesContext extends StatementContext {
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode TBLPROPERTIES() { return getToken(SqlBaseParser.TBLPROPERTIES, 0); }
public TablePropertyListContext tablePropertyList() {
return getRuleContext(TablePropertyListContext.class,0);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public SetTablePropertiesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetTableProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetTableProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetTableProperties(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 14, RULE_statement);
int _la;
try {
int _alt;
setState(1025);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
_localctx = new StatementDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(301);
query();
}
break;
case 2:
_localctx = new DmlStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(302);
ctes();
}
}
setState(305);
dmlStatementNoWith();
}
break;
case 3:
_localctx = new UseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(306);
match(USE);
setState(308);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(307);
match(NAMESPACE);
}
break;
}
setState(310);
multipartIdentifier();
}
break;
case 4:
_localctx = new CreateNamespaceContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(311);
match(CREATE);
setState(312);
namespace();
setState(316);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
setState(313);
match(IF);
setState(314);
match(NOT);
setState(315);
match(EXISTS);
}
break;
}
setState(318);
multipartIdentifier();
setState(326);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT || _la==LOCATION || _la==WITH) {
{
setState(324);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
{
setState(319);
commentSpec();
}
break;
case LOCATION:
{
setState(320);
locationSpec();
}
break;
case WITH:
{
{
setState(321);
match(WITH);
setState(322);
_la = _input.LA(1);
if ( !(_la==DBPROPERTIES || _la==PROPERTIES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(323);
tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 5:
_localctx = new SetNamespacePropertiesContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(329);
match(ALTER);
setState(330);
namespace();
setState(331);
multipartIdentifier();
setState(332);
match(SET);
setState(333);
_la = _input.LA(1);
if ( !(_la==DBPROPERTIES || _la==PROPERTIES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(334);
tablePropertyList();
}
break;
case 6:
_localctx = new SetNamespaceLocationContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(336);
match(ALTER);
setState(337);
namespace();
setState(338);
multipartIdentifier();
setState(339);
match(SET);
setState(340);
locationSpec();
}
break;
case 7:
_localctx = new DropNamespaceContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(342);
match(DROP);
setState(343);
namespace();
setState(346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(344);
match(IF);
setState(345);
match(EXISTS);
}
break;
}
setState(348);
multipartIdentifier();
setState(350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CASCADE || _la==RESTRICT) {
{
setState(349);
_la = _input.LA(1);
if ( !(_la==CASCADE || _la==RESTRICT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
case 8:
_localctx = new ShowNamespacesContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(352);
match(SHOW);
setState(353);
_la = _input.LA(1);
if ( !(_la==DATABASES || _la==NAMESPACES) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(354);
_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(355);
multipartIdentifier();
}
}
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE || _la==STRING) {
{
setState(359);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(358);
match(LIKE);
}
}
setState(361);
((ShowNamespacesContext)_localctx).pattern = match(STRING);
}
}
}
break;
case 9:
_localctx = new CreateTableContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(364);
if (!(!legacy_create_hive_table_by_default_enabled)) throw new FailedPredicateException(this, "!legacy_create_hive_table_by_default_enabled");
setState(365);
createTableHeader();
setState(370);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(366);
match(T__1);
setState(367);
colTypeList();
setState(368);
match(T__2);
}
break;
}
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(372);
tableProvider();
}
}
setState(375);
createTableClauses();
setState(380);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1 || _la==AS || _la==FROM || _la==MAP || ((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & ((1L << (REDUCE - 187)) | (1L << (SELECT - 187)) | (1L << (TABLE - 187)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(377);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(376);
match(AS);
}
}
setState(379);
query();
}
}
}
break;
case 10:
_localctx = new CreateTableContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(382);
if (!(legacy_create_hive_table_by_default_enabled)) throw new FailedPredicateException(this, "legacy_create_hive_table_by_default_enabled");
setState(383);
createTableHeader();
setState(388);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(384);
match(T__1);
setState(385);
colTypeList();
setState(386);
match(T__2);
}
}
setState(390);
tableProvider();
setState(391);
createTableClauses();
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1 || _la==AS || _la==FROM || _la==MAP || ((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & ((1L << (REDUCE - 187)) | (1L << (SELECT - 187)) | (1L << (TABLE - 187)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(393);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(392);
match(AS);
}
}
setState(395);
query();
}
}
}
break;
case 11:
_localctx = new CreateHiveTableContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(398);
createTableHeader();
setState(403);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(399);
match(T__1);
setState(400);
((CreateHiveTableContext)_localctx).columns = colTypeList();
setState(401);
match(T__2);
}
break;
}
setState(426);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CLUSTERED || _la==COMMENT || _la==LOCATION || _la==PARTITIONED || ((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & ((1L << (ROW - 202)) | (1L << (SKEWED - 202)) | (1L << (STORED - 202)) | (1L << (TBLPROPERTIES - 202)))) != 0)) {
{
setState(424);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
{
setState(405);
commentSpec();
}
break;
case PARTITIONED:
{
setState(415);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(406);
match(PARTITIONED);
setState(407);
match(BY);
setState(408);
match(T__1);
setState(409);
((CreateHiveTableContext)_localctx).partitionColumns = colTypeList();
setState(410);
match(T__2);
}
break;
case 2:
{
setState(412);
match(PARTITIONED);
setState(413);
match(BY);
setState(414);
((CreateHiveTableContext)_localctx).partitionColumnNames = identifierList();
}
break;
}
}
break;
case CLUSTERED:
{
setState(417);
bucketSpec();
}
break;
case SKEWED:
{
setState(418);
skewSpec();
}
break;
case ROW:
{
setState(419);
rowFormat();
}
break;
case STORED:
{
setState(420);
createFileFormat();
}
break;
case LOCATION:
{
setState(421);
locationSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(422);
match(TBLPROPERTIES);
setState(423);
((CreateHiveTableContext)_localctx).tableProps = tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(428);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(433);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1 || _la==AS || _la==FROM || _la==MAP || ((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & ((1L << (REDUCE - 187)) | (1L << (SELECT - 187)) | (1L << (TABLE - 187)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(429);
match(AS);
}
}
setState(432);
query();
}
}
}
break;
case 12:
_localctx = new CreateTableLikeContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(435);
match(CREATE);
setState(436);
match(TABLE);
setState(440);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(437);
match(IF);
setState(438);
match(NOT);
setState(439);
match(EXISTS);
}
break;
}
setState(442);
((CreateTableLikeContext)_localctx).target = tableIdentifier();
setState(443);
match(LIKE);
setState(444);
((CreateTableLikeContext)_localctx).source = tableIdentifier();
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOCATION || ((((_la - 202)) & ~0x3f) == 0 && ((1L << (_la - 202)) & ((1L << (ROW - 202)) | (1L << (STORED - 202)) | (1L << (TBLPROPERTIES - 202)) | (1L << (USING - 202)))) != 0)) {
{
setState(451);
_errHandler.sync(this);
switch (_input.LA(1)) {
case USING:
{
setState(445);
tableProvider();
}
break;
case ROW:
{
setState(446);
rowFormat();
}
break;
case STORED:
{
setState(447);
createFileFormat();
}
break;
case LOCATION:
{
setState(448);
locationSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(449);
match(TBLPROPERTIES);
setState(450);
((CreateTableLikeContext)_localctx).tableProps = tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(455);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 13:
_localctx = new ReplaceTableContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(456);
replaceTableHeader();
setState(461);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(457);
match(T__1);
setState(458);
colTypeList();
setState(459);
match(T__2);
}
}
setState(463);
tableProvider();
setState(464);
createTableClauses();
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1 || _la==AS || _la==FROM || _la==MAP || ((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & ((1L << (REDUCE - 187)) | (1L << (SELECT - 187)) | (1L << (TABLE - 187)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(466);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(465);
match(AS);
}
}
setState(468);
query();
}
}
}
break;
case 14:
_localctx = new AnalyzeContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(471);
match(ANALYZE);
setState(472);
match(TABLE);
setState(473);
multipartIdentifier();
setState(475);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(474);
partitionSpec();
}
}
setState(477);
match(COMPUTE);
setState(478);
match(STATISTICS);
setState(486);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(479);
identifier();
}
break;
case 2:
{
setState(480);
match(FOR);
setState(481);
match(COLUMNS);
setState(482);
identifierSeq();
}
break;
case 3:
{
setState(483);
match(FOR);
setState(484);
match(ALL);
setState(485);
match(COLUMNS);
}
break;
}
}
break;
case 15:
_localctx = new AddTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(488);
match(ALTER);
setState(489);
match(TABLE);
setState(490);
multipartIdentifier();
setState(491);
match(ADD);
setState(492);
_la = _input.LA(1);
if ( !(_la==COLUMN || _la==COLUMNS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(493);
((AddTableColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
}
break;
case 16:
_localctx = new AddTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(495);
match(ALTER);
setState(496);
match(TABLE);
setState(497);
multipartIdentifier();
setState(498);
match(ADD);
setState(499);
_la = _input.LA(1);
if ( !(_la==COLUMN || _la==COLUMNS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(500);
match(T__1);
setState(501);
((AddTableColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
setState(502);
match(T__2);
}
break;
case 17:
_localctx = new RenameTableColumnContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(504);
match(ALTER);
setState(505);
match(TABLE);
setState(506);
((RenameTableColumnContext)_localctx).table = multipartIdentifier();
setState(507);
match(RENAME);
setState(508);
match(COLUMN);
setState(509);
((RenameTableColumnContext)_localctx).from = multipartIdentifier();
setState(510);
match(TO);
setState(511);
((RenameTableColumnContext)_localctx).to = errorCapturingIdentifier();
}
break;
case 18:
_localctx = new DropTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(513);
match(ALTER);
setState(514);
match(TABLE);
setState(515);
multipartIdentifier();
setState(516);
match(DROP);
setState(517);
_la = _input.LA(1);
if ( !(_la==COLUMN || _la==COLUMNS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(518);
match(T__1);
setState(519);
((DropTableColumnsContext)_localctx).columns = multipartIdentifierList();
setState(520);
match(T__2);
}
break;
case 19:
_localctx = new DropTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(522);
match(ALTER);
setState(523);
match(TABLE);
setState(524);
multipartIdentifier();
setState(525);
match(DROP);
setState(526);
_la = _input.LA(1);
if ( !(_la==COLUMN || _la==COLUMNS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(527);
((DropTableColumnsContext)_localctx).columns = multipartIdentifierList();
}
break;
case 20:
_localctx = new RenameTableContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(529);
match(ALTER);
setState(530);
_la = _input.LA(1);
if ( !(_la==TABLE || _la==VIEW) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(531);
((RenameTableContext)_localctx).from = multipartIdentifier();
setState(532);
match(RENAME);
setState(533);
match(TO);
setState(534);
((RenameTableContext)_localctx).to = multipartIdentifier();
}
break;
case 21:
_localctx = new SetTablePropertiesContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(536);
match(ALTER);
setState(537);
_la = _input.LA(1);
if ( !(_la==TABLE || _la==VIEW) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(538);
multipartIdentifier();
setState(539);
match(SET);
setState(540);
match(TBLPROPERTIES);
setState(541);
tablePropertyList();
}
break;
case 22:
_localctx = new UnsetTablePropertiesContext(_localctx);
enterOuterAlt(_localctx, 22);
{
setState(543);
match(ALTER);
setState(544);
_la = _input.LA(1);
if ( !(_la==TABLE || _la==VIEW) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(545);
multipartIdentifier();
setState(546);
match(UNSET);
setState(547);
match(TBLPROPERTIES);
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(548);
match(IF);
setState(549);
match(EXISTS);
}
}
setState(552);
tablePropertyList();
}
break;
case 23:
_localctx = new AlterTableAlterColumnContext(_localctx);
enterOuterAlt(_localctx, 23);
{
setState(554);
match(ALTER);
setState(555);
match(TABLE);
setState(556);
((AlterTableAlterColumnContext)_localctx).table = multipartIdentifier();
setState(557);
_la = _input.LA(1);
if ( !(_la==ALTER || _la==CHANGE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(559);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
{
setState(558);
match(COLUMN);
}
break;
}
setState(561);
((AlterTableAlterColumnContext)_localctx).column = multipartIdentifier();
setState(563);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==COMMENT || _la==DROP || _la==FIRST || _la==SET || _la==TYPE) {
{
setState(562);
alterColumnAction();
}
}
}
break;
case 24:
_localctx = new HiveChangeColumnContext(_localctx);
enterOuterAlt(_localctx, 24);
{
setState(565);
match(ALTER);
setState(566);
match(TABLE);
setState(567);
((HiveChangeColumnContext)_localctx).table = multipartIdentifier();
setState(569);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(568);
partitionSpec();
}
}
setState(571);
match(CHANGE);
setState(573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(572);
match(COLUMN);
}
break;
}
setState(575);
((HiveChangeColumnContext)_localctx).colName = multipartIdentifier();
setState(576);
colType();
setState(578);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==FIRST) {
{
setState(577);
colPosition();
}
}
}
break;
case 25:
_localctx = new HiveReplaceColumnsContext(_localctx);
enterOuterAlt(_localctx, 25);
{
setState(580);
match(ALTER);
setState(581);
match(TABLE);
setState(582);
((HiveReplaceColumnsContext)_localctx).table = multipartIdentifier();
setState(584);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(583);
partitionSpec();
}
}
setState(586);
match(REPLACE);
setState(587);
match(COLUMNS);
setState(588);
match(T__1);
setState(589);
((HiveReplaceColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
setState(590);
match(T__2);
}
break;
case 26:
_localctx = new SetTableSerDeContext(_localctx);
enterOuterAlt(_localctx, 26);
{
setState(592);
match(ALTER);
setState(593);
match(TABLE);
setState(594);
multipartIdentifier();
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(595);
partitionSpec();
}
}
setState(598);
match(SET);
setState(599);
match(SERDE);
setState(600);
match(STRING);
setState(604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(601);
match(WITH);
setState(602);
match(SERDEPROPERTIES);
setState(603);
tablePropertyList();
}
}
}
break;
case 27:
_localctx = new SetTableSerDeContext(_localctx);
enterOuterAlt(_localctx, 27);
{
setState(606);
match(ALTER);
setState(607);
match(TABLE);
setState(608);
multipartIdentifier();
setState(610);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(609);
partitionSpec();
}
}
setState(612);
match(SET);
setState(613);
match(SERDEPROPERTIES);
setState(614);
tablePropertyList();
}
break;
case 28:
_localctx = new AddTablePartitionContext(_localctx);
enterOuterAlt(_localctx, 28);
{
setState(616);
match(ALTER);
setState(617);
_la = _input.LA(1);
if ( !(_la==TABLE || _la==VIEW) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(618);
multipartIdentifier();
setState(619);
match(ADD);
setState(623);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(620);
match(IF);
setState(621);
match(NOT);
setState(622);
match(EXISTS);
}
}
setState(626);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(625);
partitionSpecLocation();
}
}
setState(628);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==PARTITION );
}
break;
case 29:
_localctx = new RenameTablePartitionContext(_localctx);
enterOuterAlt(_localctx, 29);
{
setState(630);
match(ALTER);
setState(631);
match(TABLE);
setState(632);
multipartIdentifier();
setState(633);
((RenameTablePartitionContext)_localctx).from = partitionSpec();
setState(634);
match(RENAME);
setState(635);
match(TO);
setState(636);
((RenameTablePartitionContext)_localctx).to = partitionSpec();
}
break;
case 30:
_localctx = new DropTablePartitionsContext(_localctx);
enterOuterAlt(_localctx, 30);
{
setState(638);
match(ALTER);
setState(639);
_la = _input.LA(1);
if ( !(_la==TABLE || _la==VIEW) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(640);
multipartIdentifier();
setState(641);
match(DROP);
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(642);
match(IF);
setState(643);
match(EXISTS);
}
}
setState(646);
partitionSpec();
setState(651);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(647);
match(T__3);
setState(648);
partitionSpec();
}
}
setState(653);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(655);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PURGE) {
{
setState(654);
match(PURGE);
}
}
}
break;
case 31:
_localctx = new SetTableLocationContext(_localctx);
enterOuterAlt(_localctx, 31);
{
setState(657);
match(ALTER);
setState(658);
match(TABLE);
setState(659);
multipartIdentifier();
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(660);
partitionSpec();
}
}
setState(663);
match(SET);
setState(664);
locationSpec();
}
break;
case 32:
_localctx = new RecoverPartitionsContext(_localctx);
enterOuterAlt(_localctx, 32);
{
setState(666);
match(ALTER);
setState(667);
match(TABLE);
setState(668);
multipartIdentifier();
setState(669);
match(RECOVER);
setState(670);
match(PARTITIONS);
}
break;
case 33:
_localctx = new DropTableContext(_localctx);
enterOuterAlt(_localctx, 33);
{
setState(672);
match(DROP);
setState(673);
match(TABLE);
setState(676);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(674);
match(IF);
setState(675);
match(EXISTS);
}
break;
}
setState(678);
multipartIdentifier();
setState(680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PURGE) {
{
setState(679);
match(PURGE);
}
}
}
break;
case 34:
_localctx = new DropViewContext(_localctx);
enterOuterAlt(_localctx, 34);
{
setState(682);
match(DROP);
setState(683);
match(VIEW);
setState(686);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
{
setState(684);
match(IF);
setState(685);
match(EXISTS);
}
break;
}
setState(688);
multipartIdentifier();
}
break;
case 35:
_localctx = new CreateViewContext(_localctx);
enterOuterAlt(_localctx, 35);
{
setState(689);
match(CREATE);
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(690);
match(OR);
setState(691);
match(REPLACE);
}
}
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==TEMPORARY) {
{
setState(695);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL) {
{
setState(694);
match(GLOBAL);
}
}
setState(697);
match(TEMPORARY);
}
}
setState(700);
match(VIEW);
setState(704);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
case 1:
{
setState(701);
match(IF);
setState(702);
match(NOT);
setState(703);
match(EXISTS);
}
break;
}
setState(706);
multipartIdentifier();
setState(708);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(707);
identifierCommentList();
}
}
setState(718);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT || _la==PARTITIONED || _la==TBLPROPERTIES) {
{
setState(716);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
{
setState(710);
commentSpec();
}
break;
case PARTITIONED:
{
{
setState(711);
match(PARTITIONED);
setState(712);
match(ON);
setState(713);
identifierList();
}
}
break;
case TBLPROPERTIES:
{
{
setState(714);
match(TBLPROPERTIES);
setState(715);
tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(720);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(721);
match(AS);
setState(722);
query();
}
break;
case 36:
_localctx = new CreateTempViewUsingContext(_localctx);
enterOuterAlt(_localctx, 36);
{
setState(724);
match(CREATE);
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(725);
match(OR);
setState(726);
match(REPLACE);
}
}
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL) {
{
setState(729);
match(GLOBAL);
}
}
setState(732);
match(TEMPORARY);
setState(733);
match(VIEW);
setState(734);
tableIdentifier();
setState(739);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(735);
match(T__1);
setState(736);
colTypeList();
setState(737);
match(T__2);
}
}
setState(741);
tableProvider();
setState(744);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(742);
match(OPTIONS);
setState(743);
tablePropertyList();
}
}
}
break;
case 37:
_localctx = new AlterViewQueryContext(_localctx);
enterOuterAlt(_localctx, 37);
{
setState(746);
match(ALTER);
setState(747);
match(VIEW);
setState(748);
multipartIdentifier();
setState(750);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(749);
match(AS);
}
}
setState(752);
query();
}
break;
case 38:
_localctx = new CreateFunctionContext(_localctx);
enterOuterAlt(_localctx, 38);
{
setState(754);
match(CREATE);
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(755);
match(OR);
setState(756);
match(REPLACE);
}
}
setState(760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(759);
match(TEMPORARY);
}
}
setState(762);
match(FUNCTION);
setState(766);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(763);
match(IF);
setState(764);
match(NOT);
setState(765);
match(EXISTS);
}
break;
}
setState(768);
multipartIdentifier();
setState(769);
match(AS);
setState(770);
((CreateFunctionContext)_localctx).className = match(STRING);
setState(780);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(771);
match(USING);
setState(772);
resource();
setState(777);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(773);
match(T__3);
setState(774);
resource();
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
break;
case 39:
_localctx = new DropFunctionContext(_localctx);
enterOuterAlt(_localctx, 39);
{
setState(782);
match(DROP);
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(783);
match(TEMPORARY);
}
}
setState(786);
match(FUNCTION);
setState(789);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(787);
match(IF);
setState(788);
match(EXISTS);
}
break;
}
setState(791);
multipartIdentifier();
}
break;
case 40:
_localctx = new ExplainContext(_localctx);
enterOuterAlt(_localctx, 40);
{
setState(792);
match(EXPLAIN);
setState(794);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(793);
_la = _input.LA(1);
if ( !(_la==CODEGEN || _la==COST || ((((_la - 86)) & ~0x3f) == 0 && ((1L << (_la - 86)) & ((1L << (EXTENDED - 86)) | (1L << (FORMATTED - 86)) | (1L << (LOGICAL - 86)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(796);
statement();
}
break;
case 41:
_localctx = new ShowTablesContext(_localctx);
enterOuterAlt(_localctx, 41);
{
setState(797);
match(SHOW);
setState(798);
match(TABLES);
setState(801);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(799);
_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(800);
multipartIdentifier();
}
}
setState(807);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE || _la==STRING) {
{
setState(804);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(803);
match(LIKE);
}
}
setState(806);
((ShowTablesContext)_localctx).pattern = match(STRING);
}
}
}
break;
case 42:
_localctx = new ShowTableContext(_localctx);
enterOuterAlt(_localctx, 42);
{
setState(809);
match(SHOW);
setState(810);
match(TABLE);
setState(811);
match(EXTENDED);
setState(814);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(812);
_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(813);
((ShowTableContext)_localctx).ns = multipartIdentifier();
}
}
setState(816);
match(LIKE);
setState(817);
((ShowTableContext)_localctx).pattern = match(STRING);
setState(819);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(818);
partitionSpec();
}
}
}
break;
case 43:
_localctx = new ShowTblPropertiesContext(_localctx);
enterOuterAlt(_localctx, 43);
{
setState(821);
match(SHOW);
setState(822);
match(TBLPROPERTIES);
setState(823);
((ShowTblPropertiesContext)_localctx).table = multipartIdentifier();
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(824);
match(T__1);
setState(825);
((ShowTblPropertiesContext)_localctx).key = tablePropertyKey();
setState(826);
match(T__2);
}
}
}
break;
case 44:
_localctx = new ShowColumnsContext(_localctx);
enterOuterAlt(_localctx, 44);
{
setState(830);
match(SHOW);
setState(831);
match(COLUMNS);
setState(832);
_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(833);
((ShowColumnsContext)_localctx).table = multipartIdentifier();
setState(836);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(834);
_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(835);
((ShowColumnsContext)_localctx).ns = multipartIdentifier();
}
}
}
break;
case 45:
_localctx = new ShowViewsContext(_localctx);
enterOuterAlt(_localctx, 45);
{
setState(838);
match(SHOW);
setState(839);
match(VIEWS);
setState(842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(840);
_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(841);
multipartIdentifier();
}
}
setState(848);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE || _la==STRING) {
{
setState(845);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(844);
match(LIKE);
}
}
setState(847);
((ShowViewsContext)_localctx).pattern = match(STRING);
}
}
}
break;
case 46:
_localctx = new ShowPartitionsContext(_localctx);
enterOuterAlt(_localctx, 46);
{
setState(850);
match(SHOW);
setState(851);
match(PARTITIONS);
setState(852);
multipartIdentifier();
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(853);
partitionSpec();
}
}
}
break;
case 47:
_localctx = new ShowFunctionsContext(_localctx);
enterOuterAlt(_localctx, 47);
{
setState(856);
match(SHOW);
setState(858);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(857);
identifier();
}
break;
}
setState(860);
match(FUNCTIONS);
setState(868);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
{
setState(862);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(861);
match(LIKE);
}
break;
}
setState(866);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(864);
multipartIdentifier();
}
break;
case 2:
{
setState(865);
((ShowFunctionsContext)_localctx).pattern = match(STRING);
}
break;
}
}
break;
}
}
break;
case 48:
_localctx = new ShowCreateTableContext(_localctx);
enterOuterAlt(_localctx, 48);
{
setState(870);
match(SHOW);
setState(871);
match(CREATE);
setState(872);
match(TABLE);
setState(873);
multipartIdentifier();
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(874);
match(AS);
setState(875);
match(SERDE);
}
}
}
break;
case 49:
_localctx = new ShowCurrentNamespaceContext(_localctx);
enterOuterAlt(_localctx, 49);
{
setState(878);
match(SHOW);
setState(879);
match(CURRENT);
setState(880);
match(NAMESPACE);
}
break;
case 50:
_localctx = new DescribeFunctionContext(_localctx);
enterOuterAlt(_localctx, 50);
{
setState(881);
_la = _input.LA(1);
if ( !(_la==DESC || _la==DESCRIBE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(882);
match(FUNCTION);
setState(884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(883);
match(EXTENDED);
}
break;
}
setState(886);
describeFuncName();
}
break;
case 51:
_localctx = new DescribeNamespaceContext(_localctx);
enterOuterAlt(_localctx, 51);
{
setState(887);
_la = _input.LA(1);
if ( !(_la==DESC || _la==DESCRIBE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(888);
namespace();
setState(890);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(889);
match(EXTENDED);
}
break;
}
setState(892);
multipartIdentifier();
}
break;
case 52:
_localctx = new DescribeRelationContext(_localctx);
enterOuterAlt(_localctx, 52);
{
setState(894);
_la = _input.LA(1);
if ( !(_la==DESC || _la==DESCRIBE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(896);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(895);
match(TABLE);
}
break;
}
setState(899);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(898);
((DescribeRelationContext)_localctx).option = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXTENDED || _la==FORMATTED) ) {
((DescribeRelationContext)_localctx).option = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(901);
multipartIdentifier();
setState(903);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(902);
partitionSpec();
}
break;
}
setState(906);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
{
setState(905);
describeColName();
}
break;
}
}
break;
case 53:
_localctx = new DescribeQueryContext(_localctx);
enterOuterAlt(_localctx, 53);
{
setState(908);
_la = _input.LA(1);
if ( !(_la==DESC || _la==DESCRIBE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(910);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUERY) {
{
setState(909);
match(QUERY);
}
}
setState(912);
query();
}
break;
case 54:
_localctx = new CommentNamespaceContext(_localctx);
enterOuterAlt(_localctx, 54);
{
setState(913);
match(COMMENT);
setState(914);
match(ON);
setState(915);
namespace();
setState(916);
multipartIdentifier();
setState(917);
match(IS);
setState(918);
((CommentNamespaceContext)_localctx).comment = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==NULL || _la==STRING) ) {
((CommentNamespaceContext)_localctx).comment = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 55:
_localctx = new CommentTableContext(_localctx);
enterOuterAlt(_localctx, 55);
{
setState(920);
match(COMMENT);
setState(921);
match(ON);
setState(922);
match(TABLE);
setState(923);
multipartIdentifier();
setState(924);
match(IS);
setState(925);
((CommentTableContext)_localctx).comment = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==NULL || _la==STRING) ) {
((CommentTableContext)_localctx).comment = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 56:
_localctx = new RefreshTableContext(_localctx);
enterOuterAlt(_localctx, 56);
{
setState(927);
match(REFRESH);
setState(928);
match(TABLE);
setState(929);
multipartIdentifier();
}
break;
case 57:
_localctx = new RefreshResourceContext(_localctx);
enterOuterAlt(_localctx, 57);
{
setState(930);
match(REFRESH);
setState(938);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(931);
match(STRING);
}
break;
case 2:
{
setState(935);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(932);
matchWildcard();
}
}
}
setState(937);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
}
}
break;
}
}
break;
case 58:
_localctx = new CacheTableContext(_localctx);
enterOuterAlt(_localctx, 58);
{
setState(940);
match(CACHE);
setState(942);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LAZY) {
{
setState(941);
match(LAZY);
}
}
setState(944);
match(TABLE);
setState(945);
multipartIdentifier();
setState(948);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(946);
match(OPTIONS);
setState(947);
((CacheTableContext)_localctx).options = tablePropertyList();
}
}
setState(954);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1 || _la==AS || _la==FROM || _la==MAP || ((((_la - 187)) & ~0x3f) == 0 && ((1L << (_la - 187)) & ((1L << (REDUCE - 187)) | (1L << (SELECT - 187)) | (1L << (TABLE - 187)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(951);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(950);
match(AS);
}
}
setState(953);
query();
}
}
}
break;
case 59:
_localctx = new UncacheTableContext(_localctx);
enterOuterAlt(_localctx, 59);
{
setState(956);
match(UNCACHE);
setState(957);
match(TABLE);
setState(960);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
setState(958);
match(IF);
setState(959);
match(EXISTS);
}
break;
}
setState(962);
multipartIdentifier();
}
break;
case 60:
_localctx = new ClearCacheContext(_localctx);
enterOuterAlt(_localctx, 60);
{
setState(963);
match(CLEAR);
setState(964);
match(CACHE);
}
break;
case 61:
_localctx = new LoadDataContext(_localctx);
enterOuterAlt(_localctx, 61);
{
setState(965);
match(LOAD);
setState(966);
match(DATA);
setState(968);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(967);
match(LOCAL);
}
}
setState(970);
match(INPATH);
setState(971);
((LoadDataContext)_localctx).path = match(STRING);
setState(973);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OVERWRITE) {
{
setState(972);
match(OVERWRITE);
}
}
setState(975);
match(INTO);
setState(976);
match(TABLE);
setState(977);
multipartIdentifier();
setState(979);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(978);
partitionSpec();
}
}
}
break;
case 62:
_localctx = new TruncateTableContext(_localctx);
enterOuterAlt(_localctx, 62);
{
setState(981);
match(TRUNCATE);
setState(982);
match(TABLE);
setState(983);
multipartIdentifier();
setState(985);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(984);
partitionSpec();
}
}
}
break;
case 63:
_localctx = new RepairTableContext(_localctx);
enterOuterAlt(_localctx, 63);
{
setState(987);
match(MSCK);
setState(988);
match(REPAIR);
setState(989);
match(TABLE);
setState(990);
multipartIdentifier();
}
break;
case 64:
_localctx = new ManageResourceContext(_localctx);
enterOuterAlt(_localctx, 64);
{
setState(991);
((ManageResourceContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ADD || _la==LIST) ) {
((ManageResourceContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(992);
identifier();
setState(1000);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(993);
match(STRING);
}
break;
case 2:
{
setState(997);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,105,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(994);
matchWildcard();
}
}
}
setState(999);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,105,_ctx);
}
}
break;
}
}
break;
case 65:
_localctx = new FailNativeCommandContext(_localctx);
enterOuterAlt(_localctx, 65);
{
setState(1002);
match(SET);
setState(1003);
match(ROLE);
setState(1007);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1004);
matchWildcard();
}
}
}
setState(1009);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
}
}
break;
case 66:
_localctx = new SetConfigurationContext(_localctx);
enterOuterAlt(_localctx, 66);
{
setState(1010);
match(SET);
setState(1014);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1011);
matchWildcard();
}
}
}
setState(1016);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
}
}
break;
case 67:
_localctx = new ResetConfigurationContext(_localctx);
enterOuterAlt(_localctx, 67);
{
setState(1017);
match(RESET);
}
break;
case 68:
_localctx = new FailNativeCommandContext(_localctx);
enterOuterAlt(_localctx, 68);
{
setState(1018);
unsupportedHiveNativeCommands();
setState(1022);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,109,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1019);
matchWildcard();
}
}
}
setState(1024);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,109,_ctx);
}
}
break;
}
}
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(SqlBaseParser.CREATE, 0); }
public TerminalNode ROLE() { return getToken(SqlBaseParser.ROLE, 0); }
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode GRANT() { return getToken(SqlBaseParser.GRANT, 0); }
public TerminalNode REVOKE() { return getToken(SqlBaseParser.REVOKE, 0); }
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode PRINCIPALS() { return getToken(SqlBaseParser.PRINCIPALS, 0); }
public TerminalNode ROLES() { return getToken(SqlBaseParser.ROLES, 0); }
public TerminalNode CURRENT() { return getToken(SqlBaseParser.CURRENT, 0); }
public TerminalNode EXPORT() { return getToken(SqlBaseParser.EXPORT, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode IMPORT() { return getToken(SqlBaseParser.IMPORT, 0); }
public TerminalNode COMPACTIONS() { return getToken(SqlBaseParser.COMPACTIONS, 0); }
public TerminalNode TRANSACTIONS() { return getToken(SqlBaseParser.TRANSACTIONS, 0); }
public TerminalNode INDEXES() { return getToken(SqlBaseParser.INDEXES, 0); }
public TerminalNode LOCKS() { return getToken(SqlBaseParser.LOCKS, 0); }
public TerminalNode INDEX() { return getToken(SqlBaseParser.INDEX, 0); }
public TerminalNode ALTER() { return getToken(SqlBaseParser.ALTER, 0); }
public TerminalNode LOCK() { return getToken(SqlBaseParser.LOCK, 0); }
public TerminalNode DATABASE() { return getToken(SqlBaseParser.DATABASE, 0); }
public TerminalNode UNLOCK() { return getToken(SqlBaseParser.UNLOCK, 0); }
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode MACRO() { return getToken(SqlBaseParser.MACRO, 0); }
public TableIdentifierContext tableIdentifier() {
return getRuleContext(TableIdentifierContext.class,0);
}
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode CLUSTERED() { return getToken(SqlBaseParser.CLUSTERED, 0); }
public TerminalNode BY() { return getToken(SqlBaseParser.BY, 0); }
public TerminalNode SORTED() { return getToken(SqlBaseParser.SORTED, 0); }
public TerminalNode SKEWED() { return getToken(SqlBaseParser.SKEWED, 0); }
public TerminalNode STORED() { return getToken(SqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public TerminalNode DIRECTORIES() { return getToken(SqlBaseParser.DIRECTORIES, 0); }
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode LOCATION() { return getToken(SqlBaseParser.LOCATION, 0); }
public TerminalNode EXCHANGE() { return getToken(SqlBaseParser.EXCHANGE, 0); }
public TerminalNode PARTITION() { return getToken(SqlBaseParser.PARTITION, 0); }
public TerminalNode ARCHIVE() { return getToken(SqlBaseParser.ARCHIVE, 0); }
public TerminalNode UNARCHIVE() { return getToken(SqlBaseParser.UNARCHIVE, 0); }
public TerminalNode TOUCH() { return getToken(SqlBaseParser.TOUCH, 0); }
public TerminalNode COMPACT() { return getToken(SqlBaseParser.COMPACT, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode CONCATENATE() { return getToken(SqlBaseParser.CONCATENATE, 0); }
public TerminalNode FILEFORMAT() { return getToken(SqlBaseParser.FILEFORMAT, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public TerminalNode START() { return getToken(SqlBaseParser.START, 0); }
public TerminalNode TRANSACTION() { return getToken(SqlBaseParser.TRANSACTION, 0); }
public TerminalNode COMMIT() { return getToken(SqlBaseParser.COMMIT, 0); }
public TerminalNode ROLLBACK() { return getToken(SqlBaseParser.ROLLBACK, 0); }
public TerminalNode DFS() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterUnsupportedHiveNativeCommands(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUnsupportedHiveNativeCommands(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUnsupportedHiveNativeCommands(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedHiveNativeCommandsContext unsupportedHiveNativeCommands() throws RecognitionException {
UnsupportedHiveNativeCommandsContext _localctx = new UnsupportedHiveNativeCommandsContext(_ctx, getState());
enterRule(_localctx, 16, RULE_unsupportedHiveNativeCommands);
int _la;
try {
setState(1195);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1027);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1028);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1029);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1030);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1031);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(GRANT);
setState(1033);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
{
setState(1032);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1035);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(REVOKE);
setState(1037);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(1036);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1039);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1040);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(GRANT);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1041);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1042);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
setState(1044);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
{
setState(1043);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(GRANT);
}
break;
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1046);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1047);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(PRINCIPALS);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1048);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1049);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLES);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1050);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1051);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CURRENT);
setState(1052);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ROLES);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1053);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(EXPORT);
setState(1054);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1055);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(IMPORT);
setState(1056);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1057);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1058);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(COMPACTIONS);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(1059);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1060);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CREATE);
setState(1061);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TABLE);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(1062);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1063);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTIONS);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(1064);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1065);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEXES);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(1066);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1067);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(LOCKS);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(1068);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1069);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(1070);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1071);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(1072);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1073);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(1074);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(1075);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(1076);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(1077);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(1078);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(1079);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(1080);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(1081);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(1082);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1083);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(1084);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(1085);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1086);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(1087);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(1088);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1089);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1090);
tableIdentifier();
setState(1091);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1092);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(CLUSTERED);
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(1094);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1095);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1096);
tableIdentifier();
setState(1097);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CLUSTERED);
setState(1098);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(1100);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1101);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1102);
tableIdentifier();
setState(1103);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1104);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SORTED);
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(1106);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1107);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1108);
tableIdentifier();
setState(1109);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SKEWED);
setState(1110);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(1112);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1113);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1114);
tableIdentifier();
setState(1115);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1116);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(1118);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1119);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1120);
tableIdentifier();
setState(1121);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1122);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(STORED);
setState(1123);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(AS);
setState(1124);
((UnsupportedHiveNativeCommandsContext)_localctx).kw6 = match(DIRECTORIES);
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(1126);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1127);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1128);
tableIdentifier();
setState(1129);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(1130);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
setState(1131);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(LOCATION);
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(1133);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1134);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1135);
tableIdentifier();
setState(1136);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(EXCHANGE);
setState(1137);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(1139);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1140);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1141);
tableIdentifier();
setState(1142);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ARCHIVE);
setState(1143);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(1145);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1146);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1147);
tableIdentifier();
setState(1148);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(UNARCHIVE);
setState(1149);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(1151);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1152);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1153);
tableIdentifier();
setState(1154);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TOUCH);
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(1156);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1157);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1158);
tableIdentifier();
setState(1160);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1159);
partitionSpec();
}
}
setState(1162);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(COMPACT);
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(1164);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1165);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1166);
tableIdentifier();
setState(1168);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1167);
partitionSpec();
}
}
setState(1170);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CONCATENATE);
}
break;
case 39:
enterOuterAlt(_localctx, 39);
{
setState(1172);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1173);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1174);
tableIdentifier();
setState(1176);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1175);
partitionSpec();
}
}
setState(1178);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(1179);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(FILEFORMAT);
}
break;
case 40:
enterOuterAlt(_localctx, 40);
{
setState(1181);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1182);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1183);
tableIdentifier();
setState(1185);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1184);
partitionSpec();
}
}
setState(1187);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(REPLACE);
setState(1188);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(COLUMNS);
}
break;
case 41:
enterOuterAlt(_localctx, 41);
{
setState(1190);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(START);
setState(1191);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTION);
}
break;
case 42:
enterOuterAlt(_localctx, 42);
{
setState(1192);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(COMMIT);
}
break;
case 43:
enterOuterAlt(_localctx, 43);
{
setState(1193);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ROLLBACK);
}
break;
case 44:
enterOuterAlt(_localctx, 44);
{
setState(1194);
((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(SqlBaseParser.CREATE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TEMPORARY() { return getToken(SqlBaseParser.TEMPORARY, 0); }
public TerminalNode EXTERNAL() { return getToken(SqlBaseParser.EXTERNAL, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterCreateTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableHeaderContext createTableHeader() throws RecognitionException {
CreateTableHeaderContext _localctx = new CreateTableHeaderContext(_ctx, getState());
enterRule(_localctx, 18, RULE_createTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1197);
match(CREATE);
setState(1199);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(1198);
match(TEMPORARY);
}
}
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL) {
{
setState(1201);
match(EXTERNAL);
}
}
setState(1204);
match(TABLE);
setState(1208);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
{
setState(1205);
match(IF);
setState(1206);
match(NOT);
setState(1207);
match(EXISTS);
}
break;
}
setState(1210);
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(SqlBaseParser.REPLACE, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode OR() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterReplaceTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitReplaceTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitReplaceTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final ReplaceTableHeaderContext replaceTableHeader() throws RecognitionException {
ReplaceTableHeaderContext _localctx = new ReplaceTableHeaderContext(_ctx, getState());
enterRule(_localctx, 20, RULE_replaceTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1214);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(1212);
match(CREATE);
setState(1213);
match(OR);
}
}
setState(1216);
match(REPLACE);
setState(1217);
match(TABLE);
setState(1218);
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(SqlBaseParser.CLUSTERED, 0); }
public List BY() { return getTokens(SqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(SqlBaseParser.BY, i);
}
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode INTO() { return getToken(SqlBaseParser.INTO, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(SqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode BUCKETS() { return getToken(SqlBaseParser.BUCKETS, 0); }
public TerminalNode SORTED() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterBucketSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBucketSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBucketSpec(this);
else return visitor.visitChildren(this);
}
}
public final BucketSpecContext bucketSpec() throws RecognitionException {
BucketSpecContext _localctx = new BucketSpecContext(_ctx, getState());
enterRule(_localctx, 22, RULE_bucketSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1220);
match(CLUSTERED);
setState(1221);
match(BY);
setState(1222);
identifierList();
setState(1226);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SORTED) {
{
setState(1223);
match(SORTED);
setState(1224);
match(BY);
setState(1225);
orderedIdentifierList();
}
}
setState(1228);
match(INTO);
setState(1229);
match(INTEGER_VALUE);
setState(1230);
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(SqlBaseParser.SKEWED, 0); }
public TerminalNode BY() { return getToken(SqlBaseParser.BY, 0); }
public IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public TerminalNode ON() { return getToken(SqlBaseParser.ON, 0); }
public ConstantListContext constantList() {
return getRuleContext(ConstantListContext.class,0);
}
public NestedConstantListContext nestedConstantList() {
return getRuleContext(NestedConstantListContext.class,0);
}
public TerminalNode STORED() { return getToken(SqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public TerminalNode DIRECTORIES() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSkewSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSkewSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSkewSpec(this);
else return visitor.visitChildren(this);
}
}
public final SkewSpecContext skewSpec() throws RecognitionException {
SkewSpecContext _localctx = new SkewSpecContext(_ctx, getState());
enterRule(_localctx, 24, RULE_skewSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
match(SKEWED);
setState(1233);
match(BY);
setState(1234);
identifierList();
setState(1235);
match(ON);
setState(1238);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1236);
constantList();
}
break;
case 2:
{
setState(1237);
nestedConstantList();
}
break;
}
setState(1243);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1240);
match(STORED);
setState(1241);
match(AS);
setState(1242);
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(SqlBaseParser.LOCATION, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterLocationSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitLocationSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitLocationSpec(this);
else return visitor.visitChildren(this);
}
}
public final LocationSpecContext locationSpec() throws RecognitionException {
LocationSpecContext _localctx = new LocationSpecContext(_ctx, getState());
enterRule(_localctx, 26, RULE_locationSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1245);
match(LOCATION);
setState(1246);
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(SqlBaseParser.COMMENT, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterCommentSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCommentSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCommentSpec(this);
else return visitor.visitChildren(this);
}
}
public final CommentSpecContext commentSpec() throws RecognitionException {
CommentSpecContext _localctx = new CommentSpecContext(_ctx, getState());
enterRule(_localctx, 28, RULE_commentSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1248);
match(COMMENT);
setState(1249);
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 SqlBaseListener ) ((SqlBaseListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 30, RULE_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1251);
ctes();
}
}
setState(1254);
queryTerm(0);
setState(1255);
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(SqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(SqlBaseParser.OVERWRITE, 0); }
public TerminalNode DIRECTORY() { return getToken(SqlBaseParser.DIRECTORY, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public TerminalNode LOCAL() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterInsertOverwriteHiveDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInsertOverwriteHiveDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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(SqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(SqlBaseParser.OVERWRITE, 0); }
public TerminalNode DIRECTORY() { return getToken(SqlBaseParser.DIRECTORY, 0); }
public TableProviderContext tableProvider() {
return getRuleContext(TableProviderContext.class,0);
}
public TerminalNode LOCAL() { return getToken(SqlBaseParser.LOCAL, 0); }
public TerminalNode OPTIONS() { return getToken(SqlBaseParser.OPTIONS, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterInsertOverwriteDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInsertOverwriteDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitInsertOverwriteDir(this);
else return visitor.visitChildren(this);
}
}
public static class InsertOverwriteTableContext extends InsertIntoContext {
public TerminalNode INSERT() { return getToken(SqlBaseParser.INSERT, 0); }
public TerminalNode OVERWRITE() { return getToken(SqlBaseParser.OVERWRITE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public InsertOverwriteTableContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterInsertOverwriteTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInsertOverwriteTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitInsertOverwriteTable(this);
else return visitor.visitChildren(this);
}
}
public static class InsertIntoTableContext extends InsertIntoContext {
public TerminalNode INSERT() { return getToken(SqlBaseParser.INSERT, 0); }
public TerminalNode INTO() { return getToken(SqlBaseParser.INTO, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public PartitionSpecContext partitionSpec() {
return getRuleContext(PartitionSpecContext.class,0);
}
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public InsertIntoTableContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterInsertIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInsertIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitInsertIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final InsertIntoContext insertInto() throws RecognitionException {
InsertIntoContext _localctx = new InsertIntoContext(_ctx, getState());
enterRule(_localctx, 32, RULE_insertInto);
int _la;
try {
setState(1312);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
_localctx = new InsertOverwriteTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1257);
match(INSERT);
setState(1258);
match(OVERWRITE);
setState(1260);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1259);
match(TABLE);
}
break;
}
setState(1262);
multipartIdentifier();
setState(1269);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1263);
partitionSpec();
setState(1267);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(1264);
match(IF);
setState(1265);
match(NOT);
setState(1266);
match(EXISTS);
}
}
}
}
}
break;
case 2:
_localctx = new InsertIntoTableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1271);
match(INSERT);
setState(1272);
match(INTO);
setState(1274);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(1273);
match(TABLE);
}
break;
}
setState(1276);
multipartIdentifier();
setState(1278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1277);
partitionSpec();
}
}
setState(1283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(1280);
match(IF);
setState(1281);
match(NOT);
setState(1282);
match(EXISTS);
}
}
}
break;
case 3:
_localctx = new InsertOverwriteHiveDirContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1285);
match(INSERT);
setState(1286);
match(OVERWRITE);
setState(1288);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(1287);
match(LOCAL);
}
}
setState(1290);
match(DIRECTORY);
setState(1291);
((InsertOverwriteHiveDirContext)_localctx).path = match(STRING);
setState(1293);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(1292);
rowFormat();
}
}
setState(1296);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORED) {
{
setState(1295);
createFileFormat();
}
}
}
break;
case 4:
_localctx = new InsertOverwriteDirContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1298);
match(INSERT);
setState(1299);
match(OVERWRITE);
setState(1301);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(1300);
match(LOCAL);
}
}
setState(1303);
match(DIRECTORY);
setState(1305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING) {
{
setState(1304);
((InsertOverwriteDirContext)_localctx).path = match(STRING);
}
}
setState(1307);
tableProvider();
setState(1310);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(1308);
match(OPTIONS);
setState(1309);
((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 SqlBaseListener ) ((SqlBaseListener)listener).enterPartitionSpecLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPartitionSpecLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPartitionSpecLocation(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecLocationContext partitionSpecLocation() throws RecognitionException {
PartitionSpecLocationContext _localctx = new PartitionSpecLocationContext(_ctx, getState());
enterRule(_localctx, 34, RULE_partitionSpecLocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1314);
partitionSpec();
setState(1316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCATION) {
{
setState(1315);
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(SqlBaseParser.PARTITION, 0); }
public List partitionVal() {
return getRuleContexts(PartitionValContext.class);
}
public PartitionValContext partitionVal(int i) {
return getRuleContext(PartitionValContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterPartitionSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPartitionSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPartitionSpec(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecContext partitionSpec() throws RecognitionException {
PartitionSpecContext _localctx = new PartitionSpecContext(_ctx, getState());
enterRule(_localctx, 36, RULE_partitionSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1318);
match(PARTITION);
setState(1319);
match(T__1);
setState(1320);
partitionVal();
setState(1325);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1321);
match(T__3);
setState(1322);
partitionVal();
}
}
setState(1327);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1328);
match(T__2);
}
}
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterPartitionVal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPartitionVal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPartitionVal(this);
else return visitor.visitChildren(this);
}
}
public final PartitionValContext partitionVal() throws RecognitionException {
PartitionValContext _localctx = new PartitionValContext(_ctx, getState());
enterRule(_localctx, 38, RULE_partitionVal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1330);
identifier();
setState(1333);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1331);
match(EQ);
setState(1332);
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(SqlBaseParser.NAMESPACE, 0); }
public TerminalNode DATABASE() { return getToken(SqlBaseParser.DATABASE, 0); }
public TerminalNode SCHEMA() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNamespace(this);
else return visitor.visitChildren(this);
}
}
public final NamespaceContext namespace() throws RecognitionException {
NamespaceContext _localctx = new NamespaceContext(_ctx, getState());
enterRule(_localctx, 40, RULE_namespace);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1335);
_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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeFuncName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeFuncName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeFuncName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeFuncNameContext describeFuncName() throws RecognitionException {
DescribeFuncNameContext _localctx = new DescribeFuncNameContext(_ctx, getState());
enterRule(_localctx, 42, RULE_describeFuncName);
try {
setState(1342);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1337);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1338);
match(STRING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1339);
comparisonOperator();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1340);
arithmeticOperator();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1341);
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 DescribeColNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_describeColName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDescribeColName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDescribeColName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDescribeColName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeColNameContext describeColName() throws RecognitionException {
DescribeColNameContext _localctx = new DescribeColNameContext(_ctx, getState());
enterRule(_localctx, 44, RULE_describeColName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1344);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
setState(1349);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(1345);
match(T__4);
setState(1346);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
}
}
setState(1351);
_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(SqlBaseParser.WITH, 0); }
public List namedQuery() {
return getRuleContexts(NamedQueryContext.class);
}
public NamedQueryContext namedQuery(int i) {
return getRuleContext(NamedQueryContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterCtes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCtes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCtes(this);
else return visitor.visitChildren(this);
}
}
public final CtesContext ctes() throws RecognitionException {
CtesContext _localctx = new CtesContext(_ctx, getState());
enterRule(_localctx, 46, RULE_ctes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1352);
match(WITH);
setState(1353);
namedQuery();
setState(1358);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1354);
match(T__3);
setState(1355);
namedQuery();
}
}
setState(1360);
_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 QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public ErrorCapturingIdentifierContext errorCapturingIdentifier() {
return getRuleContext(ErrorCapturingIdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterNamedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNamedQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNamedQuery(this);
else return visitor.visitChildren(this);
}
}
public final NamedQueryContext namedQuery() throws RecognitionException {
NamedQueryContext _localctx = new NamedQueryContext(_ctx, getState());
enterRule(_localctx, 48, RULE_namedQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1361);
((NamedQueryContext)_localctx).name = errorCapturingIdentifier();
setState(1363);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1362);
((NamedQueryContext)_localctx).columnAliases = identifierList();
}
break;
}
setState(1366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1365);
match(AS);
}
}
setState(1368);
match(T__1);
setState(1369);
query();
setState(1370);
match(T__2);
}
}
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterTableProvider(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTableProvider(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTableProvider(this);
else return visitor.visitChildren(this);
}
}
public final TableProviderContext tableProvider() throws RecognitionException {
TableProviderContext _localctx = new TableProviderContext(_ctx, getState());
enterRule(_localctx, 50, RULE_tableProvider);
try {
enterOuterAlt(_localctx, 1);
{
setState(1372);
match(USING);
setState(1373);
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 TransformListContext partitioning;
public TablePropertyListContext tableProps;
public List bucketSpec() {
return getRuleContexts(BucketSpecContext.class);
}
public BucketSpecContext bucketSpec(int i) {
return getRuleContext(BucketSpecContext.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(SqlBaseParser.OPTIONS); }
public TerminalNode OPTIONS(int i) {
return getToken(SqlBaseParser.OPTIONS, i);
}
public List PARTITIONED() { return getTokens(SqlBaseParser.PARTITIONED); }
public TerminalNode PARTITIONED(int i) {
return getToken(SqlBaseParser.PARTITIONED, i);
}
public List BY() { return getTokens(SqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(SqlBaseParser.BY, i);
}
public List TBLPROPERTIES() { return getTokens(SqlBaseParser.TBLPROPERTIES); }
public TerminalNode TBLPROPERTIES(int i) {
return getToken(SqlBaseParser.TBLPROPERTIES, i);
}
public List tablePropertyList() {
return getRuleContexts(TablePropertyListContext.class);
}
public TablePropertyListContext tablePropertyList(int i) {
return getRuleContext(TablePropertyListContext.class,i);
}
public List transformList() {
return getRuleContexts(TransformListContext.class);
}
public TransformListContext transformList(int i) {
return getRuleContext(TransformListContext.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 SqlBaseListener ) ((SqlBaseListener)listener).enterCreateTableClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateTableClauses(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateTableClauses(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableClausesContext createTableClauses() throws RecognitionException {
CreateTableClausesContext _localctx = new CreateTableClausesContext(_ctx, getState());
enterRule(_localctx, 52, RULE_createTableClauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1387);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CLUSTERED || _la==COMMENT || ((((_la - 138)) & ~0x3f) == 0 && ((1L << (_la - 138)) & ((1L << (LOCATION - 138)) | (1L << (OPTIONS - 138)) | (1L << (PARTITIONED - 138)))) != 0) || _la==TBLPROPERTIES) {
{
setState(1385);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPTIONS:
{
{
setState(1375);
match(OPTIONS);
setState(1376);
((CreateTableClausesContext)_localctx).options = tablePropertyList();
}
}
break;
case PARTITIONED:
{
{
setState(1377);
match(PARTITIONED);
setState(1378);
match(BY);
setState(1379);
((CreateTableClausesContext)_localctx).partitioning = transformList();
}
}
break;
case CLUSTERED:
{
setState(1380);
bucketSpec();
}
break;
case LOCATION:
{
setState(1381);
locationSpec();
}
break;
case COMMENT:
{
setState(1382);
commentSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(1383);
match(TBLPROPERTIES);
setState(1384);
((CreateTableClausesContext)_localctx).tableProps = tablePropertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1389);
_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 List tableProperty() {
return getRuleContexts(TablePropertyContext.class);
}
public TablePropertyContext tableProperty(int i) {
return getRuleContext(TablePropertyContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterTablePropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTablePropertyList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTablePropertyList(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyListContext tablePropertyList() throws RecognitionException {
TablePropertyListContext _localctx = new TablePropertyListContext(_ctx, getState());
enterRule(_localctx, 54, RULE_tablePropertyList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1390);
match(T__1);
setState(1391);
tableProperty();
setState(1396);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1392);
match(T__3);
setState(1393);
tableProperty();
}
}
setState(1398);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1399);
match(T__2);
}
}
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterTableProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTableProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTableProperty(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyContext tableProperty() throws RecognitionException {
TablePropertyContext _localctx = new TablePropertyContext(_ctx, getState());
enterRule(_localctx, 56, RULE_tableProperty);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1401);
((TablePropertyContext)_localctx).key = tablePropertyKey();
setState(1406);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FALSE || ((((_la - 241)) & ~0x3f) == 0 && ((1L << (_la - 241)) & ((1L << (TRUE - 241)) | (1L << (EQ - 241)) | (1L << (STRING - 241)) | (1L << (INTEGER_VALUE - 241)) | (1L << (DECIMAL_VALUE - 241)))) != 0)) {
{
setState(1403);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1402);
match(EQ);
}
}
setState(1405);
((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 TerminalNode STRING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterTablePropertyKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTablePropertyKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTablePropertyKey(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyKeyContext tablePropertyKey() throws RecognitionException {
TablePropertyKeyContext _localctx = new TablePropertyKeyContext(_ctx, getState());
enterRule(_localctx, 58, RULE_tablePropertyKey);
int _la;
try {
setState(1417);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1408);
identifier();
setState(1413);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(1409);
match(T__4);
setState(1410);
identifier();
}
}
setState(1415);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1416);
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(SqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode DECIMAL_VALUE() { return getToken(SqlBaseParser.DECIMAL_VALUE, 0); }
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public TerminalNode STRING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterTablePropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTablePropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTablePropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final TablePropertyValueContext tablePropertyValue() throws RecognitionException {
TablePropertyValueContext _localctx = new TablePropertyValueContext(_ctx, getState());
enterRule(_localctx, 60, RULE_tablePropertyValue);
try {
setState(1423);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(1419);
match(INTEGER_VALUE);
}
break;
case DECIMAL_VALUE:
enterOuterAlt(_localctx, 2);
{
setState(1420);
match(DECIMAL_VALUE);
}
break;
case FALSE:
case TRUE:
enterOuterAlt(_localctx, 3);
{
setState(1421);
booleanValue();
}
break;
case STRING:
enterOuterAlt(_localctx, 4);
{
setState(1422);
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 List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitConstantList(this);
else return visitor.visitChildren(this);
}
}
public final ConstantListContext constantList() throws RecognitionException {
ConstantListContext _localctx = new ConstantListContext(_ctx, getState());
enterRule(_localctx, 62, RULE_constantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1425);
match(T__1);
setState(1426);
constant();
setState(1431);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1427);
match(T__3);
setState(1428);
constant();
}
}
setState(1433);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1434);
match(T__2);
}
}
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 List constantList() {
return getRuleContexts(ConstantListContext.class);
}
public ConstantListContext constantList(int i) {
return getRuleContext(ConstantListContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterNestedConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNestedConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNestedConstantList(this);
else return visitor.visitChildren(this);
}
}
public final NestedConstantListContext nestedConstantList() throws RecognitionException {
NestedConstantListContext _localctx = new NestedConstantListContext(_ctx, getState());
enterRule(_localctx, 64, RULE_nestedConstantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1436);
match(T__1);
setState(1437);
constantList();
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1438);
match(T__3);
setState(1439);
constantList();
}
}
setState(1444);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1445);
match(T__2);
}
}
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(SqlBaseParser.STORED, 0); }
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public FileFormatContext fileFormat() {
return getRuleContext(FileFormatContext.class,0);
}
public TerminalNode BY() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterCreateFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCreateFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCreateFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final CreateFileFormatContext createFileFormat() throws RecognitionException {
CreateFileFormatContext _localctx = new CreateFileFormatContext(_ctx, getState());
enterRule(_localctx, 66, RULE_createFileFormat);
try {
setState(1453);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1447);
match(STORED);
setState(1448);
match(AS);
setState(1449);
fileFormat();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1450);
match(STORED);
setState(1451);
match(BY);
setState(1452);
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(SqlBaseParser.INPUTFORMAT, 0); }
public TerminalNode OUTPUTFORMAT() { return getToken(SqlBaseParser.OUTPUTFORMAT, 0); }
public List STRING() { return getTokens(SqlBaseParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(SqlBaseParser.STRING, i);
}
public TableFileFormatContext(FileFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterTableFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTableFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterGenericFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitGenericFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitGenericFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final FileFormatContext fileFormat() throws RecognitionException {
FileFormatContext _localctx = new FileFormatContext(_ctx, getState());
enterRule(_localctx, 68, RULE_fileFormat);
try {
setState(1460);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
_localctx = new TableFileFormatContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1455);
match(INPUTFORMAT);
setState(1456);
((TableFileFormatContext)_localctx).inFmt = match(STRING);
setState(1457);
match(OUTPUTFORMAT);
setState(1458);
((TableFileFormatContext)_localctx).outFmt = match(STRING);
}
break;
case 2:
_localctx = new GenericFileFormatContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1459);
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(SqlBaseParser.STRING, 0); }
public TerminalNode WITH() { return getToken(SqlBaseParser.WITH, 0); }
public TerminalNode SERDEPROPERTIES() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterStorageHandler(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitStorageHandler(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitStorageHandler(this);
else return visitor.visitChildren(this);
}
}
public final StorageHandlerContext storageHandler() throws RecognitionException {
StorageHandlerContext _localctx = new StorageHandlerContext(_ctx, getState());
enterRule(_localctx, 70, RULE_storageHandler);
try {
enterOuterAlt(_localctx, 1);
{
setState(1462);
match(STRING);
setState(1466);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1463);
match(WITH);
setState(1464);
match(SERDEPROPERTIES);
setState(1465);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitResource(this);
else return visitor.visitChildren(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 72, RULE_resource);
try {
enterOuterAlt(_localctx, 1);
{
setState(1468);
identifier();
setState(1469);
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(SqlBaseParser.DELETE, 0); }
public TerminalNode FROM() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterDeleteFromTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDeleteFromTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterSingleInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterMultiInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitMultiInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitMultiInsertQuery(this);
else return visitor.visitChildren(this);
}
}
public static class UpdateTableContext extends DmlStatementNoWithContext {
public TerminalNode UPDATE() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterUpdateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUpdateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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(SqlBaseParser.MERGE, 0); }
public TerminalNode INTO() { return getToken(SqlBaseParser.INTO, 0); }
public TerminalNode USING() { return getToken(SqlBaseParser.USING, 0); }
public TerminalNode ON() { return getToken(SqlBaseParser.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 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 SqlBaseListener ) ((SqlBaseListener)listener).enterMergeIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitMergeIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitMergeIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final DmlStatementNoWithContext dmlStatementNoWith() throws RecognitionException {
DmlStatementNoWithContext _localctx = new DmlStatementNoWithContext(_ctx, getState());
enterRule(_localctx, 74, RULE_dmlStatementNoWith);
int _la;
try {
int _alt;
setState(1522);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INSERT:
_localctx = new SingleInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1471);
insertInto();
setState(1472);
queryTerm(0);
setState(1473);
queryOrganization();
}
break;
case FROM:
_localctx = new MultiInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1475);
fromClause();
setState(1477);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1476);
multiInsertQueryBody();
}
}
setState(1479);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
}
break;
case DELETE:
_localctx = new DeleteFromTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1481);
match(DELETE);
setState(1482);
match(FROM);
setState(1483);
multipartIdentifier();
setState(1484);
tableAlias();
setState(1486);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1485);
whereClause();
}
}
}
break;
case UPDATE:
_localctx = new UpdateTableContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1488);
match(UPDATE);
setState(1489);
multipartIdentifier();
setState(1490);
tableAlias();
setState(1491);
setClause();
setState(1493);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1492);
whereClause();
}
}
}
break;
case MERGE:
_localctx = new MergeIntoTableContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1495);
match(MERGE);
setState(1496);
match(INTO);
setState(1497);
((MergeIntoTableContext)_localctx).target = multipartIdentifier();
setState(1498);
((MergeIntoTableContext)_localctx).targetAlias = tableAlias();
setState(1499);
match(USING);
setState(1505);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
{
setState(1500);
((MergeIntoTableContext)_localctx).source = multipartIdentifier();
}
break;
case 2:
{
setState(1501);
match(T__1);
setState(1502);
((MergeIntoTableContext)_localctx).sourceQuery = query();
setState(1503);
match(T__2);
}
break;
}
setState(1507);
((MergeIntoTableContext)_localctx).sourceAlias = tableAlias();
setState(1508);
match(ON);
setState(1509);
((MergeIntoTableContext)_localctx).mergeCondition = booleanExpression(0);
setState(1513);
_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(1510);
matchedClause();
}
}
}
setState(1515);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,165,_ctx);
}
setState(1519);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WHEN) {
{
{
setState(1516);
notMatchedClause();
}
}
setState(1521);
_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(SqlBaseParser.ORDER, 0); }
public List BY() { return getTokens(SqlBaseParser.BY); }
public TerminalNode BY(int i) {
return getToken(SqlBaseParser.BY, i);
}
public TerminalNode CLUSTER() { return getToken(SqlBaseParser.CLUSTER, 0); }
public TerminalNode DISTRIBUTE() { return getToken(SqlBaseParser.DISTRIBUTE, 0); }
public TerminalNode SORT() { return getToken(SqlBaseParser.SORT, 0); }
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public TerminalNode LIMIT() { return getToken(SqlBaseParser.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(SqlBaseParser.ALL, 0); }
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 SqlBaseListener ) ((SqlBaseListener)listener).enterQueryOrganization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQueryOrganization(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitQueryOrganization(this);
else return visitor.visitChildren(this);
}
}
public final QueryOrganizationContext queryOrganization() throws RecognitionException {
QueryOrganizationContext _localctx = new QueryOrganizationContext(_ctx, getState());
enterRule(_localctx, 76, RULE_queryOrganization);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1534);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(1524);
match(ORDER);
setState(1525);
match(BY);
setState(1526);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
setState(1531);
_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(1527);
match(T__3);
setState(1528);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(1533);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
}
}
break;
}
setState(1546);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
{
setState(1536);
match(CLUSTER);
setState(1537);
match(BY);
setState(1538);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
setState(1543);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1539);
match(T__3);
setState(1540);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(1545);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
}
}
break;
}
setState(1558);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
case 1:
{
setState(1548);
match(DISTRIBUTE);
setState(1549);
match(BY);
setState(1550);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
setState(1555);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1551);
match(T__3);
setState(1552);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(1557);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
}
}
break;
}
setState(1570);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
{
setState(1560);
match(SORT);
setState(1561);
match(BY);
setState(1562);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
setState(1567);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,174,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1563);
match(T__3);
setState(1564);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(1569);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,174,_ctx);
}
}
break;
}
setState(1573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(1572);
windowClause();
}
break;
}
setState(1580);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1575);
match(LIMIT);
setState(1578);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
{
setState(1576);
match(ALL);
}
break;
case 2:
{
setState(1577);
((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 SqlBaseListener ) ((SqlBaseListener)listener).enterMultiInsertQueryBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitMultiInsertQueryBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitMultiInsertQueryBody(this);
else return visitor.visitChildren(this);
}
}
public final MultiInsertQueryBodyContext multiInsertQueryBody() throws RecognitionException {
MultiInsertQueryBodyContext _localctx = new MultiInsertQueryBodyContext(_ctx, getState());
enterRule(_localctx, 78, RULE_multiInsertQueryBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(1582);
insertInto();
setState(1583);
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 SqlBaseListener ) ((SqlBaseListener)listener).enterQueryTermDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQueryTermDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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(SqlBaseParser.INTERSECT, 0); }
public TerminalNode UNION() { return getToken(SqlBaseParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(SqlBaseParser.EXCEPT, 0); }
public TerminalNode SETMINUS() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSetOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetOperation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 = 80;
enterRecursionRule(_localctx, 80, RULE_queryTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new QueryTermDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1586);
queryPrimary();
}
_ctx.stop = _input.LT(-1);
setState(1611);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,183,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1609);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(1588);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1589);
if (!(legacy_setops_precedence_enbled)) throw new FailedPredicateException(this, "legacy_setops_precedence_enbled");
setState(1590);
((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(1592);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1591);
setQuantifier();
}
}
setState(1594);
((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(1595);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1596);
if (!(!legacy_setops_precedence_enbled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enbled");
setState(1597);
((SetOperationContext)_localctx).operator = match(INTERSECT);
setState(1599);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1598);
setQuantifier();
}
}
setState(1601);
((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(1602);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1603);
if (!(!legacy_setops_precedence_enbled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enbled");
setState(1604);
((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(1606);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1605);
setQuantifier();
}
}
setState(1608);
((SetOperationContext)_localctx).right = queryTerm(2);
}
break;
}
}
}
setState(1613);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,183,_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 QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public SubqueryContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterQueryPrimaryDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQueryPrimaryDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterInlineTableDefault1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInlineTableDefault1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 SqlBaseListener ) ((SqlBaseListener)listener).enterFromStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFromStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFromStmt(this);
else return visitor.visitChildren(this);
}
}
public static class TableContext extends QueryPrimaryContext {
public TerminalNode TABLE() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTable(this);
else return visitor.visitChildren(this);
}
}
public final QueryPrimaryContext queryPrimary() throws RecognitionException {
QueryPrimaryContext _localctx = new QueryPrimaryContext(_ctx, getState());
enterRule(_localctx, 82, RULE_queryPrimary);
try {
setState(1623);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MAP:
case REDUCE:
case SELECT:
_localctx = new QueryPrimaryDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1614);
querySpecification();
}
break;
case FROM:
_localctx = new FromStmtContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1615);
fromStatement();
}
break;
case TABLE:
_localctx = new TableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1616);
match(TABLE);
setState(1617);
multipartIdentifier();
}
break;
case VALUES:
_localctx = new InlineTableDefault1Context(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1618);
inlineTable();
}
break;
case T__1:
_localctx = new SubqueryContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1619);
match(T__1);
setState(1620);
query();
setState(1621);
match(T__2);
}
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(SqlBaseParser.NULLS, 0); }
public TerminalNode ASC() { return getToken(SqlBaseParser.ASC, 0); }
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode LAST() { return getToken(SqlBaseParser.LAST, 0); }
public TerminalNode FIRST() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSortItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSortItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSortItem(this);
else return visitor.visitChildren(this);
}
}
public final SortItemContext sortItem() throws RecognitionException {
SortItemContext _localctx = new SortItemContext(_ctx, getState());
enterRule(_localctx, 84, RULE_sortItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1625);
expression();
setState(1627);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
{
setState(1626);
((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(1631);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(1629);
match(NULLS);
setState(1630);
((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 SqlBaseListener ) ((SqlBaseListener)listener).enterFromStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFromStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFromStatement(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementContext fromStatement() throws RecognitionException {
FromStatementContext _localctx = new FromStatementContext(_ctx, getState());
enterRule(_localctx, 86, RULE_fromStatement);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1633);
fromClause();
setState(1635);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1634);
fromStatementBody();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1637);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,187,_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 SqlBaseListener ) ((SqlBaseListener)listener).enterFromStatementBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFromStatementBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFromStatementBody(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementBodyContext fromStatementBody() throws RecognitionException {
FromStatementBodyContext _localctx = new FromStatementBodyContext(_ctx, getState());
enterRule(_localctx, 88, RULE_fromStatementBody);
try {
int _alt;
setState(1666);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1639);
transformClause();
setState(1641);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
{
setState(1640);
whereClause();
}
break;
}
setState(1643);
queryOrganization();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1645);
selectClause();
setState(1649);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,189,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1646);
lateralView();
}
}
}
setState(1651);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,189,_ctx);
}
setState(1653);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(1652);
whereClause();
}
break;
}
setState(1656);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(1655);
aggregationClause();
}
break;
}
setState(1659);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1658);
havingClause();
}
break;
}
setState(1662);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1661);
windowClause();
}
break;
}
setState(1664);
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 SqlBaseListener ) ((SqlBaseListener)listener).enterRegularQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitRegularQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)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 WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TransformQuerySpecificationContext(QuerySpecificationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterTransformQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTransformQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTransformQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 90, RULE_querySpecification);
try {
int _alt;
setState(1697);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
_localctx = new TransformQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1668);
transformClause();
setState(1670);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
{
setState(1669);
fromClause();
}
break;
}
setState(1673);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
case 1:
{
setState(1672);
whereClause();
}
break;
}
}
break;
case 2:
_localctx = new RegularQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1675);
selectClause();
setState(1677);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) {
case 1:
{
setState(1676);
fromClause();
}
break;
}
setState(1682);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,198,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1679);
lateralView();
}
}
}
setState(1684);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,198,_ctx);
}
setState(1686);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
case 1:
{
setState(1685);
whereClause();
}
break;
}
setState(1689);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
setState(1688);
aggregationClause();
}
break;
}
setState(1692);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
{
setState(1691);
havingClause();
}
break;
}
setState(1695);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
setState(1694);
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(SqlBaseParser.USING, 0); }
public List STRING() { return getTokens(SqlBaseParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(SqlBaseParser.STRING, i);
}
public TerminalNode SELECT() { return getToken(SqlBaseParser.SELECT, 0); }
public NamedExpressionSeqContext namedExpressionSeq() {
return getRuleContext(NamedExpressionSeqContext.class,0);
}
public TerminalNode TRANSFORM() { return getToken(SqlBaseParser.TRANSFORM, 0); }
public TerminalNode MAP() { return getToken(SqlBaseParser.MAP, 0); }
public TerminalNode REDUCE() { return getToken(SqlBaseParser.REDUCE, 0); }
public TerminalNode RECORDWRITER() { return getToken(SqlBaseParser.RECORDWRITER, 0); }
public TerminalNode AS() { return getToken(SqlBaseParser.AS, 0); }
public TerminalNode RECORDREADER() { return getToken(SqlBaseParser.RECORDREADER, 0); }
public List rowFormat() {
return getRuleContexts(RowFormatContext.class);
}
public RowFormatContext rowFormat(int i) {
return getRuleContext(RowFormatContext.class,i);
}
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 SqlBaseListener ) ((SqlBaseListener)listener).enterTransformClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTransformClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTransformClause(this);
else return visitor.visitChildren(this);
}
}
public final TransformClauseContext transformClause() throws RecognitionException {
TransformClauseContext _localctx = new TransformClauseContext(_ctx, getState());
enterRule(_localctx, 92, RULE_transformClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1709);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(1699);
match(SELECT);
setState(1700);
((TransformClauseContext)_localctx).kind = match(TRANSFORM);
setState(1701);
match(T__1);
setState(1702);
namedExpressionSeq();
setState(1703);
match(T__2);
}
break;
case MAP:
{
setState(1705);
((TransformClauseContext)_localctx).kind = match(MAP);
setState(1706);
namedExpressionSeq();
}
break;
case REDUCE:
{
setState(1707);
((TransformClauseContext)_localctx).kind = match(REDUCE);
setState(1708);
namedExpressionSeq();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1712);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(1711);
((TransformClauseContext)_localctx).inRowFormat = rowFormat();
}
}
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORDWRITER) {
{
setState(1714);
match(RECORDWRITER);
setState(1715);
((TransformClauseContext)_localctx).recordWriter = match(STRING);
}
}
setState(1718);
match(USING);
setState(1719);
((TransformClauseContext)_localctx).script = match(STRING);
setState(1732);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
case 1:
{
setState(1720);
match(AS);
setState(1730);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
{
setState(1721);
identifierSeq();
}
break;
case 2:
{
setState(1722);
colTypeList();
}
break;
case 3:
{
{
setState(1723);
match(T__1);
setState(1726);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
{
setState(1724);
identifierSeq();
}
break;
case 2:
{
setState(1725);
colTypeList();
}
break;
}
setState(1728);
match(T__2);
}
}
break;
}
}
break;
}
setState(1735);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
case 1:
{
setState(1734);
((TransformClauseContext)_localctx).outRowFormat = rowFormat();
}
break;
}
setState(1739);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
case 1:
{
setState(1737);
match(RECORDREADER);
setState(1738);
((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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 94, RULE_selectClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1741);
match(SELECT);
setState(1745);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1742);
((SelectClauseContext)_localctx).hint = hint();
((SelectClauseContext)_localctx).hints.add(((SelectClauseContext)_localctx).hint);
}
}
}
setState(1747);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
}
setState(1749);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
{
setState(1748);
setQuantifier();
}
break;
}
setState(1751);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterSetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetClause(this);
else return visitor.visitChildren(this);
}
}
public final SetClauseContext setClause() throws RecognitionException {
SetClauseContext _localctx = new SetClauseContext(_ctx, getState());
enterRule(_localctx, 96, RULE_setClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1753);
match(SET);
setState(1754);
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(SqlBaseParser.WHEN, 0); }
public TerminalNode MATCHED() { return getToken(SqlBaseParser.MATCHED, 0); }
public TerminalNode THEN() { return getToken(SqlBaseParser.THEN, 0); }
public MatchedActionContext matchedAction() {
return getRuleContext(MatchedActionContext.class,0);
}
public TerminalNode AND() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final MatchedClauseContext matchedClause() throws RecognitionException {
MatchedClauseContext _localctx = new MatchedClauseContext(_ctx, getState());
enterRule(_localctx, 98, RULE_matchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1756);
match(WHEN);
setState(1757);
match(MATCHED);
setState(1760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1758);
match(AND);
setState(1759);
((MatchedClauseContext)_localctx).matchedCond = booleanExpression(0);
}
}
setState(1762);
match(THEN);
setState(1763);
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(SqlBaseParser.WHEN, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public TerminalNode MATCHED() { return getToken(SqlBaseParser.MATCHED, 0); }
public TerminalNode THEN() { return getToken(SqlBaseParser.THEN, 0); }
public NotMatchedActionContext notMatchedAction() {
return getRuleContext(NotMatchedActionContext.class,0);
}
public TerminalNode AND() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterNotMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNotMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNotMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedClauseContext notMatchedClause() throws RecognitionException {
NotMatchedClauseContext _localctx = new NotMatchedClauseContext(_ctx, getState());
enterRule(_localctx, 100, RULE_notMatchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1765);
match(WHEN);
setState(1766);
match(NOT);
setState(1767);
match(MATCHED);
setState(1770);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1768);
match(AND);
setState(1769);
((NotMatchedClauseContext)_localctx).notMatchedCond = booleanExpression(0);
}
}
setState(1772);
match(THEN);
setState(1773);
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(SqlBaseParser.DELETE, 0); }
public TerminalNode UPDATE() { return getToken(SqlBaseParser.UPDATE, 0); }
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode ASTERISK() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final MatchedActionContext matchedAction() throws RecognitionException {
MatchedActionContext _localctx = new MatchedActionContext(_ctx, getState());
enterRule(_localctx, 102, RULE_matchedAction);
try {
setState(1782);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1775);
match(DELETE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1776);
match(UPDATE);
setState(1777);
match(SET);
setState(1778);
match(ASTERISK);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1779);
match(UPDATE);
setState(1780);
match(SET);
setState(1781);
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(SqlBaseParser.INSERT, 0); }
public TerminalNode ASTERISK() { return getToken(SqlBaseParser.ASTERISK, 0); }
public TerminalNode VALUES() { return getToken(SqlBaseParser.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 NotMatchedActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNotMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNotMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNotMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedActionContext notMatchedAction() throws RecognitionException {
NotMatchedActionContext _localctx = new NotMatchedActionContext(_ctx, getState());
enterRule(_localctx, 104, RULE_notMatchedAction);
int _la;
try {
setState(1802);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1784);
match(INSERT);
setState(1785);
match(ASTERISK);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1786);
match(INSERT);
setState(1787);
match(T__1);
setState(1788);
((NotMatchedActionContext)_localctx).columns = multipartIdentifierList();
setState(1789);
match(T__2);
setState(1790);
match(VALUES);
setState(1791);
match(T__1);
setState(1792);
expression();
setState(1797);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1793);
match(T__3);
setState(1794);
expression();
}
}
setState(1799);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1800);
match(T__2);
}
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 AssignmentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterAssignmentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAssignmentList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAssignmentList(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentListContext assignmentList() throws RecognitionException {
AssignmentListContext _localctx = new AssignmentListContext(_ctx, getState());
enterRule(_localctx, 106, RULE_assignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1804);
assignment();
setState(1809);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1805);
match(T__3);
setState(1806);
assignment();
}
}
setState(1811);
_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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAssignment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAssignment(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 108, RULE_assignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(1812);
((AssignmentContext)_localctx).key = multipartIdentifier();
setState(1813);
match(EQ);
setState(1814);
((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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 110, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1816);
match(WHERE);
setState(1817);
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(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitHavingClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 112, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1819);
match(HAVING);
setState(1820);
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 HintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterHint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitHint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitHint(this);
else return visitor.visitChildren(this);
}
}
public final HintContext hint() throws RecognitionException {
HintContext _localctx = new HintContext(_ctx, getState());
enterRule(_localctx, 114, RULE_hint);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1822);
match(T__5);
setState(1823);
((HintContext)_localctx).hintStatement = hintStatement();
((HintContext)_localctx).hintStatements.add(((HintContext)_localctx).hintStatement);
setState(1830);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,221,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1825);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
case 1:
{
setState(1824);
match(T__3);
}
break;
}
setState(1827);
((HintContext)_localctx).hintStatement = hintStatement();
((HintContext)_localctx).hintStatements.add(((HintContext)_localctx).hintStatement);
}
}
}
setState(1832);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,221,_ctx);
}
setState(1833);
match(T__6);
}
}
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 List primaryExpression() {
return getRuleContexts(PrimaryExpressionContext.class);
}
public PrimaryExpressionContext primaryExpression(int i) {
return getRuleContext(PrimaryExpressionContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterHintStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitHintStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitHintStatement(this);
else return visitor.visitChildren(this);
}
}
public final HintStatementContext hintStatement() throws RecognitionException {
HintStatementContext _localctx = new HintStatementContext(_ctx, getState());
enterRule(_localctx, 116, RULE_hintStatement);
int _la;
try {
setState(1848);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,223,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1835);
((HintStatementContext)_localctx).hintName = identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1836);
((HintStatementContext)_localctx).hintName = identifier();
setState(1837);
match(T__1);
setState(1838);
((HintStatementContext)_localctx).primaryExpression = primaryExpression(0);
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).primaryExpression);
setState(1843);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1839);
match(T__3);
setState(1840);
((HintStatementContext)_localctx).primaryExpression = primaryExpression(0);
((HintStatementContext)_localctx).parameters.add(((HintStatementContext)_localctx).primaryExpression);
}
}
setState(1845);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1846);
match(T__2);
}
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(SqlBaseParser.FROM, 0); }
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 118, RULE_fromClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1850);
match(FROM);
setState(1851);
relation();
setState(1856);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,224,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1852);
match(T__3);
setState(1853);
relation();
}
}
}
setState(1858);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,224,_ctx);
}
setState(1862);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,225,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1859);
lateralView();
}
}
}
setState(1864);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,225,_ctx);
}
setState(1866);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) {
case 1:
{
setState(1865);
pivotClause();
}
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 ExpressionContext expression;
public List groupingExpressions = new ArrayList();
public Token kind;
public TerminalNode GROUP() { return getToken(SqlBaseParser.GROUP, 0); }
public TerminalNode BY() { return getToken(SqlBaseParser.BY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode WITH() { return getToken(SqlBaseParser.WITH, 0); }
public TerminalNode SETS() { return getToken(SqlBaseParser.SETS, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public TerminalNode ROLLUP() { return getToken(SqlBaseParser.ROLLUP, 0); }
public TerminalNode CUBE() { return getToken(SqlBaseParser.CUBE, 0); }
public TerminalNode GROUPING() { return getToken(SqlBaseParser.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 SqlBaseListener ) ((SqlBaseListener)listener).enterAggregationClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitAggregationClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitAggregationClause(this);
else return visitor.visitChildren(this);
}
}
public final AggregationClauseContext aggregationClause() throws RecognitionException {
AggregationClauseContext _localctx = new AggregationClauseContext(_ctx, getState());
enterRule(_localctx, 120, RULE_aggregationClause);
int _la;
try {
int _alt;
setState(1912);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1868);
match(GROUP);
setState(1869);
match(BY);
setState(1870);
((AggregationClauseContext)_localctx).expression = expression();
((AggregationClauseContext)_localctx).groupingExpressions.add(((AggregationClauseContext)_localctx).expression);
setState(1875);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,227,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1871);
match(T__3);
setState(1872);
((AggregationClauseContext)_localctx).expression = expression();
((AggregationClauseContext)_localctx).groupingExpressions.add(((AggregationClauseContext)_localctx).expression);
}
}
}
setState(1877);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,227,_ctx);
}
setState(1895);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
case 1:
{
setState(1878);
match(WITH);
setState(1879);
((AggregationClauseContext)_localctx).kind = match(ROLLUP);
}
break;
case 2:
{
setState(1880);
match(WITH);
setState(1881);
((AggregationClauseContext)_localctx).kind = match(CUBE);
}
break;
case 3:
{
setState(1882);
((AggregationClauseContext)_localctx).kind = match(GROUPING);
setState(1883);
match(SETS);
setState(1884);
match(T__1);
setState(1885);
groupingSet();
setState(1890);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1886);
match(T__3);
setState(1887);
groupingSet();
}
}
setState(1892);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1893);
match(T__2);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1897);
match(GROUP);
setState(1898);
match(BY);
setState(1899);
((AggregationClauseContext)_localctx).kind = match(GROUPING);
setState(1900);
match(SETS);
setState(1901);
match(T__1);
setState(1902);
groupingSet();
setState(1907);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1903);
match(T__3);
setState(1904);
groupingSet();
}
}
setState(1909);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1910);
match(T__2);
}
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 List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,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 SqlBaseListener ) ((SqlBaseListener)listener).enterGroupingSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitGroupingSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitGroupingSet(this);
else return visitor.visitChildren(this);
}
}
public final GroupingSetContext groupingSet() throws RecognitionException {
GroupingSetContext _localctx = new GroupingSetContext(_ctx, getState());
enterRule(_localctx, 122, RULE_groupingSet);
int _la;
try {
setState(1927);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1914);
match(T__1);
setState(1923);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
case 1:
{
setState(1915);
expression();
setState(1920);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1916);
match(T__3);
setState(1917);
expression();
}
}
setState(1922);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1925);
match(T__2);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1926);
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(SqlBaseParser.PIVOT, 0); }
public TerminalNode FOR() { return getToken(SqlBaseParser.FOR, 0); }
public PivotColumnContext pivotColumn() {
return getRuleContext(PivotColumnContext.class,0);
}
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
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 PivotClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pivotClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPivotClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPivotClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPivotClause(this);
else return visitor.visitChildren(this);
}
}
public final PivotClauseContext pivotClause() throws RecognitionException {
PivotClauseContext _localctx = new PivotClauseContext(_ctx, getState());
enterRule(_localctx, 124, RULE_pivotClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1929);
match(PIVOT);
setState(1930);
match(T__1);
setState(1931);
((PivotClauseContext)_localctx).aggregates = namedExpressionSeq();
setState(1932);
match(FOR);
setState(1933);
pivotColumn();
setState(1934);
match(IN);
setState(1935);
match(T__1);
setState(1936);
((PivotClauseContext)_localctx).pivotValue = pivotValue();
((PivotClauseContext)_localctx).pivotValues.add(((PivotClauseContext)_localctx).pivotValue);
setState(1941);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__3) {
{
{
setState(1937);
match(T__3);
setState(1938);
((PivotClauseContext)_localctx).pivotValue = pivotValue();
((PivotClauseContext)_localctx).pivotValues.add(((PivotClauseContext)_localctx).pivotValue);
}
}
setState(1943);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1944);
match(T__2);
setState(1945);
match(T__2);
}
}
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 PivotColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pivotColumn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPivotColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPivotColumn(this);
}
@Override
public 