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/SqlBaseParser.g4 by ANTLR 4.9.3
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.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
SEMICOLON=1, LEFT_PAREN=2, RIGHT_PAREN=3, COMMA=4, DOT=5, LEFT_BRACKET=6,
RIGHT_BRACKET=7, ADD=8, AFTER=9, ALL=10, ALTER=11, ALWAYS=12, ANALYZE=13,
AND=14, ANTI=15, ANY=16, ANY_VALUE=17, ARCHIVE=18, ARRAY=19, AS=20, ASC=21,
AT=22, AUTHORIZATION=23, BETWEEN=24, BOTH=25, BUCKET=26, BUCKETS=27, BY=28,
CACHE=29, CASCADE=30, CASE=31, CAST=32, CATALOG=33, CATALOGS=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, DAY=61, DAYS=62, DAYOFYEAR=63, DATA=64, DATABASE=65,
DATABASES=66, DATEADD=67, DATEDIFF=68, DBPROPERTIES=69, DEFAULT=70, DEFINED=71,
DELETE=72, DELIMITED=73, DESC=74, DESCRIBE=75, DFS=76, DIRECTORIES=77,
DIRECTORY=78, DISTINCT=79, DISTRIBUTE=80, DIV=81, DROP=82, ELSE=83, END=84,
ESCAPE=85, ESCAPED=86, EXCEPT=87, EXCHANGE=88, EXCLUDE=89, EXISTS=90,
EXPLAIN=91, EXPORT=92, EXTENDED=93, EXTERNAL=94, EXTRACT=95, FALSE=96,
FETCH=97, FIELDS=98, FILTER=99, FILEFORMAT=100, FIRST=101, FOLLOWING=102,
FOR=103, FOREIGN=104, FORMAT=105, FORMATTED=106, FROM=107, FULL=108, FUNCTION=109,
FUNCTIONS=110, GENERATED=111, GLOBAL=112, GRANT=113, GROUP=114, GROUPING=115,
HAVING=116, HOUR=117, HOURS=118, IF=119, IGNORE=120, IMPORT=121, IN=122,
INCLUDE=123, INDEX=124, INDEXES=125, INNER=126, INPATH=127, INPUTFORMAT=128,
INSERT=129, INTERSECT=130, INTERVAL=131, INTO=132, IS=133, ITEMS=134,
JOIN=135, KEYS=136, LAST=137, LATERAL=138, LAZY=139, LEADING=140, LEFT=141,
LIKE=142, ILIKE=143, LIMIT=144, LINES=145, LIST=146, LOAD=147, LOCAL=148,
LOCATION=149, LOCK=150, LOCKS=151, LOGICAL=152, MACRO=153, MAP=154, MATCHED=155,
MERGE=156, MICROSECOND=157, MICROSECONDS=158, MILLISECOND=159, MILLISECONDS=160,
MINUTE=161, MINUTES=162, MONTH=163, MONTHS=164, MSCK=165, NAMESPACE=166,
NAMESPACES=167, NANOSECOND=168, NANOSECONDS=169, NATURAL=170, NO=171,
NOT=172, NULL=173, NULLS=174, OF=175, OFFSET=176, ON=177, ONLY=178, OPTION=179,
OPTIONS=180, OR=181, ORDER=182, OUT=183, OUTER=184, OUTPUTFORMAT=185,
OVER=186, OVERLAPS=187, OVERLAY=188, OVERWRITE=189, PARTITION=190, PARTITIONED=191,
PARTITIONS=192, PERCENTILE_CONT=193, PERCENTILE_DISC=194, PERCENTLIT=195,
PIVOT=196, PLACING=197, POSITION=198, PRECEDING=199, PRIMARY=200, PRINCIPALS=201,
PROPERTIES=202, PURGE=203, QUARTER=204, QUERY=205, RANGE=206, RECORDREADER=207,
RECORDWRITER=208, RECOVER=209, REDUCE=210, REFERENCES=211, REFRESH=212,
RENAME=213, REPAIR=214, REPEATABLE=215, REPLACE=216, RESET=217, RESPECT=218,
RESTRICT=219, REVOKE=220, RIGHT=221, RLIKE=222, ROLE=223, ROLES=224, ROLLBACK=225,
ROLLUP=226, ROW=227, ROWS=228, SECOND=229, SECONDS=230, SCHEMA=231, SCHEMAS=232,
SELECT=233, SEMI=234, SEPARATED=235, SERDE=236, SERDEPROPERTIES=237, SESSION_USER=238,
SET=239, SETMINUS=240, SETS=241, SHOW=242, SKEWED=243, SOME=244, SORT=245,
SORTED=246, SOURCE=247, START=248, STATISTICS=249, STORED=250, STRATIFY=251,
STRUCT=252, SUBSTR=253, SUBSTRING=254, SYNC=255, SYSTEM_TIME=256, SYSTEM_VERSION=257,
TABLE=258, TABLES=259, TABLESAMPLE=260, TARGET=261, TBLPROPERTIES=262,
TEMPORARY=263, TERMINATED=264, THEN=265, TIME=266, TIMESTAMP=267, TIMESTAMPADD=268,
TIMESTAMPDIFF=269, TO=270, TOUCH=271, TRAILING=272, TRANSACTION=273, TRANSACTIONS=274,
TRANSFORM=275, TRIM=276, TRUE=277, TRUNCATE=278, TRY_CAST=279, TYPE=280,
UNARCHIVE=281, UNBOUNDED=282, UNCACHE=283, UNION=284, UNIQUE=285, UNKNOWN=286,
UNLOCK=287, UNPIVOT=288, UNSET=289, UPDATE=290, USE=291, USER=292, USING=293,
VALUES=294, VERSION=295, VIEW=296, VIEWS=297, WEEK=298, WEEKS=299, WHEN=300,
WHERE=301, WINDOW=302, WITH=303, WITHIN=304, YEAR=305, YEARS=306, ZONE=307,
EQ=308, NSEQ=309, NEQ=310, NEQJ=311, LT=312, LTE=313, GT=314, GTE=315,
PLUS=316, MINUS=317, ASTERISK=318, SLASH=319, PERCENT=320, TILDE=321,
AMPERSAND=322, PIPE=323, CONCAT_PIPE=324, HAT=325, COLON=326, ARROW=327,
HENT_START=328, HENT_END=329, STRING=330, DOUBLEQUOTED_STRING=331, BIGINT_LITERAL=332,
SMALLINT_LITERAL=333, TINYINT_LITERAL=334, INTEGER_VALUE=335, EXPONENT_VALUE=336,
DECIMAL_VALUE=337, FLOAT_LITERAL=338, DOUBLE_LITERAL=339, BIGDECIMAL_LITERAL=340,
IDENTIFIER=341, BACKQUOTED_IDENTIFIER=342, SIMPLE_COMMENT=343, BRACKETED_COMMENT=344,
WS=345, UNRECOGNIZED=346;
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_timezone = 8, RULE_configKey = 9, RULE_configValue = 10, RULE_unsupportedHiveNativeCommands = 11,
RULE_createTableHeader = 12, RULE_replaceTableHeader = 13, RULE_bucketSpec = 14,
RULE_skewSpec = 15, RULE_locationSpec = 16, RULE_commentSpec = 17, RULE_query = 18,
RULE_insertInto = 19, RULE_partitionSpecLocation = 20, RULE_partitionSpec = 21,
RULE_partitionVal = 22, RULE_namespace = 23, RULE_namespaces = 24, RULE_describeFuncName = 25,
RULE_describeColName = 26, RULE_ctes = 27, RULE_namedQuery = 28, RULE_tableProvider = 29,
RULE_createTableClauses = 30, RULE_propertyList = 31, RULE_property = 32,
RULE_propertyKey = 33, RULE_propertyValue = 34, RULE_constantList = 35,
RULE_nestedConstantList = 36, RULE_createFileFormat = 37, RULE_fileFormat = 38,
RULE_storageHandler = 39, RULE_resource = 40, RULE_dmlStatementNoWith = 41,
RULE_queryOrganization = 42, RULE_multiInsertQueryBody = 43, RULE_queryTerm = 44,
RULE_queryPrimary = 45, RULE_sortItem = 46, RULE_fromStatement = 47, RULE_fromStatementBody = 48,
RULE_querySpecification = 49, RULE_transformClause = 50, RULE_selectClause = 51,
RULE_setClause = 52, RULE_matchedClause = 53, RULE_notMatchedClause = 54,
RULE_notMatchedBySourceClause = 55, RULE_matchedAction = 56, RULE_notMatchedAction = 57,
RULE_notMatchedBySourceAction = 58, RULE_assignmentList = 59, RULE_assignment = 60,
RULE_whereClause = 61, RULE_havingClause = 62, RULE_hint = 63, RULE_hintStatement = 64,
RULE_fromClause = 65, RULE_temporalClause = 66, RULE_aggregationClause = 67,
RULE_groupByClause = 68, RULE_groupingAnalytics = 69, RULE_groupingElement = 70,
RULE_groupingSet = 71, RULE_pivotClause = 72, RULE_pivotColumn = 73, RULE_pivotValue = 74,
RULE_unpivotClause = 75, RULE_unpivotNullClause = 76, RULE_unpivotOperator = 77,
RULE_unpivotSingleValueColumnClause = 78, RULE_unpivotMultiValueColumnClause = 79,
RULE_unpivotColumnSet = 80, RULE_unpivotValueColumn = 81, RULE_unpivotNameColumn = 82,
RULE_unpivotColumnAndAlias = 83, RULE_unpivotColumn = 84, RULE_unpivotAlias = 85,
RULE_lateralView = 86, RULE_setQuantifier = 87, RULE_relation = 88, RULE_relationExtension = 89,
RULE_joinRelation = 90, RULE_joinType = 91, RULE_joinCriteria = 92, RULE_sample = 93,
RULE_sampleMethod = 94, RULE_identifierList = 95, RULE_identifierSeq = 96,
RULE_orderedIdentifierList = 97, RULE_orderedIdentifier = 98, RULE_identifierCommentList = 99,
RULE_identifierComment = 100, RULE_relationPrimary = 101, RULE_inlineTable = 102,
RULE_functionTable = 103, RULE_tableAlias = 104, RULE_rowFormat = 105,
RULE_multipartIdentifierList = 106, RULE_multipartIdentifier = 107, RULE_multipartIdentifierPropertyList = 108,
RULE_multipartIdentifierProperty = 109, RULE_tableIdentifier = 110, RULE_functionIdentifier = 111,
RULE_namedExpression = 112, RULE_namedExpressionSeq = 113, RULE_partitionFieldList = 114,
RULE_partitionField = 115, RULE_transform = 116, RULE_transformArgument = 117,
RULE_expression = 118, RULE_expressionSeq = 119, RULE_booleanExpression = 120,
RULE_predicate = 121, RULE_valueExpression = 122, RULE_datetimeUnit = 123,
RULE_primaryExpression = 124, RULE_constant = 125, RULE_comparisonOperator = 126,
RULE_arithmeticOperator = 127, RULE_predicateOperator = 128, RULE_booleanValue = 129,
RULE_interval = 130, RULE_errorCapturingMultiUnitsInterval = 131, RULE_multiUnitsInterval = 132,
RULE_errorCapturingUnitToUnitInterval = 133, RULE_unitToUnitInterval = 134,
RULE_intervalValue = 135, RULE_unitInMultiUnits = 136, RULE_unitInUnitToUnit = 137,
RULE_colPosition = 138, RULE_dataType = 139, RULE_qualifiedColTypeWithPositionList = 140,
RULE_qualifiedColTypeWithPosition = 141, RULE_defaultExpression = 142,
RULE_colTypeList = 143, RULE_colType = 144, RULE_createOrReplaceTableColTypeList = 145,
RULE_createOrReplaceTableColType = 146, RULE_colDefinitionOption = 147,
RULE_generationExpression = 148, RULE_complexColTypeList = 149, RULE_complexColType = 150,
RULE_whenClause = 151, RULE_windowClause = 152, RULE_namedWindow = 153,
RULE_windowSpec = 154, RULE_windowFrame = 155, RULE_frameBound = 156,
RULE_qualifiedNameList = 157, RULE_functionName = 158, RULE_qualifiedName = 159,
RULE_errorCapturingIdentifier = 160, RULE_errorCapturingIdentifierExtra = 161,
RULE_identifier = 162, RULE_strictIdentifier = 163, RULE_quotedIdentifier = 164,
RULE_backQuotedIdentifier = 165, RULE_number = 166, RULE_alterColumnAction = 167,
RULE_stringLit = 168, RULE_comment = 169, RULE_version = 170, RULE_ansiNonReserved = 171,
RULE_strictNonReserved = 172, RULE_nonReserved = 173;
private static String[] makeRuleNames() {
return new String[] {
"singleStatement", "singleExpression", "singleTableIdentifier", "singleMultipartIdentifier",
"singleFunctionIdentifier", "singleDataType", "singleTableSchema", "statement",
"timezone", "configKey", "configValue", "unsupportedHiveNativeCommands",
"createTableHeader", "replaceTableHeader", "bucketSpec", "skewSpec",
"locationSpec", "commentSpec", "query", "insertInto", "partitionSpecLocation",
"partitionSpec", "partitionVal", "namespace", "namespaces", "describeFuncName",
"describeColName", "ctes", "namedQuery", "tableProvider", "createTableClauses",
"propertyList", "property", "propertyKey", "propertyValue", "constantList",
"nestedConstantList", "createFileFormat", "fileFormat", "storageHandler",
"resource", "dmlStatementNoWith", "queryOrganization", "multiInsertQueryBody",
"queryTerm", "queryPrimary", "sortItem", "fromStatement", "fromStatementBody",
"querySpecification", "transformClause", "selectClause", "setClause",
"matchedClause", "notMatchedClause", "notMatchedBySourceClause", "matchedAction",
"notMatchedAction", "notMatchedBySourceAction", "assignmentList", "assignment",
"whereClause", "havingClause", "hint", "hintStatement", "fromClause",
"temporalClause", "aggregationClause", "groupByClause", "groupingAnalytics",
"groupingElement", "groupingSet", "pivotClause", "pivotColumn", "pivotValue",
"unpivotClause", "unpivotNullClause", "unpivotOperator", "unpivotSingleValueColumnClause",
"unpivotMultiValueColumnClause", "unpivotColumnSet", "unpivotValueColumn",
"unpivotNameColumn", "unpivotColumnAndAlias", "unpivotColumn", "unpivotAlias",
"lateralView", "setQuantifier", "relation", "relationExtension", "joinRelation",
"joinType", "joinCriteria", "sample", "sampleMethod", "identifierList",
"identifierSeq", "orderedIdentifierList", "orderedIdentifier", "identifierCommentList",
"identifierComment", "relationPrimary", "inlineTable", "functionTable",
"tableAlias", "rowFormat", "multipartIdentifierList", "multipartIdentifier",
"multipartIdentifierPropertyList", "multipartIdentifierProperty", "tableIdentifier",
"functionIdentifier", "namedExpression", "namedExpressionSeq", "partitionFieldList",
"partitionField", "transform", "transformArgument", "expression", "expressionSeq",
"booleanExpression", "predicate", "valueExpression", "datetimeUnit",
"primaryExpression", "constant", "comparisonOperator", "arithmeticOperator",
"predicateOperator", "booleanValue", "interval", "errorCapturingMultiUnitsInterval",
"multiUnitsInterval", "errorCapturingUnitToUnitInterval", "unitToUnitInterval",
"intervalValue", "unitInMultiUnits", "unitInUnitToUnit", "colPosition",
"dataType", "qualifiedColTypeWithPositionList", "qualifiedColTypeWithPosition",
"defaultExpression", "colTypeList", "colType", "createOrReplaceTableColTypeList",
"createOrReplaceTableColType", "colDefinitionOption", "generationExpression",
"complexColTypeList", "complexColType", "whenClause", "windowClause",
"namedWindow", "windowSpec", "windowFrame", "frameBound", "qualifiedNameList",
"functionName", "qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra",
"identifier", "strictIdentifier", "quotedIdentifier", "backQuotedIdentifier",
"number", "alterColumnAction", "stringLit", "comment", "version", "ansiNonReserved",
"strictNonReserved", "nonReserved"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'ADD'", "'AFTER'",
"'ALL'", "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'AND'", "'ANTI'", "'ANY'",
"'ANY_VALUE'", "'ARCHIVE'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORIZATION'",
"'BETWEEN'", "'BOTH'", "'BUCKET'", "'BUCKETS'", "'BY'", "'CACHE'", "'CASCADE'",
"'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", "'CHANGE'", "'CHECK'",
"'CLEAR'", "'CLUSTER'", "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", "'COLLECTION'",
"'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMPACT'", "'COMPACTIONS'",
"'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'", "'COST'", "'CREATE'", "'CROSS'",
"'CUBE'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'",
"'CURRENT_USER'", "'DAY'", "'DAYS'", "'DAYOFYEAR'", "'DATA'", "'DATABASE'",
"'DATABASES'", "'DATEADD'", "'DATEDIFF'", "'DBPROPERTIES'", "'DEFAULT'",
"'DEFINED'", "'DELETE'", "'DELIMITED'", "'DESC'", "'DESCRIBE'", "'DFS'",
"'DIRECTORIES'", "'DIRECTORY'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'",
"'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'", "'EXCHANGE'",
"'EXCLUDE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'", "'EXTERNAL'",
"'EXTRACT'", "'FALSE'", "'FETCH'", "'FIELDS'", "'FILTER'", "'FILEFORMAT'",
"'FIRST'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'", "'FORMATTED'",
"'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GENERATED'", "'GLOBAL'",
"'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", "'HOUR'", "'HOURS'",
"'IF'", "'IGNORE'", "'IMPORT'", "'IN'", "'INCLUDE'", "'INDEX'", "'INDEXES'",
"'INNER'", "'INPATH'", "'INPUTFORMAT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'",
"'INTO'", "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'",
"'LAZY'", "'LEADING'", "'LEFT'", "'LIKE'", "'ILIKE'", "'LIMIT'", "'LINES'",
"'LIST'", "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'",
"'MACRO'", "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", "'MICROSECONDS'",
"'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", "'MINUTES'", "'MONTH'",
"'MONTHS'", "'MSCK'", "'NAMESPACE'", "'NAMESPACES'", "'NANOSECOND'",
"'NANOSECONDS'", "'NATURAL'", "'NO'", null, "'NULL'", "'NULLS'", "'OF'",
"'OFFSET'", "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", "'OR'", "'ORDER'",
"'OUT'", "'OUTER'", "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", "'OVERLAY'",
"'OVERWRITE'", "'PARTITION'", "'PARTITIONED'", "'PARTITIONS'", "'PERCENTILE_CONT'",
"'PERCENTILE_DISC'", "'PERCENT'", "'PIVOT'", "'PLACING'", "'POSITION'",
"'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", "'PURGE'",
"'QUARTER'", "'QUERY'", "'RANGE'", "'RECORDREADER'", "'RECORDWRITER'",
"'RECOVER'", "'REDUCE'", "'REFERENCES'", "'REFRESH'", "'RENAME'", "'REPAIR'",
"'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'", "'RESTRICT'", "'REVOKE'",
"'RIGHT'", null, "'ROLE'", "'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'",
"'ROWS'", "'SECOND'", "'SECONDS'", "'SCHEMA'", "'SCHEMAS'", "'SELECT'",
"'SEMI'", "'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", "'SESSION_USER'",
"'SET'", "'MINUS'", "'SETS'", "'SHOW'", "'SKEWED'", "'SOME'", "'SORT'",
"'SORTED'", "'SOURCE'", "'START'", "'STATISTICS'", "'STORED'", "'STRATIFY'",
"'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'SYNC'", "'SYSTEM_TIME'", "'SYSTEM_VERSION'",
"'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TARGET'", "'TBLPROPERTIES'",
null, "'TERMINATED'", "'THEN'", "'TIME'", "'TIMESTAMP'", "'TIMESTAMPADD'",
"'TIMESTAMPDIFF'", "'TO'", "'TOUCH'", "'TRAILING'", "'TRANSACTION'",
"'TRANSACTIONS'", "'TRANSFORM'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'",
"'TYPE'", "'UNARCHIVE'", "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'",
"'UNKNOWN'", "'UNLOCK'", "'UNPIVOT'", "'UNSET'", "'UPDATE'", "'USE'",
"'USER'", "'USING'", "'VALUES'", "'VERSION'", "'VIEW'", "'VIEWS'", "'WEEK'",
"'WEEKS'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'WITHIN'", "'YEAR'",
"'YEARS'", "'ZONE'", null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'",
null, "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'",
"'^'", "':'", "'->'", "'/*+'", "'*/'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "LEFT_BRACKET",
"RIGHT_BRACKET", "ADD", "AFTER", "ALL", "ALTER", "ALWAYS", "ANALYZE",
"AND", "ANTI", "ANY", "ANY_VALUE", "ARCHIVE", "ARRAY", "AS", "ASC", "AT",
"AUTHORIZATION", "BETWEEN", "BOTH", "BUCKET", "BUCKETS", "BY", "CACHE",
"CASCADE", "CASE", "CAST", "CATALOG", "CATALOGS", "CHANGE", "CHECK",
"CLEAR", "CLUSTER", "CLUSTERED", "CODEGEN", "COLLATE", "COLLECTION",
"COLUMN", "COLUMNS", "COMMENT", "COMMIT", "COMPACT", "COMPACTIONS", "COMPUTE",
"CONCATENATE", "CONSTRAINT", "COST", "CREATE", "CROSS", "CUBE", "CURRENT",
"CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER",
"DAY", "DAYS", "DAYOFYEAR", "DATA", "DATABASE", "DATABASES", "DATEADD",
"DATEDIFF", "DBPROPERTIES", "DEFAULT", "DEFINED", "DELETE", "DELIMITED",
"DESC", "DESCRIBE", "DFS", "DIRECTORIES", "DIRECTORY", "DISTINCT", "DISTRIBUTE",
"DIV", "DROP", "ELSE", "END", "ESCAPE", "ESCAPED", "EXCEPT", "EXCHANGE",
"EXCLUDE", "EXISTS", "EXPLAIN", "EXPORT", "EXTENDED", "EXTERNAL", "EXTRACT",
"FALSE", "FETCH", "FIELDS", "FILTER", "FILEFORMAT", "FIRST", "FOLLOWING",
"FOR", "FOREIGN", "FORMAT", "FORMATTED", "FROM", "FULL", "FUNCTION",
"FUNCTIONS", "GENERATED", "GLOBAL", "GRANT", "GROUP", "GROUPING", "HAVING",
"HOUR", "HOURS", "IF", "IGNORE", "IMPORT", "IN", "INCLUDE", "INDEX",
"INDEXES", "INNER", "INPATH", "INPUTFORMAT", "INSERT", "INTERSECT", "INTERVAL",
"INTO", "IS", "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL", "LAZY", "LEADING",
"LEFT", "LIKE", "ILIKE", "LIMIT", "LINES", "LIST", "LOAD", "LOCAL", "LOCATION",
"LOCK", "LOCKS", "LOGICAL", "MACRO", "MAP", "MATCHED", "MERGE", "MICROSECOND",
"MICROSECONDS", "MILLISECOND", "MILLISECONDS", "MINUTE", "MINUTES", "MONTH",
"MONTHS", "MSCK", "NAMESPACE", "NAMESPACES", "NANOSECOND", "NANOSECONDS",
"NATURAL", "NO", "NOT", "NULL", "NULLS", "OF", "OFFSET", "ON", "ONLY",
"OPTION", "OPTIONS", "OR", "ORDER", "OUT", "OUTER", "OUTPUTFORMAT", "OVER",
"OVERLAPS", "OVERLAY", "OVERWRITE", "PARTITION", "PARTITIONED", "PARTITIONS",
"PERCENTILE_CONT", "PERCENTILE_DISC", "PERCENTLIT", "PIVOT", "PLACING",
"POSITION", "PRECEDING", "PRIMARY", "PRINCIPALS", "PROPERTIES", "PURGE",
"QUARTER", "QUERY", "RANGE", "RECORDREADER", "RECORDWRITER", "RECOVER",
"REDUCE", "REFERENCES", "REFRESH", "RENAME", "REPAIR", "REPEATABLE",
"REPLACE", "RESET", "RESPECT", "RESTRICT", "REVOKE", "RIGHT", "RLIKE",
"ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROW", "ROWS", "SECOND", "SECONDS",
"SCHEMA", "SCHEMAS", "SELECT", "SEMI", "SEPARATED", "SERDE", "SERDEPROPERTIES",
"SESSION_USER", "SET", "SETMINUS", "SETS", "SHOW", "SKEWED", "SOME",
"SORT", "SORTED", "SOURCE", "START", "STATISTICS", "STORED", "STRATIFY",
"STRUCT", "SUBSTR", "SUBSTRING", "SYNC", "SYSTEM_TIME", "SYSTEM_VERSION",
"TABLE", "TABLES", "TABLESAMPLE", "TARGET", "TBLPROPERTIES", "TEMPORARY",
"TERMINATED", "THEN", "TIME", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF",
"TO", "TOUCH", "TRAILING", "TRANSACTION", "TRANSACTIONS", "TRANSFORM",
"TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "UNARCHIVE", "UNBOUNDED",
"UNCACHE", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNPIVOT", "UNSET",
"UPDATE", "USE", "USER", "USING", "VALUES", "VERSION", "VIEW", "VIEWS",
"WEEK", "WEEKS", "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", "YEAR",
"YEARS", "ZONE", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", "GT", "GTE",
"PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "TILDE", "AMPERSAND",
"PIPE", "CONCAT_PIPE", "HAT", "COLON", "ARROW", "HENT_START", "HENT_END",
"STRING", "DOUBLEQUOTED_STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL",
"TINYINT_LITERAL", "INTEGER_VALUE", "EXPONENT_VALUE", "DECIMAL_VALUE",
"FLOAT_LITERAL", "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", "IDENTIFIER",
"BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS",
"UNRECOGNIZED"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "SqlBaseParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
/**
* When false, INTERSECT is given the greater precedence over the other set
* operations (UNION, EXCEPT and MINUS) as per the SQL standard.
*/
public boolean legacy_setops_precedence_enabled = false;
/**
* When false, a literal with an exponent would be converted into
* double type rather than decimal type.
*/
public boolean legacy_exponent_literal_as_decimal_enabled = false;
/**
* When true, the behavior of keywords follows ANSI SQL standard.
*/
public boolean SQL_standard_keyword_behavior = false;
/**
* When true, double quoted literals are identifiers rather than STRINGs.
*/
public boolean double_quoted_identifiers = 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 List SEMICOLON() { return getTokens(SqlBaseParser.SEMICOLON); }
public TerminalNode SEMICOLON(int i) {
return getToken(SqlBaseParser.SEMICOLON, i);
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(348);
statement();
setState(352);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMICOLON) {
{
{
setState(349);
match(SEMICOLON);
}
}
setState(354);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(355);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(357);
namedExpression();
setState(358);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleTableIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleTableIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(360);
tableIdentifier();
setState(361);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleMultipartIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(363);
multipartIdentifier();
setState(364);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleFunctionIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleFunctionIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(366);
functionIdentifier();
setState(367);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleDataType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleDataType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(369);
dataType();
setState(370);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleTableSchema(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleTableSchema(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(372);
colTypeList();
setState(373);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterExplain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitExplain(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterResetConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitResetConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAlterViewQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAlterViewQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 UseContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public TerminalNode OPTIONS() { return getToken(SqlBaseParser.OPTIONS, 0); }
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public CreateTempViewUsingContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateTempViewUsing(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateTempViewUsing(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRenameTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRenameTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterFailNativeCommand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitFailNativeCommand(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitFailNativeCommand(this);
else return visitor.visitChildren(this);
}
}
public static class SetCatalogContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode CATALOG() { return getToken(SqlBaseParser.CATALOG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public SetCatalogContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetCatalog(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSetCatalog(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterClearCache(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitClearCache(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDropView(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTablesContext extends StatementContext {
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowTablesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowTables(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRecoverPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRecoverPartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitRecoverPartitions(this);
else return visitor.visitChildren(this);
}
}
public static class DropIndexContext extends StatementContext {
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode INDEX() { return getToken(SqlBaseParser.INDEX, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ON() { return getToken(SqlBaseParser.ON, 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 TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public DropIndexContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDropIndex(this);
else return visitor.visitChildren(this);
}
}
public static class ShowCatalogsContext extends StatementContext {
public StringLitContext pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode CATALOGS() { return getToken(SqlBaseParser.CATALOGS, 0); }
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowCatalogsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowCatalogs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowCatalogs(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowCatalogs(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 NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public ShowCurrentNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowCurrentNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowCurrentNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRenameTablePartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRenameTablePartition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitRenameTablePartition(this);
else return visitor.visitChildren(this);
}
}
public static class RepairTableContext extends StatementContext {
public Token option;
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 TerminalNode MSCK() { return getToken(SqlBaseParser.MSCK, 0); }
public TerminalNode PARTITIONS() { return getToken(SqlBaseParser.PARTITIONS, 0); }
public TerminalNode ADD() { return getToken(SqlBaseParser.ADD, 0); }
public TerminalNode DROP() { return getToken(SqlBaseParser.DROP, 0); }
public TerminalNode SYNC() { return getToken(SqlBaseParser.SYNC, 0); }
public RepairTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRepairTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRepairTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitRepairTable(this);
else return visitor.visitChildren(this);
}
}
public static class RefreshResourceContext extends StatementContext {
public TerminalNode REFRESH() { return getToken(SqlBaseParser.REFRESH, 0); }
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public RefreshResourceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRefreshResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRefreshResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowCreateTable(this);
else return visitor.visitChildren(this);
}
}
public static class ShowNamespacesContext extends StatementContext {
public StringLitContext pattern;
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public NamespacesContext namespaces() {
return getRuleContext(NamespacesContext.class,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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowNamespacesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowNamespaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowNamespaces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowColumns(this);
else return visitor.visitChildren(this);
}
}
public static class ReplaceTableContext extends StatementContext {
public ReplaceTableHeaderContext replaceTableHeader() {
return getRuleContext(ReplaceTableHeaderContext.class,0);
}
public CreateTableClausesContext createTableClauses() {
return getRuleContext(CreateTableClausesContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public CreateOrReplaceTableColTypeListContext createOrReplaceTableColTypeList() {
return getRuleContext(CreateOrReplaceTableColTypeListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 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 ReplaceTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterReplaceTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitReplaceTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitReplaceTable(this);
else return visitor.visitChildren(this);
}
}
public static class AnalyzeTablesContext extends StatementContext {
public TerminalNode ANALYZE() { return getToken(SqlBaseParser.ANALYZE, 0); }
public TerminalNode TABLES() { return getToken(SqlBaseParser.TABLES, 0); }
public TerminalNode COMPUTE() { return getToken(SqlBaseParser.COMPUTE, 0); }
public TerminalNode STATISTICS() { return getToken(SqlBaseParser.STATISTICS, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public AnalyzeTablesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAnalyzeTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAnalyzeTables(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitAnalyzeTables(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAddTablePartition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAddTablePartition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetNamespaceLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetNamespaceLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRefreshTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRefreshTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetNamespaceProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetNamespaceProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 ManageResourceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterManageResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitManageResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitManageResource(this);
else return visitor.visitChildren(this);
}
}
public static class SetQuotedConfigurationContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public ConfigKeyContext configKey() {
return getRuleContext(ConfigKeyContext.class,0);
}
public TerminalNode EQ() { return getToken(SqlBaseParser.EQ, 0); }
public ConfigValueContext configValue() {
return getRuleContext(ConfigValueContext.class,0);
}
public SetQuotedConfigurationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetQuotedConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetQuotedConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSetQuotedConfiguration(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAnalyze(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAnalyze(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitAnalyze(this);
else return visitor.visitChildren(this);
}
}
public static class CreateFunctionContext extends StatementContext {
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.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 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 List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public CreateFunctionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateFunction(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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterHiveReplaceColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitHiveReplaceColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitHiveReplaceColumns(this);
else return visitor.visitChildren(this);
}
}
public static class CommentNamespaceContext extends StatementContext {
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 CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public CommentNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCommentNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCommentNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCommentNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class ResetQuotedConfigurationContext extends StatementContext {
public TerminalNode RESET() { return getToken(SqlBaseParser.RESET, 0); }
public ConfigKeyContext configKey() {
return getRuleContext(ConfigKeyContext.class,0);
}
public ResetQuotedConfigurationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterResetQuotedConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitResetQuotedConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitResetQuotedConfiguration(this);
else return visitor.visitChildren(this);
}
}
public static class CreateTableContext extends StatementContext {
public CreateTableHeaderContext createTableHeader() {
return getRuleContext(CreateTableHeaderContext.class,0);
}
public CreateTableClausesContext createTableClauses() {
return getRuleContext(CreateTableClausesContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public CreateOrReplaceTableColTypeListContext createOrReplaceTableColTypeList() {
return getRuleContext(CreateOrReplaceTableColTypeListContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDmlStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDmlStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDmlStatement(this);
else return visitor.visitChildren(this);
}
}
public static class CreateTableLikeContext extends StatementContext {
public TableIdentifierContext target;
public TableIdentifierContext source;
public PropertyListContext 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 propertyList() {
return getRuleContexts(PropertyListContext.class);
}
public PropertyListContext propertyList(int i) {
return getRuleContext(PropertyListContext.class,i);
}
public CreateTableLikeContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateTableLike(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateTableLike(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUncacheTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUncacheTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDescribeRelation(this);
else return visitor.visitChildren(this);
}
}
public static class LoadDataContext extends StatementContext {
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterLoadData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitLoadData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowPartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowPartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRenameTableColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRenameTableColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterStatementDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitStatementDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterHiveChangeColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitHiveChangeColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitHiveChangeColumn(this);
else return visitor.visitChildren(this);
}
}
public static class SetTimeZoneContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode TIME() { return getToken(SqlBaseParser.TIME, 0); }
public TerminalNode ZONE() { return getToken(SqlBaseParser.ZONE, 0); }
public IntervalContext interval() {
return getRuleContext(IntervalContext.class,0);
}
public TimezoneContext timezone() {
return getRuleContext(TimezoneContext.class,0);
}
public SetTimeZoneContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetTimeZone(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetTimeZone(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSetTimeZone(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTruncateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTruncateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public SetTableSerDeContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetTableSerDe(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetTableSerDe(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 propertyList() {
return getRuleContexts(PropertyListContext.class);
}
public PropertyListContext propertyList(int i) {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateView(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateView(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public TerminalNode PURGE() { return getToken(SqlBaseParser.PURGE, 0); }
public DropTablePartitionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropTablePartitions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropTablePartitions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDropTablePartitions(this);
else return visitor.visitChildren(this);
}
}
public static class SetConfigurationContext extends StatementContext {
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public ConfigKeyContext configKey() {
return getRuleContext(ConfigKeyContext.class,0);
}
public TerminalNode EQ() { return getToken(SqlBaseParser.EQ, 0); }
public SetConfigurationContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetConfiguration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetConfiguration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDropTable(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTableExtendedContext extends StatementContext {
public MultipartIdentifierContext ns;
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 ShowTableExtendedContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowTableExtended(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowTableExtended(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowTableExtended(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAlterTableAlterColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAlterTableAlterColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitAlterTableAlterColumn(this);
else return visitor.visitChildren(this);
}
}
public static class RefreshFunctionContext extends StatementContext {
public TerminalNode REFRESH() { return getToken(SqlBaseParser.REFRESH, 0); }
public TerminalNode FUNCTION() { return getToken(SqlBaseParser.FUNCTION, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public RefreshFunctionContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRefreshFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRefreshFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitRefreshFunction(this);
else return visitor.visitChildren(this);
}
}
public static class CommentTableContext extends StatementContext {
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 CommentContext comment() {
return getRuleContext(CommentContext.class,0);
}
public CommentTableContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCommentTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCommentTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCommentTable(this);
else return visitor.visitChildren(this);
}
}
public static class CreateIndexContext extends StatementContext {
public IdentifierContext indexType;
public MultipartIdentifierPropertyListContext columns;
public PropertyListContext options;
public TerminalNode CREATE() { return getToken(SqlBaseParser.CREATE, 0); }
public TerminalNode INDEX() { return getToken(SqlBaseParser.INDEX, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode ON() { return getToken(SqlBaseParser.ON, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public MultipartIdentifierPropertyListContext multipartIdentifierPropertyList() {
return getRuleContext(MultipartIdentifierPropertyListContext.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 TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public TerminalNode USING() { return getToken(SqlBaseParser.USING, 0); }
public TerminalNode OPTIONS() { return getToken(SqlBaseParser.OPTIONS, 0); }
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public CreateIndexContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateIndex(this);
else return visitor.visitChildren(this);
}
}
public static class UseNamespaceContext extends StatementContext {
public TerminalNode USE() { return getToken(SqlBaseParser.USE, 0); }
public NamespaceContext namespace() {
return getRuleContext(NamespaceContext.class,0);
}
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public UseNamespaceContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUseNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUseNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitUseNamespace(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 propertyList() {
return getRuleContexts(PropertyListContext.class);
}
public PropertyListContext propertyList(int i) {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateNamespace(this);
else return visitor.visitChildren(this);
}
}
public static class ShowTblPropertiesContext extends StatementContext {
public MultipartIdentifierContext table;
public PropertyKeyContext 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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public PropertyKeyContext propertyKey() {
return getRuleContext(PropertyKeyContext.class,0);
}
public ShowTblPropertiesContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowTblProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowTblProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUnsetTableProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUnsetTableProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetTableLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetTableLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 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 TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(SqlBaseParser.EXISTS, 0); }
public DropTableColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDropTableColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDropTableColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDropTableColumns(this);
else return visitor.visitChildren(this);
}
}
public static class ShowViewsContext extends StatementContext {
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public ShowViewsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowViews(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowViews(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowViews(this);
else return visitor.visitChildren(this);
}
}
public static class ShowFunctionsContext extends StatementContext {
public MultipartIdentifierContext ns;
public MultipartIdentifierContext legacy;
public StringLitContext 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 TerminalNode FROM() { return getToken(SqlBaseParser.FROM, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public TerminalNode LIKE() { return getToken(SqlBaseParser.LIKE, 0); }
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public ShowFunctionsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterShowFunctions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitShowFunctions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitShowFunctions(this);
else return visitor.visitChildren(this);
}
}
public static class CacheTableContext extends StatementContext {
public PropertyListContext 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 PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCacheTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCacheTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public AddTableColumnsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAddTableColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAddTableColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetTableProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetTableProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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(1178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
case 1:
_localctx = new StatementDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(375);
query();
}
break;
case 2:
_localctx = new DmlStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(377);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(376);
ctes();
}
}
setState(379);
dmlStatementNoWith();
}
break;
case 3:
_localctx = new UseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(380);
match(USE);
setState(381);
multipartIdentifier();
}
break;
case 4:
_localctx = new UseNamespaceContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(382);
match(USE);
setState(383);
namespace();
setState(384);
multipartIdentifier();
}
break;
case 5:
_localctx = new SetCatalogContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(386);
match(SET);
setState(387);
match(CATALOG);
setState(390);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(388);
identifier();
}
break;
case 2:
{
setState(389);
stringLit();
}
break;
}
}
break;
case 6:
_localctx = new CreateNamespaceContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(392);
match(CREATE);
setState(393);
namespace();
setState(397);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
setState(394);
match(IF);
setState(395);
match(NOT);
setState(396);
match(EXISTS);
}
break;
}
setState(399);
multipartIdentifier();
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT || _la==LOCATION || _la==WITH) {
{
setState(405);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
{
setState(400);
commentSpec();
}
break;
case LOCATION:
{
setState(401);
locationSpec();
}
break;
case WITH:
{
{
setState(402);
match(WITH);
setState(403);
_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(404);
propertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 7:
_localctx = new SetNamespacePropertiesContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(410);
match(ALTER);
setState(411);
namespace();
setState(412);
multipartIdentifier();
setState(413);
match(SET);
setState(414);
_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(415);
propertyList();
}
break;
case 8:
_localctx = new SetNamespaceLocationContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(417);
match(ALTER);
setState(418);
namespace();
setState(419);
multipartIdentifier();
setState(420);
match(SET);
setState(421);
locationSpec();
}
break;
case 9:
_localctx = new DropNamespaceContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(423);
match(DROP);
setState(424);
namespace();
setState(427);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(425);
match(IF);
setState(426);
match(EXISTS);
}
break;
}
setState(429);
multipartIdentifier();
setState(431);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CASCADE || _la==RESTRICT) {
{
setState(430);
_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 10:
_localctx = new ShowNamespacesContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(433);
match(SHOW);
setState(434);
namespaces();
setState(437);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(435);
_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(436);
multipartIdentifier();
}
break;
}
setState(443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(440);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(439);
match(LIKE);
}
break;
}
setState(442);
((ShowNamespacesContext)_localctx).pattern = stringLit();
}
break;
}
}
break;
case 11:
_localctx = new CreateTableContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(445);
createTableHeader();
setState(450);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(446);
match(LEFT_PAREN);
setState(447);
createOrReplaceTableColTypeList();
setState(448);
match(RIGHT_PAREN);
}
break;
}
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(452);
tableProvider();
}
}
setState(455);
createTableClauses();
setState(460);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN || _la==AS || _la==FROM || _la==MAP || ((((_la - 210)) & ~0x3f) == 0 && ((1L << (_la - 210)) & ((1L << (REDUCE - 210)) | (1L << (SELECT - 210)) | (1L << (TABLE - 210)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(457);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(456);
match(AS);
}
}
setState(459);
query();
}
}
}
break;
case 12:
_localctx = new CreateTableLikeContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(462);
match(CREATE);
setState(463);
match(TABLE);
setState(467);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(464);
match(IF);
setState(465);
match(NOT);
setState(466);
match(EXISTS);
}
break;
}
setState(469);
((CreateTableLikeContext)_localctx).target = tableIdentifier();
setState(470);
match(LIKE);
setState(471);
((CreateTableLikeContext)_localctx).source = tableIdentifier();
setState(480);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOCATION || ((((_la - 227)) & ~0x3f) == 0 && ((1L << (_la - 227)) & ((1L << (ROW - 227)) | (1L << (STORED - 227)) | (1L << (TBLPROPERTIES - 227)))) != 0) || _la==USING) {
{
setState(478);
_errHandler.sync(this);
switch (_input.LA(1)) {
case USING:
{
setState(472);
tableProvider();
}
break;
case ROW:
{
setState(473);
rowFormat();
}
break;
case STORED:
{
setState(474);
createFileFormat();
}
break;
case LOCATION:
{
setState(475);
locationSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(476);
match(TBLPROPERTIES);
setState(477);
((CreateTableLikeContext)_localctx).tableProps = propertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(482);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 13:
_localctx = new ReplaceTableContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(483);
replaceTableHeader();
setState(488);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(484);
match(LEFT_PAREN);
setState(485);
createOrReplaceTableColTypeList();
setState(486);
match(RIGHT_PAREN);
}
break;
}
setState(491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(490);
tableProvider();
}
}
setState(493);
createTableClauses();
setState(498);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN || _la==AS || _la==FROM || _la==MAP || ((((_la - 210)) & ~0x3f) == 0 && ((1L << (_la - 210)) & ((1L << (REDUCE - 210)) | (1L << (SELECT - 210)) | (1L << (TABLE - 210)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(495);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(494);
match(AS);
}
}
setState(497);
query();
}
}
}
break;
case 14:
_localctx = new AnalyzeContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(500);
match(ANALYZE);
setState(501);
match(TABLE);
setState(502);
multipartIdentifier();
setState(504);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(503);
partitionSpec();
}
}
setState(506);
match(COMPUTE);
setState(507);
match(STATISTICS);
setState(515);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(508);
identifier();
}
break;
case 2:
{
setState(509);
match(FOR);
setState(510);
match(COLUMNS);
setState(511);
identifierSeq();
}
break;
case 3:
{
setState(512);
match(FOR);
setState(513);
match(ALL);
setState(514);
match(COLUMNS);
}
break;
}
}
break;
case 15:
_localctx = new AnalyzeTablesContext(_localctx);
enterOuterAlt(_localctx, 15);
{
setState(517);
match(ANALYZE);
setState(518);
match(TABLES);
setState(521);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(519);
_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(520);
multipartIdentifier();
}
}
setState(523);
match(COMPUTE);
setState(524);
match(STATISTICS);
setState(526);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(525);
identifier();
}
break;
}
}
break;
case 16:
_localctx = new AddTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 16);
{
setState(528);
match(ALTER);
setState(529);
match(TABLE);
setState(530);
multipartIdentifier();
setState(531);
match(ADD);
setState(532);
_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(533);
((AddTableColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
}
break;
case 17:
_localctx = new AddTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 17);
{
setState(535);
match(ALTER);
setState(536);
match(TABLE);
setState(537);
multipartIdentifier();
setState(538);
match(ADD);
setState(539);
_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(540);
match(LEFT_PAREN);
setState(541);
((AddTableColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
setState(542);
match(RIGHT_PAREN);
}
break;
case 18:
_localctx = new RenameTableColumnContext(_localctx);
enterOuterAlt(_localctx, 18);
{
setState(544);
match(ALTER);
setState(545);
match(TABLE);
setState(546);
((RenameTableColumnContext)_localctx).table = multipartIdentifier();
setState(547);
match(RENAME);
setState(548);
match(COLUMN);
setState(549);
((RenameTableColumnContext)_localctx).from = multipartIdentifier();
setState(550);
match(TO);
setState(551);
((RenameTableColumnContext)_localctx).to = errorCapturingIdentifier();
}
break;
case 19:
_localctx = new DropTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 19);
{
setState(553);
match(ALTER);
setState(554);
match(TABLE);
setState(555);
multipartIdentifier();
setState(556);
match(DROP);
setState(557);
_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(560);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(558);
match(IF);
setState(559);
match(EXISTS);
}
}
setState(562);
match(LEFT_PAREN);
setState(563);
((DropTableColumnsContext)_localctx).columns = multipartIdentifierList();
setState(564);
match(RIGHT_PAREN);
}
break;
case 20:
_localctx = new DropTableColumnsContext(_localctx);
enterOuterAlt(_localctx, 20);
{
setState(566);
match(ALTER);
setState(567);
match(TABLE);
setState(568);
multipartIdentifier();
setState(569);
match(DROP);
setState(570);
_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(573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(571);
match(IF);
setState(572);
match(EXISTS);
}
break;
}
setState(575);
((DropTableColumnsContext)_localctx).columns = multipartIdentifierList();
}
break;
case 21:
_localctx = new RenameTableContext(_localctx);
enterOuterAlt(_localctx, 21);
{
setState(577);
match(ALTER);
setState(578);
_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(579);
((RenameTableContext)_localctx).from = multipartIdentifier();
setState(580);
match(RENAME);
setState(581);
match(TO);
setState(582);
((RenameTableContext)_localctx).to = multipartIdentifier();
}
break;
case 22:
_localctx = new SetTablePropertiesContext(_localctx);
enterOuterAlt(_localctx, 22);
{
setState(584);
match(ALTER);
setState(585);
_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(586);
multipartIdentifier();
setState(587);
match(SET);
setState(588);
match(TBLPROPERTIES);
setState(589);
propertyList();
}
break;
case 23:
_localctx = new UnsetTablePropertiesContext(_localctx);
enterOuterAlt(_localctx, 23);
{
setState(591);
match(ALTER);
setState(592);
_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(593);
multipartIdentifier();
setState(594);
match(UNSET);
setState(595);
match(TBLPROPERTIES);
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(596);
match(IF);
setState(597);
match(EXISTS);
}
}
setState(600);
propertyList();
}
break;
case 24:
_localctx = new AlterTableAlterColumnContext(_localctx);
enterOuterAlt(_localctx, 24);
{
setState(602);
match(ALTER);
setState(603);
match(TABLE);
setState(604);
((AlterTableAlterColumnContext)_localctx).table = multipartIdentifier();
setState(605);
_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(607);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(606);
match(COLUMN);
}
break;
}
setState(609);
((AlterTableAlterColumnContext)_localctx).column = multipartIdentifier();
setState(611);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==COMMENT || _la==DROP || _la==FIRST || _la==SET || _la==TYPE) {
{
setState(610);
alterColumnAction();
}
}
}
break;
case 25:
_localctx = new HiveChangeColumnContext(_localctx);
enterOuterAlt(_localctx, 25);
{
setState(613);
match(ALTER);
setState(614);
match(TABLE);
setState(615);
((HiveChangeColumnContext)_localctx).table = multipartIdentifier();
setState(617);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(616);
partitionSpec();
}
}
setState(619);
match(CHANGE);
setState(621);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
{
setState(620);
match(COLUMN);
}
break;
}
setState(623);
((HiveChangeColumnContext)_localctx).colName = multipartIdentifier();
setState(624);
colType();
setState(626);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==FIRST) {
{
setState(625);
colPosition();
}
}
}
break;
case 26:
_localctx = new HiveReplaceColumnsContext(_localctx);
enterOuterAlt(_localctx, 26);
{
setState(628);
match(ALTER);
setState(629);
match(TABLE);
setState(630);
((HiveReplaceColumnsContext)_localctx).table = multipartIdentifier();
setState(632);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(631);
partitionSpec();
}
}
setState(634);
match(REPLACE);
setState(635);
match(COLUMNS);
setState(636);
match(LEFT_PAREN);
setState(637);
((HiveReplaceColumnsContext)_localctx).columns = qualifiedColTypeWithPositionList();
setState(638);
match(RIGHT_PAREN);
}
break;
case 27:
_localctx = new SetTableSerDeContext(_localctx);
enterOuterAlt(_localctx, 27);
{
setState(640);
match(ALTER);
setState(641);
match(TABLE);
setState(642);
multipartIdentifier();
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(643);
partitionSpec();
}
}
setState(646);
match(SET);
setState(647);
match(SERDE);
setState(648);
stringLit();
setState(652);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(649);
match(WITH);
setState(650);
match(SERDEPROPERTIES);
setState(651);
propertyList();
}
}
}
break;
case 28:
_localctx = new SetTableSerDeContext(_localctx);
enterOuterAlt(_localctx, 28);
{
setState(654);
match(ALTER);
setState(655);
match(TABLE);
setState(656);
multipartIdentifier();
setState(658);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(657);
partitionSpec();
}
}
setState(660);
match(SET);
setState(661);
match(SERDEPROPERTIES);
setState(662);
propertyList();
}
break;
case 29:
_localctx = new AddTablePartitionContext(_localctx);
enterOuterAlt(_localctx, 29);
{
setState(664);
match(ALTER);
setState(665);
_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(666);
multipartIdentifier();
setState(667);
match(ADD);
setState(671);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(668);
match(IF);
setState(669);
match(NOT);
setState(670);
match(EXISTS);
}
}
setState(674);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(673);
partitionSpecLocation();
}
}
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==PARTITION );
}
break;
case 30:
_localctx = new RenameTablePartitionContext(_localctx);
enterOuterAlt(_localctx, 30);
{
setState(678);
match(ALTER);
setState(679);
match(TABLE);
setState(680);
multipartIdentifier();
setState(681);
((RenameTablePartitionContext)_localctx).from = partitionSpec();
setState(682);
match(RENAME);
setState(683);
match(TO);
setState(684);
((RenameTablePartitionContext)_localctx).to = partitionSpec();
}
break;
case 31:
_localctx = new DropTablePartitionsContext(_localctx);
enterOuterAlt(_localctx, 31);
{
setState(686);
match(ALTER);
setState(687);
_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(688);
multipartIdentifier();
setState(689);
match(DROP);
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(690);
match(IF);
setState(691);
match(EXISTS);
}
}
setState(694);
partitionSpec();
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(695);
match(COMMA);
setState(696);
partitionSpec();
}
}
setState(701);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(703);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PURGE) {
{
setState(702);
match(PURGE);
}
}
}
break;
case 32:
_localctx = new SetTableLocationContext(_localctx);
enterOuterAlt(_localctx, 32);
{
setState(705);
match(ALTER);
setState(706);
match(TABLE);
setState(707);
multipartIdentifier();
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(708);
partitionSpec();
}
}
setState(711);
match(SET);
setState(712);
locationSpec();
}
break;
case 33:
_localctx = new RecoverPartitionsContext(_localctx);
enterOuterAlt(_localctx, 33);
{
setState(714);
match(ALTER);
setState(715);
match(TABLE);
setState(716);
multipartIdentifier();
setState(717);
match(RECOVER);
setState(718);
match(PARTITIONS);
}
break;
case 34:
_localctx = new DropTableContext(_localctx);
enterOuterAlt(_localctx, 34);
{
setState(720);
match(DROP);
setState(721);
match(TABLE);
setState(724);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(722);
match(IF);
setState(723);
match(EXISTS);
}
break;
}
setState(726);
multipartIdentifier();
setState(728);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PURGE) {
{
setState(727);
match(PURGE);
}
}
}
break;
case 35:
_localctx = new DropViewContext(_localctx);
enterOuterAlt(_localctx, 35);
{
setState(730);
match(DROP);
setState(731);
match(VIEW);
setState(734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(732);
match(IF);
setState(733);
match(EXISTS);
}
break;
}
setState(736);
multipartIdentifier();
}
break;
case 36:
_localctx = new CreateViewContext(_localctx);
enterOuterAlt(_localctx, 36);
{
setState(737);
match(CREATE);
setState(740);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(738);
match(OR);
setState(739);
match(REPLACE);
}
}
setState(746);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL || _la==TEMPORARY) {
{
setState(743);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL) {
{
setState(742);
match(GLOBAL);
}
}
setState(745);
match(TEMPORARY);
}
}
setState(748);
match(VIEW);
setState(752);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
{
setState(749);
match(IF);
setState(750);
match(NOT);
setState(751);
match(EXISTS);
}
break;
}
setState(754);
multipartIdentifier();
setState(756);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(755);
identifierCommentList();
}
}
setState(766);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMENT || _la==PARTITIONED || _la==TBLPROPERTIES) {
{
setState(764);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMENT:
{
setState(758);
commentSpec();
}
break;
case PARTITIONED:
{
{
setState(759);
match(PARTITIONED);
setState(760);
match(ON);
setState(761);
identifierList();
}
}
break;
case TBLPROPERTIES:
{
{
setState(762);
match(TBLPROPERTIES);
setState(763);
propertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(769);
match(AS);
setState(770);
query();
}
break;
case 37:
_localctx = new CreateTempViewUsingContext(_localctx);
enterOuterAlt(_localctx, 37);
{
setState(772);
match(CREATE);
setState(775);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(773);
match(OR);
setState(774);
match(REPLACE);
}
}
setState(778);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GLOBAL) {
{
setState(777);
match(GLOBAL);
}
}
setState(780);
match(TEMPORARY);
setState(781);
match(VIEW);
setState(782);
tableIdentifier();
setState(787);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(783);
match(LEFT_PAREN);
setState(784);
colTypeList();
setState(785);
match(RIGHT_PAREN);
}
}
setState(789);
tableProvider();
setState(792);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(790);
match(OPTIONS);
setState(791);
propertyList();
}
}
}
break;
case 38:
_localctx = new AlterViewQueryContext(_localctx);
enterOuterAlt(_localctx, 38);
{
setState(794);
match(ALTER);
setState(795);
match(VIEW);
setState(796);
multipartIdentifier();
setState(798);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(797);
match(AS);
}
}
setState(800);
query();
}
break;
case 39:
_localctx = new CreateFunctionContext(_localctx);
enterOuterAlt(_localctx, 39);
{
setState(802);
match(CREATE);
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(803);
match(OR);
setState(804);
match(REPLACE);
}
}
setState(808);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(807);
match(TEMPORARY);
}
}
setState(810);
match(FUNCTION);
setState(814);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
setState(811);
match(IF);
setState(812);
match(NOT);
setState(813);
match(EXISTS);
}
break;
}
setState(816);
multipartIdentifier();
setState(817);
match(AS);
setState(818);
((CreateFunctionContext)_localctx).className = stringLit();
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(819);
match(USING);
setState(820);
resource();
setState(825);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(821);
match(COMMA);
setState(822);
resource();
}
}
setState(827);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
break;
case 40:
_localctx = new DropFunctionContext(_localctx);
enterOuterAlt(_localctx, 40);
{
setState(830);
match(DROP);
setState(832);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(831);
match(TEMPORARY);
}
}
setState(834);
match(FUNCTION);
setState(837);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(835);
match(IF);
setState(836);
match(EXISTS);
}
break;
}
setState(839);
multipartIdentifier();
}
break;
case 41:
_localctx = new ExplainContext(_localctx);
enterOuterAlt(_localctx, 41);
{
setState(840);
match(EXPLAIN);
setState(842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CODEGEN || _la==COST || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (EXTENDED - 93)) | (1L << (FORMATTED - 93)) | (1L << (LOGICAL - 93)))) != 0)) {
{
setState(841);
_la = _input.LA(1);
if ( !(_la==CODEGEN || _la==COST || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (EXTENDED - 93)) | (1L << (FORMATTED - 93)) | (1L << (LOGICAL - 93)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(844);
statement();
}
break;
case 42:
_localctx = new ShowTablesContext(_localctx);
enterOuterAlt(_localctx, 42);
{
setState(845);
match(SHOW);
setState(846);
match(TABLES);
setState(849);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(847);
_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(848);
multipartIdentifier();
}
break;
}
setState(855);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(852);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(851);
match(LIKE);
}
break;
}
setState(854);
((ShowTablesContext)_localctx).pattern = stringLit();
}
break;
}
}
break;
case 43:
_localctx = new ShowTableExtendedContext(_localctx);
enterOuterAlt(_localctx, 43);
{
setState(857);
match(SHOW);
setState(858);
match(TABLE);
setState(859);
match(EXTENDED);
setState(862);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(860);
_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(861);
((ShowTableExtendedContext)_localctx).ns = multipartIdentifier();
}
}
setState(864);
match(LIKE);
setState(865);
((ShowTableExtendedContext)_localctx).pattern = stringLit();
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(866);
partitionSpec();
}
}
}
break;
case 44:
_localctx = new ShowTblPropertiesContext(_localctx);
enterOuterAlt(_localctx, 44);
{
setState(869);
match(SHOW);
setState(870);
match(TBLPROPERTIES);
setState(871);
((ShowTblPropertiesContext)_localctx).table = multipartIdentifier();
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN) {
{
setState(872);
match(LEFT_PAREN);
setState(873);
((ShowTblPropertiesContext)_localctx).key = propertyKey();
setState(874);
match(RIGHT_PAREN);
}
}
}
break;
case 45:
_localctx = new ShowColumnsContext(_localctx);
enterOuterAlt(_localctx, 45);
{
setState(878);
match(SHOW);
setState(879);
match(COLUMNS);
setState(880);
_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(881);
((ShowColumnsContext)_localctx).table = multipartIdentifier();
setState(884);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM || _la==IN) {
{
setState(882);
_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(883);
((ShowColumnsContext)_localctx).ns = multipartIdentifier();
}
}
}
break;
case 46:
_localctx = new ShowViewsContext(_localctx);
enterOuterAlt(_localctx, 46);
{
setState(886);
match(SHOW);
setState(887);
match(VIEWS);
setState(890);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(888);
_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(889);
multipartIdentifier();
}
break;
}
setState(896);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
{
setState(893);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(892);
match(LIKE);
}
break;
}
setState(895);
((ShowViewsContext)_localctx).pattern = stringLit();
}
break;
}
}
break;
case 47:
_localctx = new ShowPartitionsContext(_localctx);
enterOuterAlt(_localctx, 47);
{
setState(898);
match(SHOW);
setState(899);
match(PARTITIONS);
setState(900);
multipartIdentifier();
setState(902);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(901);
partitionSpec();
}
}
}
break;
case 48:
_localctx = new ShowFunctionsContext(_localctx);
enterOuterAlt(_localctx, 48);
{
setState(904);
match(SHOW);
setState(906);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
setState(905);
identifier();
}
break;
}
setState(908);
match(FUNCTIONS);
setState(911);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(909);
_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(910);
((ShowFunctionsContext)_localctx).ns = multipartIdentifier();
}
break;
}
setState(920);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(914);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(913);
match(LIKE);
}
break;
}
setState(918);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
{
setState(916);
((ShowFunctionsContext)_localctx).legacy = multipartIdentifier();
}
break;
case 2:
{
setState(917);
((ShowFunctionsContext)_localctx).pattern = stringLit();
}
break;
}
}
break;
}
}
break;
case 49:
_localctx = new ShowCreateTableContext(_localctx);
enterOuterAlt(_localctx, 49);
{
setState(922);
match(SHOW);
setState(923);
match(CREATE);
setState(924);
match(TABLE);
setState(925);
multipartIdentifier();
setState(928);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(926);
match(AS);
setState(927);
match(SERDE);
}
}
}
break;
case 50:
_localctx = new ShowCurrentNamespaceContext(_localctx);
enterOuterAlt(_localctx, 50);
{
setState(930);
match(SHOW);
setState(931);
match(CURRENT);
setState(932);
namespace();
}
break;
case 51:
_localctx = new ShowCatalogsContext(_localctx);
enterOuterAlt(_localctx, 51);
{
setState(933);
match(SHOW);
setState(934);
match(CATALOGS);
setState(939);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
{
setState(936);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(935);
match(LIKE);
}
break;
}
setState(938);
((ShowCatalogsContext)_localctx).pattern = stringLit();
}
break;
}
}
break;
case 52:
_localctx = new DescribeFunctionContext(_localctx);
enterOuterAlt(_localctx, 52);
{
setState(941);
_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(942);
match(FUNCTION);
setState(944);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(943);
match(EXTENDED);
}
break;
}
setState(946);
describeFuncName();
}
break;
case 53:
_localctx = new DescribeNamespaceContext(_localctx);
enterOuterAlt(_localctx, 53);
{
setState(947);
_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(948);
namespace();
setState(950);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(949);
match(EXTENDED);
}
break;
}
setState(952);
multipartIdentifier();
}
break;
case 54:
_localctx = new DescribeRelationContext(_localctx);
enterOuterAlt(_localctx, 54);
{
setState(954);
_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(956);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(955);
match(TABLE);
}
break;
}
setState(959);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(958);
((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(961);
multipartIdentifier();
setState(963);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(962);
partitionSpec();
}
break;
}
setState(966);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(965);
describeColName();
}
break;
}
}
break;
case 55:
_localctx = new DescribeQueryContext(_localctx);
enterOuterAlt(_localctx, 55);
{
setState(968);
_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(970);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUERY) {
{
setState(969);
match(QUERY);
}
}
setState(972);
query();
}
break;
case 56:
_localctx = new CommentNamespaceContext(_localctx);
enterOuterAlt(_localctx, 56);
{
setState(973);
match(COMMENT);
setState(974);
match(ON);
setState(975);
namespace();
setState(976);
multipartIdentifier();
setState(977);
match(IS);
setState(978);
comment();
}
break;
case 57:
_localctx = new CommentTableContext(_localctx);
enterOuterAlt(_localctx, 57);
{
setState(980);
match(COMMENT);
setState(981);
match(ON);
setState(982);
match(TABLE);
setState(983);
multipartIdentifier();
setState(984);
match(IS);
setState(985);
comment();
}
break;
case 58:
_localctx = new RefreshTableContext(_localctx);
enterOuterAlt(_localctx, 58);
{
setState(987);
match(REFRESH);
setState(988);
match(TABLE);
setState(989);
multipartIdentifier();
}
break;
case 59:
_localctx = new RefreshFunctionContext(_localctx);
enterOuterAlt(_localctx, 59);
{
setState(990);
match(REFRESH);
setState(991);
match(FUNCTION);
setState(992);
multipartIdentifier();
}
break;
case 60:
_localctx = new RefreshResourceContext(_localctx);
enterOuterAlt(_localctx, 60);
{
setState(993);
match(REFRESH);
setState(1001);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(994);
stringLit();
}
break;
case 2:
{
setState(998);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(995);
matchWildcard();
}
}
}
setState(1000);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
}
}
break;
}
}
break;
case 61:
_localctx = new CacheTableContext(_localctx);
enterOuterAlt(_localctx, 61);
{
setState(1003);
match(CACHE);
setState(1005);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LAZY) {
{
setState(1004);
match(LAZY);
}
}
setState(1007);
match(TABLE);
setState(1008);
multipartIdentifier();
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(1009);
match(OPTIONS);
setState(1010);
((CacheTableContext)_localctx).options = propertyList();
}
}
setState(1017);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LEFT_PAREN || _la==AS || _la==FROM || _la==MAP || ((((_la - 210)) & ~0x3f) == 0 && ((1L << (_la - 210)) & ((1L << (REDUCE - 210)) | (1L << (SELECT - 210)) | (1L << (TABLE - 210)))) != 0) || _la==VALUES || _la==WITH) {
{
setState(1014);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1013);
match(AS);
}
}
setState(1016);
query();
}
}
}
break;
case 62:
_localctx = new UncacheTableContext(_localctx);
enterOuterAlt(_localctx, 62);
{
setState(1019);
match(UNCACHE);
setState(1020);
match(TABLE);
setState(1023);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
{
setState(1021);
match(IF);
setState(1022);
match(EXISTS);
}
break;
}
setState(1025);
multipartIdentifier();
}
break;
case 63:
_localctx = new ClearCacheContext(_localctx);
enterOuterAlt(_localctx, 63);
{
setState(1026);
match(CLEAR);
setState(1027);
match(CACHE);
}
break;
case 64:
_localctx = new LoadDataContext(_localctx);
enterOuterAlt(_localctx, 64);
{
setState(1028);
match(LOAD);
setState(1029);
match(DATA);
setState(1031);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(1030);
match(LOCAL);
}
}
setState(1033);
match(INPATH);
setState(1034);
((LoadDataContext)_localctx).path = stringLit();
setState(1036);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OVERWRITE) {
{
setState(1035);
match(OVERWRITE);
}
}
setState(1038);
match(INTO);
setState(1039);
match(TABLE);
setState(1040);
multipartIdentifier();
setState(1042);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1041);
partitionSpec();
}
}
}
break;
case 65:
_localctx = new TruncateTableContext(_localctx);
enterOuterAlt(_localctx, 65);
{
setState(1044);
match(TRUNCATE);
setState(1045);
match(TABLE);
setState(1046);
multipartIdentifier();
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1047);
partitionSpec();
}
}
}
break;
case 66:
_localctx = new RepairTableContext(_localctx);
enterOuterAlt(_localctx, 66);
{
setState(1051);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MSCK) {
{
setState(1050);
match(MSCK);
}
}
setState(1053);
match(REPAIR);
setState(1054);
match(TABLE);
setState(1055);
multipartIdentifier();
setState(1058);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ADD || _la==DROP || _la==SYNC) {
{
setState(1056);
((RepairTableContext)_localctx).option = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ADD || _la==DROP || _la==SYNC) ) {
((RepairTableContext)_localctx).option = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1057);
match(PARTITIONS);
}
}
}
break;
case 67:
_localctx = new ManageResourceContext(_localctx);
enterOuterAlt(_localctx, 67);
{
setState(1060);
((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(1061);
identifier();
setState(1065);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1062);
matchWildcard();
}
}
}
setState(1067);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
}
}
break;
case 68:
_localctx = new FailNativeCommandContext(_localctx);
enterOuterAlt(_localctx, 68);
{
setState(1068);
match(SET);
setState(1069);
match(ROLE);
setState(1073);
_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(1070);
matchWildcard();
}
}
}
setState(1075);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
}
}
break;
case 69:
_localctx = new SetTimeZoneContext(_localctx);
enterOuterAlt(_localctx, 69);
{
setState(1076);
match(SET);
setState(1077);
match(TIME);
setState(1078);
match(ZONE);
setState(1079);
interval();
}
break;
case 70:
_localctx = new SetTimeZoneContext(_localctx);
enterOuterAlt(_localctx, 70);
{
setState(1080);
match(SET);
setState(1081);
match(TIME);
setState(1082);
match(ZONE);
setState(1083);
timezone();
}
break;
case 71:
_localctx = new SetTimeZoneContext(_localctx);
enterOuterAlt(_localctx, 71);
{
setState(1084);
match(SET);
setState(1085);
match(TIME);
setState(1086);
match(ZONE);
setState(1090);
_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(1087);
matchWildcard();
}
}
}
setState(1092);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,108,_ctx);
}
}
break;
case 72:
_localctx = new SetQuotedConfigurationContext(_localctx);
enterOuterAlt(_localctx, 72);
{
setState(1093);
match(SET);
setState(1094);
configKey();
setState(1095);
match(EQ);
setState(1096);
configValue();
}
break;
case 73:
_localctx = new SetConfigurationContext(_localctx);
enterOuterAlt(_localctx, 73);
{
setState(1098);
match(SET);
setState(1099);
configKey();
setState(1107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1100);
match(EQ);
setState(1104);
_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(1101);
matchWildcard();
}
}
}
setState(1106);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,109,_ctx);
}
}
}
}
break;
case 74:
_localctx = new SetQuotedConfigurationContext(_localctx);
enterOuterAlt(_localctx, 74);
{
setState(1109);
match(SET);
setState(1113);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,111,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1110);
matchWildcard();
}
}
}
setState(1115);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,111,_ctx);
}
setState(1116);
match(EQ);
setState(1117);
configValue();
}
break;
case 75:
_localctx = new SetConfigurationContext(_localctx);
enterOuterAlt(_localctx, 75);
{
setState(1118);
match(SET);
setState(1122);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1119);
matchWildcard();
}
}
}
setState(1124);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
}
}
break;
case 76:
_localctx = new ResetQuotedConfigurationContext(_localctx);
enterOuterAlt(_localctx, 76);
{
setState(1125);
match(RESET);
setState(1126);
configKey();
}
break;
case 77:
_localctx = new ResetConfigurationContext(_localctx);
enterOuterAlt(_localctx, 77);
{
setState(1127);
match(RESET);
setState(1131);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,113,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1128);
matchWildcard();
}
}
}
setState(1133);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,113,_ctx);
}
}
break;
case 78:
_localctx = new CreateIndexContext(_localctx);
enterOuterAlt(_localctx, 78);
{
setState(1134);
match(CREATE);
setState(1135);
match(INDEX);
setState(1139);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(1136);
match(IF);
setState(1137);
match(NOT);
setState(1138);
match(EXISTS);
}
break;
}
setState(1141);
identifier();
setState(1142);
match(ON);
setState(1144);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(1143);
match(TABLE);
}
break;
}
setState(1146);
multipartIdentifier();
setState(1149);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING) {
{
setState(1147);
match(USING);
setState(1148);
((CreateIndexContext)_localctx).indexType = identifier();
}
}
setState(1151);
match(LEFT_PAREN);
setState(1152);
((CreateIndexContext)_localctx).columns = multipartIdentifierPropertyList();
setState(1153);
match(RIGHT_PAREN);
setState(1156);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(1154);
match(OPTIONS);
setState(1155);
((CreateIndexContext)_localctx).options = propertyList();
}
}
}
break;
case 79:
_localctx = new DropIndexContext(_localctx);
enterOuterAlt(_localctx, 79);
{
setState(1158);
match(DROP);
setState(1159);
match(INDEX);
setState(1162);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
{
setState(1160);
match(IF);
setState(1161);
match(EXISTS);
}
break;
}
setState(1164);
identifier();
setState(1165);
match(ON);
setState(1167);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
{
setState(1166);
match(TABLE);
}
break;
}
setState(1169);
multipartIdentifier();
}
break;
case 80:
_localctx = new FailNativeCommandContext(_localctx);
enterOuterAlt(_localctx, 80);
{
setState(1171);
unsupportedHiveNativeCommands();
setState(1175);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1+1 ) {
{
{
setState(1172);
matchWildcard();
}
}
}
setState(1177);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimezoneContext extends ParserRuleContext {
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode LOCAL() { return getToken(SqlBaseParser.LOCAL, 0); }
public TimezoneContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timezone; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTimezone(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTimezone(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitTimezone(this);
else return visitor.visitChildren(this);
}
}
public final TimezoneContext timezone() throws RecognitionException {
TimezoneContext _localctx = new TimezoneContext(_ctx, getState());
enterRule(_localctx, 16, RULE_timezone);
try {
setState(1182);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1180);
stringLit();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1181);
match(LOCAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConfigKeyContext extends ParserRuleContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public ConfigKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterConfigKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitConfigKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitConfigKey(this);
else return visitor.visitChildren(this);
}
}
public final ConfigKeyContext configKey() throws RecognitionException {
ConfigKeyContext _localctx = new ConfigKeyContext(_ctx, getState());
enterRule(_localctx, 18, RULE_configKey);
try {
enterOuterAlt(_localctx, 1);
{
setState(1184);
quotedIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConfigValueContext extends ParserRuleContext {
public BackQuotedIdentifierContext backQuotedIdentifier() {
return getRuleContext(BackQuotedIdentifierContext.class,0);
}
public ConfigValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_configValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterConfigValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitConfigValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitConfigValue(this);
else return visitor.visitChildren(this);
}
}
public final ConfigValueContext configValue() throws RecognitionException {
ConfigValueContext _localctx = new ConfigValueContext(_ctx, getState());
enterRule(_localctx, 20, RULE_configValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(1186);
backQuotedIdentifier();
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUnsupportedHiveNativeCommands(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUnsupportedHiveNativeCommands(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitUnsupportedHiveNativeCommands(this);
else return visitor.visitChildren(this);
}
}
public final UnsupportedHiveNativeCommandsContext unsupportedHiveNativeCommands() throws RecognitionException {
UnsupportedHiveNativeCommandsContext _localctx = new UnsupportedHiveNativeCommandsContext(_ctx, getState());
enterRule(_localctx, 22, RULE_unsupportedHiveNativeCommands);
int _la;
try {
setState(1356);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1188);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1189);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1190);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1191);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1192);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(GRANT);
setState(1194);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1193);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1196);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(REVOKE);
setState(1198);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1197);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
}
break;
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1200);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1201);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(GRANT);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1202);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1203);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLE);
setState(1205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1204);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(GRANT);
}
break;
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1207);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1208);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(PRINCIPALS);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1209);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1210);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(ROLES);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1211);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1212);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CURRENT);
setState(1213);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ROLES);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1214);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(EXPORT);
setState(1215);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1216);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(IMPORT);
setState(1217);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1218);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1219);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(COMPACTIONS);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(1220);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1221);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(CREATE);
setState(1222);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TABLE);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(1223);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1224);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTIONS);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(1225);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1226);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEXES);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(1227);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(SHOW);
setState(1228);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(LOCKS);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(1229);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1230);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(1231);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1232);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(1233);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1234);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(INDEX);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(1235);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(1236);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(1237);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(LOCK);
setState(1238);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(1239);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(1240);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(1241);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(UNLOCK);
setState(1242);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(DATABASE);
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(1243);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(CREATE);
setState(1244);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(1245);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(1246);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(DROP);
setState(1247);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TEMPORARY);
setState(1248);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(MACRO);
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(1249);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1250);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1251);
tableIdentifier();
setState(1252);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1253);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(CLUSTERED);
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(1255);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1256);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1257);
tableIdentifier();
setState(1258);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CLUSTERED);
setState(1259);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(1261);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1262);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1263);
tableIdentifier();
setState(1264);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1265);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SORTED);
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(1267);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1268);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1269);
tableIdentifier();
setState(1270);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SKEWED);
setState(1271);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(BY);
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(1273);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1274);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1275);
tableIdentifier();
setState(1276);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1277);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(1279);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1280);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1281);
tableIdentifier();
setState(1282);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(NOT);
setState(1283);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(STORED);
setState(1284);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(AS);
setState(1285);
((UnsupportedHiveNativeCommandsContext)_localctx).kw6 = match(DIRECTORIES);
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(1287);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1288);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1289);
tableIdentifier();
setState(1290);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(1291);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(SKEWED);
setState(1292);
((UnsupportedHiveNativeCommandsContext)_localctx).kw5 = match(LOCATION);
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(1294);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1295);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1296);
tableIdentifier();
setState(1297);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(EXCHANGE);
setState(1298);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(1300);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1301);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1302);
tableIdentifier();
setState(1303);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(ARCHIVE);
setState(1304);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(1306);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1307);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1308);
tableIdentifier();
setState(1309);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(UNARCHIVE);
setState(1310);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(PARTITION);
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(1312);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1313);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1314);
tableIdentifier();
setState(1315);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(TOUCH);
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(1317);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1318);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1319);
tableIdentifier();
setState(1321);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1320);
partitionSpec();
}
}
setState(1323);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(COMPACT);
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(1325);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1326);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1327);
tableIdentifier();
setState(1329);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1328);
partitionSpec();
}
}
setState(1331);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(CONCATENATE);
}
break;
case 39:
enterOuterAlt(_localctx, 39);
{
setState(1333);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1334);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1335);
tableIdentifier();
setState(1337);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1336);
partitionSpec();
}
}
setState(1339);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(SET);
setState(1340);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(FILEFORMAT);
}
break;
case 40:
enterOuterAlt(_localctx, 40);
{
setState(1342);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ALTER);
setState(1343);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TABLE);
setState(1344);
tableIdentifier();
setState(1346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1345);
partitionSpec();
}
}
setState(1348);
((UnsupportedHiveNativeCommandsContext)_localctx).kw3 = match(REPLACE);
setState(1349);
((UnsupportedHiveNativeCommandsContext)_localctx).kw4 = match(COLUMNS);
}
break;
case 41:
enterOuterAlt(_localctx, 41);
{
setState(1351);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(START);
setState(1352);
((UnsupportedHiveNativeCommandsContext)_localctx).kw2 = match(TRANSACTION);
}
break;
case 42:
enterOuterAlt(_localctx, 42);
{
setState(1353);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(COMMIT);
}
break;
case 43:
enterOuterAlt(_localctx, 43);
{
setState(1354);
((UnsupportedHiveNativeCommandsContext)_localctx).kw1 = match(ROLLBACK);
}
break;
case 44:
enterOuterAlt(_localctx, 44);
{
setState(1355);
((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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableHeaderContext createTableHeader() throws RecognitionException {
CreateTableHeaderContext _localctx = new CreateTableHeaderContext(_ctx, getState());
enterRule(_localctx, 24, RULE_createTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1358);
match(CREATE);
setState(1360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TEMPORARY) {
{
setState(1359);
match(TEMPORARY);
}
}
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTERNAL) {
{
setState(1362);
match(EXTERNAL);
}
}
setState(1365);
match(TABLE);
setState(1369);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1366);
match(IF);
setState(1367);
match(NOT);
setState(1368);
match(EXISTS);
}
break;
}
setState(1371);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterReplaceTableHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitReplaceTableHeader(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitReplaceTableHeader(this);
else return visitor.visitChildren(this);
}
}
public final ReplaceTableHeaderContext replaceTableHeader() throws RecognitionException {
ReplaceTableHeaderContext _localctx = new ReplaceTableHeaderContext(_ctx, getState());
enterRule(_localctx, 26, RULE_replaceTableHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1375);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(1373);
match(CREATE);
setState(1374);
match(OR);
}
}
setState(1377);
match(REPLACE);
setState(1378);
match(TABLE);
setState(1379);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterBucketSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitBucketSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitBucketSpec(this);
else return visitor.visitChildren(this);
}
}
public final BucketSpecContext bucketSpec() throws RecognitionException {
BucketSpecContext _localctx = new BucketSpecContext(_ctx, getState());
enterRule(_localctx, 28, RULE_bucketSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1381);
match(CLUSTERED);
setState(1382);
match(BY);
setState(1383);
identifierList();
setState(1387);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SORTED) {
{
setState(1384);
match(SORTED);
setState(1385);
match(BY);
setState(1386);
orderedIdentifierList();
}
}
setState(1389);
match(INTO);
setState(1390);
match(INTEGER_VALUE);
setState(1391);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSkewSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSkewSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSkewSpec(this);
else return visitor.visitChildren(this);
}
}
public final SkewSpecContext skewSpec() throws RecognitionException {
SkewSpecContext _localctx = new SkewSpecContext(_ctx, getState());
enterRule(_localctx, 30, RULE_skewSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1393);
match(SKEWED);
setState(1394);
match(BY);
setState(1395);
identifierList();
setState(1396);
match(ON);
setState(1399);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
{
setState(1397);
constantList();
}
break;
case 2:
{
setState(1398);
nestedConstantList();
}
break;
}
setState(1404);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
{
setState(1401);
match(STORED);
setState(1402);
match(AS);
setState(1403);
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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterLocationSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitLocationSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitLocationSpec(this);
else return visitor.visitChildren(this);
}
}
public final LocationSpecContext locationSpec() throws RecognitionException {
LocationSpecContext _localctx = new LocationSpecContext(_ctx, getState());
enterRule(_localctx, 32, RULE_locationSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1406);
match(LOCATION);
setState(1407);
stringLit();
}
}
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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCommentSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCommentSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCommentSpec(this);
else return visitor.visitChildren(this);
}
}
public final CommentSpecContext commentSpec() throws RecognitionException {
CommentSpecContext _localctx = new CommentSpecContext(_ctx, getState());
enterRule(_localctx, 34, RULE_commentSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(1409);
match(COMMENT);
setState(1410);
stringLit();
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 36, RULE_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(1412);
ctes();
}
}
setState(1415);
queryTerm(0);
setState(1416);
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 InsertIntoReplaceWhereContext 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 REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public InsertIntoReplaceWhereContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInsertIntoReplaceWhere(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInsertIntoReplaceWhere(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitInsertIntoReplaceWhere(this);
else return visitor.visitChildren(this);
}
}
public static class InsertOverwriteHiveDirContext extends InsertIntoContext {
public StringLitContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInsertOverwriteHiveDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInsertOverwriteHiveDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitInsertOverwriteHiveDir(this);
else return visitor.visitChildren(this);
}
}
public static class InsertOverwriteDirContext extends InsertIntoContext {
public StringLitContext path;
public PropertyListContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.class,0);
}
public InsertOverwriteDirContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInsertOverwriteDir(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInsertOverwriteDir(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInsertOverwriteTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInsertOverwriteTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 IdentifierListContext identifierList() {
return getRuleContext(IdentifierListContext.class,0);
}
public InsertIntoTableContext(InsertIntoContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInsertIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInsertIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitInsertIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final InsertIntoContext insertInto() throws RecognitionException {
InsertIntoContext _localctx = new InsertIntoContext(_ctx, getState());
enterRule(_localctx, 38, RULE_insertInto);
int _la;
try {
setState(1488);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
_localctx = new InsertOverwriteTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1418);
match(INSERT);
setState(1419);
match(OVERWRITE);
setState(1421);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1420);
match(TABLE);
}
break;
}
setState(1423);
multipartIdentifier();
setState(1430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1424);
partitionSpec();
setState(1428);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(1425);
match(IF);
setState(1426);
match(NOT);
setState(1427);
match(EXISTS);
}
}
}
}
setState(1433);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
{
setState(1432);
identifierList();
}
break;
}
}
break;
case 2:
_localctx = new InsertIntoTableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1435);
match(INSERT);
setState(1436);
match(INTO);
setState(1438);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
{
setState(1437);
match(TABLE);
}
break;
}
setState(1440);
multipartIdentifier();
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1441);
partitionSpec();
}
}
setState(1447);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(1444);
match(IF);
setState(1445);
match(NOT);
setState(1446);
match(EXISTS);
}
}
setState(1450);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1449);
identifierList();
}
break;
}
}
break;
case 3:
_localctx = new InsertIntoReplaceWhereContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1452);
match(INSERT);
setState(1453);
match(INTO);
setState(1455);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
{
setState(1454);
match(TABLE);
}
break;
}
setState(1457);
multipartIdentifier();
setState(1458);
match(REPLACE);
setState(1459);
whereClause();
}
break;
case 4:
_localctx = new InsertOverwriteHiveDirContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1461);
match(INSERT);
setState(1462);
match(OVERWRITE);
setState(1464);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(1463);
match(LOCAL);
}
}
setState(1466);
match(DIRECTORY);
setState(1467);
((InsertOverwriteHiveDirContext)_localctx).path = stringLit();
setState(1469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(1468);
rowFormat();
}
}
setState(1472);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STORED) {
{
setState(1471);
createFileFormat();
}
}
}
break;
case 5:
_localctx = new InsertOverwriteDirContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1474);
match(INSERT);
setState(1475);
match(OVERWRITE);
setState(1477);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCAL) {
{
setState(1476);
match(LOCAL);
}
}
setState(1479);
match(DIRECTORY);
setState(1481);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1480);
((InsertOverwriteDirContext)_localctx).path = stringLit();
}
break;
}
setState(1483);
tableProvider();
setState(1486);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPTIONS) {
{
setState(1484);
match(OPTIONS);
setState(1485);
((InsertOverwriteDirContext)_localctx).options = propertyList();
}
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPartitionSpecLocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPartitionSpecLocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPartitionSpecLocation(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecLocationContext partitionSpecLocation() throws RecognitionException {
PartitionSpecLocationContext _localctx = new PartitionSpecLocationContext(_ctx, getState());
enterRule(_localctx, 40, RULE_partitionSpecLocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1490);
partitionSpec();
setState(1492);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCATION) {
{
setState(1491);
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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public List partitionVal() {
return getRuleContexts(PartitionValContext.class);
}
public PartitionValContext partitionVal(int i) {
return getRuleContext(PartitionValContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public PartitionSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPartitionSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPartitionSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPartitionSpec(this);
else return visitor.visitChildren(this);
}
}
public final PartitionSpecContext partitionSpec() throws RecognitionException {
PartitionSpecContext _localctx = new PartitionSpecContext(_ctx, getState());
enterRule(_localctx, 42, RULE_partitionSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1494);
match(PARTITION);
setState(1495);
match(LEFT_PAREN);
setState(1496);
partitionVal();
setState(1501);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1497);
match(COMMA);
setState(1498);
partitionVal();
}
}
setState(1503);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1504);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionValContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(SqlBaseParser.EQ, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(SqlBaseParser.DEFAULT, 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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPartitionVal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPartitionVal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPartitionVal(this);
else return visitor.visitChildren(this);
}
}
public final PartitionValContext partitionVal() throws RecognitionException {
PartitionValContext _localctx = new PartitionValContext(_ctx, getState());
enterRule(_localctx, 44, RULE_partitionVal);
int _la;
try {
setState(1515);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1506);
identifier();
setState(1509);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1507);
match(EQ);
setState(1508);
constant();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1511);
identifier();
setState(1512);
match(EQ);
setState(1513);
match(DEFAULT);
}
break;
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNamespace(this);
else return visitor.visitChildren(this);
}
}
public final NamespaceContext namespace() throws RecognitionException {
NamespaceContext _localctx = new NamespaceContext(_ctx, getState());
enterRule(_localctx, 46, RULE_namespace);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1517);
_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 NamespacesContext extends ParserRuleContext {
public TerminalNode NAMESPACES() { return getToken(SqlBaseParser.NAMESPACES, 0); }
public TerminalNode DATABASES() { return getToken(SqlBaseParser.DATABASES, 0); }
public TerminalNode SCHEMAS() { return getToken(SqlBaseParser.SCHEMAS, 0); }
public NamespacesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespaces; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNamespaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNamespaces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNamespaces(this);
else return visitor.visitChildren(this);
}
}
public final NamespacesContext namespaces() throws RecognitionException {
NamespacesContext _localctx = new NamespacesContext(_ctx, getState());
enterRule(_localctx, 48, RULE_namespaces);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1519);
_la = _input.LA(1);
if ( !(_la==DATABASES || _la==NAMESPACES || _la==SCHEMAS) ) {
_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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeFuncName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeFuncName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDescribeFuncName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeFuncNameContext describeFuncName() throws RecognitionException {
DescribeFuncNameContext _localctx = new DescribeFuncNameContext(_ctx, getState());
enterRule(_localctx, 50, RULE_describeFuncName);
try {
setState(1526);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1521);
qualifiedName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1522);
stringLit();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1523);
comparisonOperator();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1524);
arithmeticOperator();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1525);
predicateOperator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DescribeColNameContext extends ParserRuleContext {
public IdentifierContext identifier;
public List nameParts = new ArrayList();
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(SqlBaseParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(SqlBaseParser.DOT, i);
}
public DescribeColNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_describeColName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDescribeColName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDescribeColName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDescribeColName(this);
else return visitor.visitChildren(this);
}
}
public final DescribeColNameContext describeColName() throws RecognitionException {
DescribeColNameContext _localctx = new DescribeColNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_describeColName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1528);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
setState(1533);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1529);
match(DOT);
setState(1530);
((DescribeColNameContext)_localctx).identifier = identifier();
((DescribeColNameContext)_localctx).nameParts.add(((DescribeColNameContext)_localctx).identifier);
}
}
setState(1535);
_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 List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public CtesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCtes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCtes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCtes(this);
else return visitor.visitChildren(this);
}
}
public final CtesContext ctes() throws RecognitionException {
CtesContext _localctx = new CtesContext(_ctx, getState());
enterRule(_localctx, 54, RULE_ctes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1536);
match(WITH);
setState(1537);
namedQuery();
setState(1542);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1538);
match(COMMA);
setState(1539);
namedQuery();
}
}
setState(1544);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamedQueryContext extends ParserRuleContext {
public ErrorCapturingIdentifierContext name;
public IdentifierListContext columnAliases;
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNamedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNamedQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNamedQuery(this);
else return visitor.visitChildren(this);
}
}
public final NamedQueryContext namedQuery() throws RecognitionException {
NamedQueryContext _localctx = new NamedQueryContext(_ctx, getState());
enterRule(_localctx, 56, RULE_namedQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1545);
((NamedQueryContext)_localctx).name = errorCapturingIdentifier();
setState(1547);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1546);
((NamedQueryContext)_localctx).columnAliases = identifierList();
}
break;
}
setState(1550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(1549);
match(AS);
}
}
setState(1552);
match(LEFT_PAREN);
setState(1553);
query();
setState(1554);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TableProviderContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTableProvider(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTableProvider(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitTableProvider(this);
else return visitor.visitChildren(this);
}
}
public final TableProviderContext tableProvider() throws RecognitionException {
TableProviderContext _localctx = new TableProviderContext(_ctx, getState());
enterRule(_localctx, 58, RULE_tableProvider);
try {
enterOuterAlt(_localctx, 1);
{
setState(1556);
match(USING);
setState(1557);
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 PropertyListContext options;
public PartitionFieldListContext partitioning;
public PropertyListContext tableProps;
public List skewSpec() {
return getRuleContexts(SkewSpecContext.class);
}
public SkewSpecContext skewSpec(int i) {
return getRuleContext(SkewSpecContext.class,i);
}
public List bucketSpec() {
return getRuleContexts(BucketSpecContext.class);
}
public BucketSpecContext bucketSpec(int i) {
return getRuleContext(BucketSpecContext.class,i);
}
public List rowFormat() {
return getRuleContexts(RowFormatContext.class);
}
public RowFormatContext rowFormat(int i) {
return getRuleContext(RowFormatContext.class,i);
}
public List createFileFormat() {
return getRuleContexts(CreateFileFormatContext.class);
}
public CreateFileFormatContext createFileFormat(int i) {
return getRuleContext(CreateFileFormatContext.class,i);
}
public List locationSpec() {
return getRuleContexts(LocationSpecContext.class);
}
public LocationSpecContext locationSpec(int i) {
return getRuleContext(LocationSpecContext.class,i);
}
public List commentSpec() {
return getRuleContexts(CommentSpecContext.class);
}
public CommentSpecContext commentSpec(int i) {
return getRuleContext(CommentSpecContext.class,i);
}
public List OPTIONS() { return getTokens(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 propertyList() {
return getRuleContexts(PropertyListContext.class);
}
public PropertyListContext propertyList(int i) {
return getRuleContext(PropertyListContext.class,i);
}
public List partitionFieldList() {
return getRuleContexts(PartitionFieldListContext.class);
}
public PartitionFieldListContext partitionFieldList(int i) {
return getRuleContext(PartitionFieldListContext.class,i);
}
public CreateTableClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createTableClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateTableClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateTableClauses(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateTableClauses(this);
else return visitor.visitChildren(this);
}
}
public final CreateTableClausesContext createTableClauses() throws RecognitionException {
CreateTableClausesContext _localctx = new CreateTableClausesContext(_ctx, getState());
enterRule(_localctx, 60, RULE_createTableClauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1574);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CLUSTERED || _la==COMMENT || ((((_la - 149)) & ~0x3f) == 0 && ((1L << (_la - 149)) & ((1L << (LOCATION - 149)) | (1L << (OPTIONS - 149)) | (1L << (PARTITIONED - 149)))) != 0) || ((((_la - 227)) & ~0x3f) == 0 && ((1L << (_la - 227)) & ((1L << (ROW - 227)) | (1L << (SKEWED - 227)) | (1L << (STORED - 227)) | (1L << (TBLPROPERTIES - 227)))) != 0)) {
{
setState(1572);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPTIONS:
{
{
setState(1559);
match(OPTIONS);
setState(1560);
((CreateTableClausesContext)_localctx).options = propertyList();
}
}
break;
case PARTITIONED:
{
{
setState(1561);
match(PARTITIONED);
setState(1562);
match(BY);
setState(1563);
((CreateTableClausesContext)_localctx).partitioning = partitionFieldList();
}
}
break;
case SKEWED:
{
setState(1564);
skewSpec();
}
break;
case CLUSTERED:
{
setState(1565);
bucketSpec();
}
break;
case ROW:
{
setState(1566);
rowFormat();
}
break;
case STORED:
{
setState(1567);
createFileFormat();
}
break;
case LOCATION:
{
setState(1568);
locationSpec();
}
break;
case COMMENT:
{
setState(1569);
commentSpec();
}
break;
case TBLPROPERTIES:
{
{
setState(1570);
match(TBLPROPERTIES);
setState(1571);
((CreateTableClausesContext)_localctx).tableProps = propertyList();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1576);
_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 PropertyListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public List property() {
return getRuleContexts(PropertyContext.class);
}
public PropertyContext property(int i) {
return getRuleContext(PropertyContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public PropertyListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPropertyList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPropertyList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPropertyList(this);
else return visitor.visitChildren(this);
}
}
public final PropertyListContext propertyList() throws RecognitionException {
PropertyListContext _localctx = new PropertyListContext(_ctx, getState());
enterRule(_localctx, 62, RULE_propertyList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1577);
match(LEFT_PAREN);
setState(1578);
property();
setState(1583);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1579);
match(COMMA);
setState(1580);
property();
}
}
setState(1585);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1586);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyContext extends ParserRuleContext {
public PropertyKeyContext key;
public PropertyValueContext value;
public PropertyKeyContext propertyKey() {
return getRuleContext(PropertyKeyContext.class,0);
}
public PropertyValueContext propertyValue() {
return getRuleContext(PropertyValueContext.class,0);
}
public TerminalNode EQ() { return getToken(SqlBaseParser.EQ, 0); }
public PropertyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_property; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitProperty(this);
else return visitor.visitChildren(this);
}
}
public final PropertyContext property() throws RecognitionException {
PropertyContext _localctx = new PropertyContext(_ctx, getState());
enterRule(_localctx, 64, RULE_property);
try {
enterOuterAlt(_localctx, 1);
{
setState(1588);
((PropertyContext)_localctx).key = propertyKey();
setState(1593);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
{
setState(1590);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
{
setState(1589);
match(EQ);
}
break;
}
setState(1592);
((PropertyContext)_localctx).value = propertyValue();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyKeyContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(SqlBaseParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(SqlBaseParser.DOT, i);
}
public StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public PropertyKeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyKey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPropertyKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPropertyKey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPropertyKey(this);
else return visitor.visitChildren(this);
}
}
public final PropertyKeyContext propertyKey() throws RecognitionException {
PropertyKeyContext _localctx = new PropertyKeyContext(_ctx, getState());
enterRule(_localctx, 66, RULE_propertyKey);
try {
int _alt;
setState(1604);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1595);
identifier();
setState(1600);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1596);
match(DOT);
setState(1597);
identifier();
}
}
}
setState(1602);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1603);
stringLit();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyValueContext 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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public PropertyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterPropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitPropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitPropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final PropertyValueContext propertyValue() throws RecognitionException {
PropertyValueContext _localctx = new PropertyValueContext(_ctx, getState());
enterRule(_localctx, 68, RULE_propertyValue);
try {
setState(1610);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1606);
match(INTEGER_VALUE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1607);
match(DECIMAL_VALUE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1608);
booleanValue();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1609);
stringLit();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public ConstantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitConstantList(this);
else return visitor.visitChildren(this);
}
}
public final ConstantListContext constantList() throws RecognitionException {
ConstantListContext _localctx = new ConstantListContext(_ctx, getState());
enterRule(_localctx, 70, RULE_constantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1612);
match(LEFT_PAREN);
setState(1613);
constant();
setState(1618);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1614);
match(COMMA);
setState(1615);
constant();
}
}
setState(1620);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1621);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NestedConstantListContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public List constantList() {
return getRuleContexts(ConstantListContext.class);
}
public ConstantListContext constantList(int i) {
return getRuleContext(ConstantListContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public NestedConstantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nestedConstantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNestedConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNestedConstantList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNestedConstantList(this);
else return visitor.visitChildren(this);
}
}
public final NestedConstantListContext nestedConstantList() throws RecognitionException {
NestedConstantListContext _localctx = new NestedConstantListContext(_ctx, getState());
enterRule(_localctx, 72, RULE_nestedConstantList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1623);
match(LEFT_PAREN);
setState(1624);
constantList();
setState(1629);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1625);
match(COMMA);
setState(1626);
constantList();
}
}
setState(1631);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1632);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateFileFormatContext extends ParserRuleContext {
public TerminalNode STORED() { return getToken(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterCreateFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitCreateFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitCreateFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final CreateFileFormatContext createFileFormat() throws RecognitionException {
CreateFileFormatContext _localctx = new CreateFileFormatContext(_ctx, getState());
enterRule(_localctx, 74, RULE_createFileFormat);
try {
setState(1640);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1634);
match(STORED);
setState(1635);
match(AS);
setState(1636);
fileFormat();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1637);
match(STORED);
setState(1638);
match(BY);
setState(1639);
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 StringLitContext inFmt;
public StringLitContext outFmt;
public TerminalNode INPUTFORMAT() { return getToken(SqlBaseParser.INPUTFORMAT, 0); }
public TerminalNode OUTPUTFORMAT() { return getToken(SqlBaseParser.OUTPUTFORMAT, 0); }
public List stringLit() {
return getRuleContexts(StringLitContext.class);
}
public StringLitContext stringLit(int i) {
return getRuleContext(StringLitContext.class,i);
}
public TableFileFormatContext(FileFormatContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTableFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTableFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterGenericFileFormat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitGenericFileFormat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitGenericFileFormat(this);
else return visitor.visitChildren(this);
}
}
public final FileFormatContext fileFormat() throws RecognitionException {
FileFormatContext _localctx = new FileFormatContext(_ctx, getState());
enterRule(_localctx, 76, RULE_fileFormat);
try {
setState(1648);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
_localctx = new TableFileFormatContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1642);
match(INPUTFORMAT);
setState(1643);
((TableFileFormatContext)_localctx).inFmt = stringLit();
setState(1644);
match(OUTPUTFORMAT);
setState(1645);
((TableFileFormatContext)_localctx).outFmt = stringLit();
}
break;
case 2:
_localctx = new GenericFileFormatContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1647);
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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,0);
}
public TerminalNode WITH() { return getToken(SqlBaseParser.WITH, 0); }
public TerminalNode SERDEPROPERTIES() { return getToken(SqlBaseParser.SERDEPROPERTIES, 0); }
public PropertyListContext propertyList() {
return getRuleContext(PropertyListContext.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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterStorageHandler(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitStorageHandler(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitStorageHandler(this);
else return visitor.visitChildren(this);
}
}
public final StorageHandlerContext storageHandler() throws RecognitionException {
StorageHandlerContext _localctx = new StorageHandlerContext(_ctx, getState());
enterRule(_localctx, 78, RULE_storageHandler);
try {
enterOuterAlt(_localctx, 1);
{
setState(1650);
stringLit();
setState(1654);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(1651);
match(WITH);
setState(1652);
match(SERDEPROPERTIES);
setState(1653);
propertyList();
}
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 StringLitContext stringLit() {
return getRuleContext(StringLitContext.class,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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitResource(this);
else return visitor.visitChildren(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 80, RULE_resource);
try {
enterOuterAlt(_localctx, 1);
{
setState(1656);
identifier();
setState(1657);
stringLit();
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterDeleteFromTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitDeleteFromTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitDeleteFromTable(this);
else return visitor.visitChildren(this);
}
}
public static class SingleInsertQueryContext extends DmlStatementNoWithContext {
public InsertIntoContext insertInto() {
return getRuleContext(InsertIntoContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public SingleInsertQueryContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSingleInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSingleInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterMultiInsertQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitMultiInsertQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterUpdateTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitUpdateTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public List matchedClause() {
return getRuleContexts(MatchedClauseContext.class);
}
public MatchedClauseContext matchedClause(int i) {
return getRuleContext(MatchedClauseContext.class,i);
}
public List notMatchedClause() {
return getRuleContexts(NotMatchedClauseContext.class);
}
public NotMatchedClauseContext notMatchedClause(int i) {
return getRuleContext(NotMatchedClauseContext.class,i);
}
public List notMatchedBySourceClause() {
return getRuleContexts(NotMatchedBySourceClauseContext.class);
}
public NotMatchedBySourceClauseContext notMatchedBySourceClause(int i) {
return getRuleContext(NotMatchedBySourceClauseContext.class,i);
}
public MergeIntoTableContext(DmlStatementNoWithContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterMergeIntoTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitMergeIntoTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitMergeIntoTable(this);
else return visitor.visitChildren(this);
}
}
public final DmlStatementNoWithContext dmlStatementNoWith() throws RecognitionException {
DmlStatementNoWithContext _localctx = new DmlStatementNoWithContext(_ctx, getState());
enterRule(_localctx, 82, RULE_dmlStatementNoWith);
int _la;
try {
int _alt;
setState(1715);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INSERT:
_localctx = new SingleInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1659);
insertInto();
setState(1660);
query();
}
break;
case FROM:
_localctx = new MultiInsertQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1662);
fromClause();
setState(1664);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1663);
multiInsertQueryBody();
}
}
setState(1666);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==INSERT );
}
break;
case DELETE:
_localctx = new DeleteFromTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1668);
match(DELETE);
setState(1669);
match(FROM);
setState(1670);
multipartIdentifier();
setState(1671);
tableAlias();
setState(1673);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1672);
whereClause();
}
}
}
break;
case UPDATE:
_localctx = new UpdateTableContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1675);
match(UPDATE);
setState(1676);
multipartIdentifier();
setState(1677);
tableAlias();
setState(1678);
setClause();
setState(1680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(1679);
whereClause();
}
}
}
break;
case MERGE:
_localctx = new MergeIntoTableContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1682);
match(MERGE);
setState(1683);
match(INTO);
setState(1684);
((MergeIntoTableContext)_localctx).target = multipartIdentifier();
setState(1685);
((MergeIntoTableContext)_localctx).targetAlias = tableAlias();
setState(1686);
match(USING);
setState(1692);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
{
setState(1687);
((MergeIntoTableContext)_localctx).source = multipartIdentifier();
}
break;
case 2:
{
setState(1688);
match(LEFT_PAREN);
setState(1689);
((MergeIntoTableContext)_localctx).sourceQuery = query();
setState(1690);
match(RIGHT_PAREN);
}
break;
}
setState(1694);
((MergeIntoTableContext)_localctx).sourceAlias = tableAlias();
setState(1695);
match(ON);
setState(1696);
((MergeIntoTableContext)_localctx).mergeCondition = booleanExpression(0);
setState(1700);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,181,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1697);
matchedClause();
}
}
}
setState(1702);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,181,_ctx);
}
setState(1706);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,182,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1703);
notMatchedClause();
}
}
}
setState(1708);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,182,_ctx);
}
setState(1712);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==WHEN) {
{
{
setState(1709);
notMatchedBySourceClause();
}
}
setState(1714);
_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 ExpressionContext offset;
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 TerminalNode OFFSET() { return getToken(SqlBaseParser.OFFSET, 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 List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public QueryOrganizationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOrganization; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterQueryOrganization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitQueryOrganization(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitQueryOrganization(this);
else return visitor.visitChildren(this);
}
}
public final QueryOrganizationContext queryOrganization() throws RecognitionException {
QueryOrganizationContext _localctx = new QueryOrganizationContext(_ctx, getState());
enterRule(_localctx, 84, RULE_queryOrganization);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1727);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(1717);
match(ORDER);
setState(1718);
match(BY);
setState(1719);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
setState(1724);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,185,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1720);
match(COMMA);
setState(1721);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).order.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(1726);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,185,_ctx);
}
}
break;
}
setState(1739);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
{
setState(1729);
match(CLUSTER);
setState(1730);
match(BY);
setState(1731);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
setState(1736);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1732);
match(COMMA);
setState(1733);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).clusterBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(1738);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
}
}
break;
}
setState(1751);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(1741);
match(DISTRIBUTE);
setState(1742);
match(BY);
setState(1743);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
setState(1748);
_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(1744);
match(COMMA);
setState(1745);
((QueryOrganizationContext)_localctx).expression = expression();
((QueryOrganizationContext)_localctx).distributeBy.add(((QueryOrganizationContext)_localctx).expression);
}
}
}
setState(1750);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,189,_ctx);
}
}
break;
}
setState(1763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1753);
match(SORT);
setState(1754);
match(BY);
setState(1755);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
setState(1760);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,191,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1756);
match(COMMA);
setState(1757);
((QueryOrganizationContext)_localctx).sortItem = sortItem();
((QueryOrganizationContext)_localctx).sort.add(((QueryOrganizationContext)_localctx).sortItem);
}
}
}
setState(1762);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,191,_ctx);
}
}
break;
}
setState(1766);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1765);
windowClause();
}
break;
}
setState(1773);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
{
setState(1768);
match(LIMIT);
setState(1771);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
{
setState(1769);
match(ALL);
}
break;
case 2:
{
setState(1770);
((QueryOrganizationContext)_localctx).limit = expression();
}
break;
}
}
break;
}
setState(1777);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
case 1:
{
setState(1775);
match(OFFSET);
setState(1776);
((QueryOrganizationContext)_localctx).offset = expression();
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterMultiInsertQueryBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitMultiInsertQueryBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitMultiInsertQueryBody(this);
else return visitor.visitChildren(this);
}
}
public final MultiInsertQueryBodyContext multiInsertQueryBody() throws RecognitionException {
MultiInsertQueryBodyContext _localctx = new MultiInsertQueryBodyContext(_ctx, getState());
enterRule(_localctx, 86, RULE_multiInsertQueryBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(1779);
insertInto();
setState(1780);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterQueryTermDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitQueryTermDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetOperation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 = 88;
enterRecursionRule(_localctx, 88, RULE_queryTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new QueryTermDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1783);
queryPrimary();
}
_ctx.stop = _input.LT(-1);
setState(1808);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1806);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(1785);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1786);
if (!(legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "legacy_setops_precedence_enabled");
setState(1787);
((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(1789);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1788);
setQuantifier();
}
}
setState(1791);
((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(1792);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1793);
if (!(!legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enabled");
setState(1794);
((SetOperationContext)_localctx).operator = match(INTERSECT);
setState(1796);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1795);
setQuantifier();
}
}
setState(1798);
((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(1799);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1800);
if (!(!legacy_setops_precedence_enabled)) throw new FailedPredicateException(this, "!legacy_setops_precedence_enabled");
setState(1801);
((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(1803);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(1802);
setQuantifier();
}
}
setState(1805);
((SetOperationContext)_localctx).right = queryTerm(2);
}
break;
}
}
}
setState(1810);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class QueryPrimaryContext extends ParserRuleContext {
public QueryPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryPrimary; }
public QueryPrimaryContext() { }
public void copyFrom(QueryPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
public static class SubqueryContext extends QueryPrimaryContext {
public TerminalNode LEFT_PAREN() { return getToken(SqlBaseParser.LEFT_PAREN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(SqlBaseParser.RIGHT_PAREN, 0); }
public SubqueryContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterQueryPrimaryDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitQueryPrimaryDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterInlineTableDefault1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitInlineTableDefault1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterFromStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitFromStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitTable(this);
else return visitor.visitChildren(this);
}
}
public final QueryPrimaryContext queryPrimary() throws RecognitionException {
QueryPrimaryContext _localctx = new QueryPrimaryContext(_ctx, getState());
enterRule(_localctx, 90, RULE_queryPrimary);
try {
setState(1820);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MAP:
case REDUCE:
case SELECT:
_localctx = new QueryPrimaryDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1811);
querySpecification();
}
break;
case FROM:
_localctx = new FromStmtContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1812);
fromStatement();
}
break;
case TABLE:
_localctx = new TableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1813);
match(TABLE);
setState(1814);
multipartIdentifier();
}
break;
case VALUES:
_localctx = new InlineTableDefault1Context(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1815);
inlineTable();
}
break;
case LEFT_PAREN:
_localctx = new SubqueryContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1816);
match(LEFT_PAREN);
setState(1817);
query();
setState(1818);
match(RIGHT_PAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SortItemContext extends ParserRuleContext {
public Token ordering;
public Token nullOrder;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NULLS() { return getToken(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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSortItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSortItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSortItem(this);
else return visitor.visitChildren(this);
}
}
public final SortItemContext sortItem() throws RecognitionException {
SortItemContext _localctx = new SortItemContext(_ctx, getState());
enterRule(_localctx, 92, RULE_sortItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1822);
expression();
setState(1824);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
{
setState(1823);
((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(1828);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
case 1:
{
setState(1826);
match(NULLS);
setState(1827);
((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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterFromStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitFromStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitFromStatement(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementContext fromStatement() throws RecognitionException {
FromStatementContext _localctx = new FromStatementContext(_ctx, getState());
enterRule(_localctx, 94, RULE_fromStatement);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1830);
fromClause();
setState(1832);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1831);
fromStatementBody();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1834);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,205,_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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterFromStatementBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitFromStatementBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitFromStatementBody(this);
else return visitor.visitChildren(this);
}
}
public final FromStatementBodyContext fromStatementBody() throws RecognitionException {
FromStatementBodyContext _localctx = new FromStatementBodyContext(_ctx, getState());
enterRule(_localctx, 96, RULE_fromStatementBody);
try {
int _alt;
setState(1863);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1836);
transformClause();
setState(1838);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
{
setState(1837);
whereClause();
}
break;
}
setState(1840);
queryOrganization();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1842);
selectClause();
setState(1846);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,207,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1843);
lateralView();
}
}
}
setState(1848);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,207,_ctx);
}
setState(1850);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
{
setState(1849);
whereClause();
}
break;
}
setState(1853);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
case 1:
{
setState(1852);
aggregationClause();
}
break;
}
setState(1856);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
case 1:
{
setState(1855);
havingClause();
}
break;
}
setState(1859);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
case 1:
{
setState(1858);
windowClause();
}
break;
}
setState(1861);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterRegularQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitRegularQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitRegularQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public static class TransformQuerySpecificationContext extends QuerySpecificationContext {
public TransformClauseContext transformClause() {
return getRuleContext(TransformClauseContext.class,0);
}
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public List lateralView() {
return getRuleContexts(LateralViewContext.class);
}
public LateralViewContext lateralView(int i) {
return getRuleContext(LateralViewContext.class,i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public AggregationClauseContext aggregationClause() {
return getRuleContext(AggregationClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public TransformQuerySpecificationContext(QuerySpecificationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTransformQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTransformQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitTransformQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 98, RULE_querySpecification);
try {
int _alt;
setState(1909);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
case 1:
_localctx = new TransformQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1865);
transformClause();
setState(1867);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
{
setState(1866);
fromClause();
}
break;
}
setState(1872);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1869);
lateralView();
}
}
}
setState(1874);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
}
setState(1876);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) {
case 1:
{
setState(1875);
whereClause();
}
break;
}
setState(1879);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
{
setState(1878);
aggregationClause();
}
break;
}
setState(1882);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,217,_ctx) ) {
case 1:
{
setState(1881);
havingClause();
}
break;
}
setState(1885);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) {
case 1:
{
setState(1884);
windowClause();
}
break;
}
}
break;
case 2:
_localctx = new RegularQuerySpecificationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1887);
selectClause();
setState(1889);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
case 1:
{
setState(1888);
fromClause();
}
break;
}
setState(1894);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,220,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1891);
lateralView();
}
}
}
setState(1896);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,220,_ctx);
}
setState(1898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
case 1:
{
setState(1897);
whereClause();
}
break;
}
setState(1901);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) {
case 1:
{
setState(1900);
aggregationClause();
}
break;
}
setState(1904);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,223,_ctx) ) {
case 1:
{
setState(1903);
havingClause();
}
break;
}
setState(1907);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
case 1:
{
setState(1906);
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 StringLitContext recordWriter;
public StringLitContext script;
public RowFormatContext outRowFormat;
public StringLitContext recordReader;
public TerminalNode USING() { return getToken(SqlBaseParser.USING, 0); }
public List stringLit() {
return getRuleContexts(StringLitContext.class);
}
public StringLitContext stringLit(int i) {
return getRuleContext(StringLitContext.class,i);
}
public TerminalNode SELECT() { return getToken(SqlBaseParser.SELECT, 0); }
public List LEFT_PAREN() { return getTokens(SqlBaseParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(SqlBaseParser.LEFT_PAREN, i);
}
public ExpressionSeqContext expressionSeq() {
return getRuleContext(ExpressionSeqContext.class,0);
}
public List RIGHT_PAREN() { return getTokens(SqlBaseParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(SqlBaseParser.RIGHT_PAREN, i);
}
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 SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public IdentifierSeqContext identifierSeq() {
return getRuleContext(IdentifierSeqContext.class,0);
}
public ColTypeListContext colTypeList() {
return getRuleContext(ColTypeListContext.class,0);
}
public TransformClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transformClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterTransformClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitTransformClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitTransformClause(this);
else return visitor.visitChildren(this);
}
}
public final TransformClauseContext transformClause() throws RecognitionException {
TransformClauseContext _localctx = new TransformClauseContext(_ctx, getState());
enterRule(_localctx, 100, RULE_transformClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1930);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(1911);
match(SELECT);
setState(1912);
((TransformClauseContext)_localctx).kind = match(TRANSFORM);
setState(1913);
match(LEFT_PAREN);
setState(1915);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) {
case 1:
{
setState(1914);
setQuantifier();
}
break;
}
setState(1917);
expressionSeq();
setState(1918);
match(RIGHT_PAREN);
}
break;
case MAP:
{
setState(1920);
((TransformClauseContext)_localctx).kind = match(MAP);
setState(1922);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
case 1:
{
setState(1921);
setQuantifier();
}
break;
}
setState(1924);
expressionSeq();
}
break;
case REDUCE:
{
setState(1925);
((TransformClauseContext)_localctx).kind = match(REDUCE);
setState(1927);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(1926);
setQuantifier();
}
break;
}
setState(1929);
expressionSeq();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1933);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW) {
{
setState(1932);
((TransformClauseContext)_localctx).inRowFormat = rowFormat();
}
}
setState(1937);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORDWRITER) {
{
setState(1935);
match(RECORDWRITER);
setState(1936);
((TransformClauseContext)_localctx).recordWriter = stringLit();
}
}
setState(1939);
match(USING);
setState(1940);
((TransformClauseContext)_localctx).script = stringLit();
setState(1953);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) {
case 1:
{
setState(1941);
match(AS);
setState(1951);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
case 1:
{
setState(1942);
identifierSeq();
}
break;
case 2:
{
setState(1943);
colTypeList();
}
break;
case 3:
{
{
setState(1944);
match(LEFT_PAREN);
setState(1947);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
case 1:
{
setState(1945);
identifierSeq();
}
break;
case 2:
{
setState(1946);
colTypeList();
}
break;
}
setState(1949);
match(RIGHT_PAREN);
}
}
break;
}
}
break;
}
setState(1956);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,235,_ctx) ) {
case 1:
{
setState(1955);
((TransformClauseContext)_localctx).outRowFormat = rowFormat();
}
break;
}
setState(1960);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) {
case 1:
{
setState(1958);
match(RECORDREADER);
setState(1959);
((TransformClauseContext)_localctx).recordReader = stringLit();
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 102, RULE_selectClause);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1962);
match(SELECT);
setState(1966);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,237,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1963);
((SelectClauseContext)_localctx).hint = hint();
((SelectClauseContext)_localctx).hints.add(((SelectClauseContext)_localctx).hint);
}
}
}
setState(1968);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,237,_ctx);
}
setState(1970);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
case 1:
{
setState(1969);
setQuantifier();
}
break;
}
setState(1972);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterSetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitSetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitSetClause(this);
else return visitor.visitChildren(this);
}
}
public final SetClauseContext setClause() throws RecognitionException {
SetClauseContext _localctx = new SetClauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_setClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1974);
match(SET);
setState(1975);
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final MatchedClauseContext matchedClause() throws RecognitionException {
MatchedClauseContext _localctx = new MatchedClauseContext(_ctx, getState());
enterRule(_localctx, 106, RULE_matchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1977);
match(WHEN);
setState(1978);
match(MATCHED);
setState(1981);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1979);
match(AND);
setState(1980);
((MatchedClauseContext)_localctx).matchedCond = booleanExpression(0);
}
}
setState(1983);
match(THEN);
setState(1984);
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 BY() { return getToken(SqlBaseParser.BY, 0); }
public TerminalNode TARGET() { return getToken(SqlBaseParser.TARGET, 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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNotMatchedClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNotMatchedClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNotMatchedClause(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedClauseContext notMatchedClause() throws RecognitionException {
NotMatchedClauseContext _localctx = new NotMatchedClauseContext(_ctx, getState());
enterRule(_localctx, 108, RULE_notMatchedClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1986);
match(WHEN);
setState(1987);
match(NOT);
setState(1988);
match(MATCHED);
setState(1991);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BY) {
{
setState(1989);
match(BY);
setState(1990);
match(TARGET);
}
}
setState(1995);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(1993);
match(AND);
setState(1994);
((NotMatchedClauseContext)_localctx).notMatchedCond = booleanExpression(0);
}
}
setState(1997);
match(THEN);
setState(1998);
notMatchedAction();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotMatchedBySourceClauseContext extends ParserRuleContext {
public BooleanExpressionContext notMatchedBySourceCond;
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 BY() { return getToken(SqlBaseParser.BY, 0); }
public TerminalNode SOURCE() { return getToken(SqlBaseParser.SOURCE, 0); }
public TerminalNode THEN() { return getToken(SqlBaseParser.THEN, 0); }
public NotMatchedBySourceActionContext notMatchedBySourceAction() {
return getRuleContext(NotMatchedBySourceActionContext.class,0);
}
public TerminalNode AND() { return getToken(SqlBaseParser.AND, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public NotMatchedBySourceClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedBySourceClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNotMatchedBySourceClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNotMatchedBySourceClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNotMatchedBySourceClause(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedBySourceClauseContext notMatchedBySourceClause() throws RecognitionException {
NotMatchedBySourceClauseContext _localctx = new NotMatchedBySourceClauseContext(_ctx, getState());
enterRule(_localctx, 110, RULE_notMatchedBySourceClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2000);
match(WHEN);
setState(2001);
match(NOT);
setState(2002);
match(MATCHED);
setState(2003);
match(BY);
setState(2004);
match(SOURCE);
setState(2007);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(2005);
match(AND);
setState(2006);
((NotMatchedBySourceClauseContext)_localctx).notMatchedBySourceCond = booleanExpression(0);
}
}
setState(2009);
match(THEN);
setState(2010);
notMatchedBySourceAction();
}
}
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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final MatchedActionContext matchedAction() throws RecognitionException {
MatchedActionContext _localctx = new MatchedActionContext(_ctx, getState());
enterRule(_localctx, 112, RULE_matchedAction);
try {
setState(2019);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2012);
match(DELETE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2013);
match(UPDATE);
setState(2014);
match(SET);
setState(2015);
match(ASTERISK);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2016);
match(UPDATE);
setState(2017);
match(SET);
setState(2018);
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 List LEFT_PAREN() { return getTokens(SqlBaseParser.LEFT_PAREN); }
public TerminalNode LEFT_PAREN(int i) {
return getToken(SqlBaseParser.LEFT_PAREN, i);
}
public List RIGHT_PAREN() { return getTokens(SqlBaseParser.RIGHT_PAREN); }
public TerminalNode RIGHT_PAREN(int i) {
return getToken(SqlBaseParser.RIGHT_PAREN, i);
}
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 List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public NotMatchedActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNotMatchedAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNotMatchedAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNotMatchedAction(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedActionContext notMatchedAction() throws RecognitionException {
NotMatchedActionContext _localctx = new NotMatchedActionContext(_ctx, getState());
enterRule(_localctx, 114, RULE_notMatchedAction);
int _la;
try {
setState(2039);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,245,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2021);
match(INSERT);
setState(2022);
match(ASTERISK);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2023);
match(INSERT);
setState(2024);
match(LEFT_PAREN);
setState(2025);
((NotMatchedActionContext)_localctx).columns = multipartIdentifierList();
setState(2026);
match(RIGHT_PAREN);
setState(2027);
match(VALUES);
setState(2028);
match(LEFT_PAREN);
setState(2029);
expression();
setState(2034);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2030);
match(COMMA);
setState(2031);
expression();
}
}
setState(2036);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2037);
match(RIGHT_PAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NotMatchedBySourceActionContext 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 AssignmentListContext assignmentList() {
return getRuleContext(AssignmentListContext.class,0);
}
public NotMatchedBySourceActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notMatchedBySourceAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterNotMatchedBySourceAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitNotMatchedBySourceAction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitNotMatchedBySourceAction(this);
else return visitor.visitChildren(this);
}
}
public final NotMatchedBySourceActionContext notMatchedBySourceAction() throws RecognitionException {
NotMatchedBySourceActionContext _localctx = new NotMatchedBySourceActionContext(_ctx, getState());
enterRule(_localctx, 116, RULE_notMatchedBySourceAction);
try {
setState(2045);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DELETE:
enterOuterAlt(_localctx, 1);
{
setState(2041);
match(DELETE);
}
break;
case UPDATE:
enterOuterAlt(_localctx, 2);
{
setState(2042);
match(UPDATE);
setState(2043);
match(SET);
setState(2044);
assignmentList();
}
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 AssignmentListContext extends ParserRuleContext {
public List assignment() {
return getRuleContexts(AssignmentContext.class);
}
public AssignmentContext assignment(int i) {
return getRuleContext(AssignmentContext.class,i);
}
public List COMMA() { return getTokens(SqlBaseParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SqlBaseParser.COMMA, i);
}
public AssignmentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAssignmentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAssignmentList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseParserVisitor ) return ((SqlBaseParserVisitor)visitor).visitAssignmentList(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentListContext assignmentList() throws RecognitionException {
AssignmentListContext _localctx = new AssignmentListContext(_ctx, getState());
enterRule(_localctx, 118, RULE_assignmentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2047);
assignment();
setState(2052);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2048);
match(COMMA);
setState(2049);
assignment();
}
}
setState(2054);
_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 SqlBaseParserListener ) ((SqlBaseParserListener)listener).enterAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseParserListener ) ((SqlBaseParserListener)listener).exitAssignment(this);
}
@Override
public 