org.kinotic.structures.sql.antlr.StructuresSqlParserParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of structures-sql Show documentation
Show all versions of structures-sql Show documentation
Framework for data storage and retrieval, supporting schema evolution!
// Generated from /Users/navid/workspace/git/continuum/structures/structures-sql/src/main/resources/antlr/StructuresSqlParser.g4 by ANTLR 4.13.1
package org.kinotic.structures.sql.antlr;
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", "CheckReturnValue"})
public class StructuresSqlParserParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, ABSENT=1, ADD=2, ADMIN=3, AFTER=4, ALL=5, ALTER=6,
ANALYZE=7, AND=8, ANY=9, ARRAY=10, AS=11, ASC=12, AT=13, AUTHORIZATION=14,
BEGIN=15, BERNOULLI=16, BETWEEN=17, BOTH=18, BY=19, CALL=20, CALLED=21,
CASCADE=22, CASE=23, CAST=24, CATALOG=25, CATALOGS=26, COLUMN=27, COLUMNS=28,
COMMENT=29, COMMIT=30, COMMITTED=31, CONDITIONAL=32, CONSTRAINT=33, COUNT=34,
COPARTITION=35, CREATE=36, CROSS=37, CUBE=38, CURRENT=39, CURRENT_CATALOG=40,
CURRENT_DATE=41, CURRENT_PATH=42, CURRENT_ROLE=43, CURRENT_SCHEMA=44,
CURRENT_TIME=45, CURRENT_TIMESTAMP=46, CURRENT_USER=47, DATA=48, DATE=49,
DAY=50, DEALLOCATE=51, DECLARE=52, DEFAULT=53, DEFINE=54, DEFINER=55,
DELETE=56, DENY=57, DESC=58, DESCRIBE=59, DESCRIPTOR=60, DETERMINISTIC=61,
DISTINCT=62, DISTRIBUTED=63, DO=64, DOUBLE=65, DROP=66, ELSE=67, EMPTY=68,
ELSEIF=69, ENCODING=70, END=71, ERROR=72, ESCAPE=73, EXCEPT=74, EXCLUDING=75,
EXECUTE=76, EXISTS=77, EXPLAIN=78, EXTRACT=79, FALSE=80, FETCH=81, FILTER=82,
FINAL=83, FIRST=84, FOLLOWING=85, FOR=86, FORMAT=87, FROM=88, FULL=89,
FUNCTION=90, FUNCTIONS=91, GRACE=92, GRANT=93, GRANTED=94, GRANTS=95,
GRAPHVIZ=96, GROUP=97, GROUPING=98, GROUPS=99, HAVING=100, HOUR=101, IF=102,
IGNORE=103, IMMEDIATE=104, IN=105, INCLUDING=106, INITIAL=107, INNER=108,
INPUT=109, INSERT=110, INTERSECT=111, INTERVAL=112, INTO=113, INVOKER=114,
IO=115, IS=116, ISOLATION=117, ITERATE=118, JOIN=119, JSON=120, JSON_ARRAY=121,
JSON_EXISTS=122, JSON_OBJECT=123, JSON_QUERY=124, JSON_TABLE=125, JSON_VALUE=126,
KEEP=127, KEY=128, KEYS=129, LANGUAGE=130, LAST=131, LATERAL=132, LEADING=133,
LEAVE=134, LEFT=135, LEVEL=136, LIKE=137, LIMIT=138, LISTAGG=139, LOCAL=140,
LOCALTIME=141, LOCALTIMESTAMP=142, LOGICAL=143, LOOP=144, MAP=145, MATCH=146,
MATCHED=147, MATCHES=148, MATCH_RECOGNIZE=149, MATERIALIZED=150, MEASURES=151,
MERGE=152, MINUTE=153, MONTH=154, NATURAL=155, NESTED=156, NEXT=157, NFC=158,
NFD=159, NFKC=160, NFKD=161, NO=162, NONE=163, NORMALIZE=164, NOT=165,
NULL=166, NULLIF=167, NULLS=168, OBJECT=169, OF=170, OFFSET=171, OMIT=172,
ON=173, ONE=174, ONLY=175, OPTION=176, OR=177, ORDER=178, ORDINALITY=179,
OUTER=180, OUTPUT=181, OVER=182, OVERFLOW=183, PARTITION=184, PARTITIONS=185,
PASSING=186, PAST=187, PATH=188, PATTERN=189, PER=190, PERIOD=191, PERMUTE=192,
PLAN=193, POSITION=194, PRECEDING=195, PRECISION=196, PREPARE=197, PRIVILEGES=198,
PROPERTIES=199, PRUNE=200, QUOTES=201, RANGE=202, READ=203, RECURSIVE=204,
REFRESH=205, RENAME=206, REPEAT=207, REPEATABLE=208, REPLACE=209, RESET=210,
RESPECT=211, RESTRICT=212, RETURN=213, RETURNING=214, RETURNS=215, REVOKE=216,
RIGHT=217, ROLE=218, ROLES=219, ROLLBACK=220, ROLLUP=221, ROW=222, ROWS=223,
RUNNING=224, SCALAR=225, SCHEMA=226, SCHEMAS=227, SECOND=228, SECURITY=229,
SEEK=230, SELECT=231, SERIALIZABLE=232, SESSION=233, SET=234, SETS=235,
SHOW=236, SOME=237, START=238, STATS=239, SUBSET=240, SUBSTRING=241, SYSTEM=242,
TABLE=243, TABLES=244, TABLESAMPLE=245, TEXT=246, TEXT_STRING=247, THEN=248,
TIES=249, TIME=250, TIMESTAMP=251, TO=252, TRAILING=253, TRANSACTION=254,
TRIM=255, TRUE=256, TRUNCATE=257, TRY_CAST=258, TYPE=259, UESCAPE=260,
UNBOUNDED=261, UNCOMMITTED=262, UNCONDITIONAL=263, UNION=264, UNIQUE=265,
UNKNOWN=266, UNMATCHED=267, UNNEST=268, UNTIL=269, UPDATE=270, USE=271,
USER=272, USING=273, UTF16=274, UTF32=275, UTF8=276, VALIDATE=277, VALUE=278,
VALUES=279, VERBOSE=280, VERSION=281, VIEW=282, WHEN=283, WHERE=284, WHILE=285,
WINDOW=286, WITH=287, WITHIN=288, WITHOUT=289, WORK=290, WRAPPER=291,
WRITE=292, YEAR=293, ZONE=294, EQ=295, NEQ=296, LT=297, LTE=298, GT=299,
GTE=300, PLUS=301, MINUS=302, ASTERISK=303, SLASH=304, PERCENT=305, CONCAT=306,
QUESTION_MARK=307, SEMICOLON=308, STRING=309, UNICODE_STRING=310, BINARY_LITERAL=311,
INTEGER_VALUE=312, DECIMAL_VALUE=313, DOUBLE_VALUE=314, IDENTIFIER=315,
DIGIT_IDENTIFIER=316, QUOTED_IDENTIFIER=317, BACKQUOTED_IDENTIFIER=318,
SIMPLE_COMMENT=319, BRACKETED_COMMENT=320, WS=321, UNRECOGNIZED=322, DELIMITER=323;
public static final int
RULE_singleStatement = 0, RULE_standaloneExpression = 1, RULE_standalonePathSpecification = 2,
RULE_standaloneType = 3, RULE_standaloneRowPattern = 4, RULE_standaloneFunctionSpecification = 5,
RULE_statement = 6, RULE_rootQuery = 7, RULE_withFunction = 8, RULE_query = 9,
RULE_with = 10, RULE_tableElement = 11, RULE_columnDefinition = 12, RULE_likeClause = 13,
RULE_properties = 14, RULE_propertyAssignments = 15, RULE_property = 16,
RULE_propertyValue = 17, RULE_queryNoWith = 18, RULE_limitRowCount = 19,
RULE_rowCount = 20, RULE_queryTerm = 21, RULE_queryPrimary = 22, RULE_sortItem = 23,
RULE_querySpecification = 24, RULE_groupBy = 25, RULE_groupingElement = 26,
RULE_groupingSet = 27, RULE_windowDefinition = 28, RULE_windowSpecification = 29,
RULE_namedQuery = 30, RULE_setQuantifier = 31, RULE_selectItem = 32, RULE_relation = 33,
RULE_joinType = 34, RULE_joinCriteria = 35, RULE_sampledRelation = 36,
RULE_sampleType = 37, RULE_trimsSpecification = 38, RULE_listAggOverflowBehavior = 39,
RULE_listaggCountIndication = 40, RULE_patternRecognition = 41, RULE_measureDefinition = 42,
RULE_rowsPerMatch = 43, RULE_emptyMatchHandling = 44, RULE_skipTo = 45,
RULE_subsetDefinition = 46, RULE_variableDefinition = 47, RULE_aliasedRelation = 48,
RULE_columnAliases = 49, RULE_relationPrimary = 50, RULE_jsonTableColumn = 51,
RULE_jsonTableSpecificPlan = 52, RULE_jsonTablePathName = 53, RULE_planPrimary = 54,
RULE_jsonTableDefaultPlan = 55, RULE_tableFunctionCall = 56, RULE_tableFunctionArgument = 57,
RULE_tableArgument = 58, RULE_tableArgumentRelation = 59, RULE_descriptorArgument = 60,
RULE_descriptorField = 61, RULE_copartitionTables = 62, RULE_expression = 63,
RULE_booleanExpression = 64, RULE_predicate = 65, RULE_valueExpression = 66,
RULE_primaryExpression = 67, RULE_jsonPathInvocation = 68, RULE_jsonValueExpression = 69,
RULE_jsonRepresentation = 70, RULE_jsonArgument = 71, RULE_jsonExistsErrorBehavior = 72,
RULE_jsonValueBehavior = 73, RULE_jsonQueryWrapperBehavior = 74, RULE_jsonQueryBehavior = 75,
RULE_jsonObjectMember = 76, RULE_processingMode = 77, RULE_nullTreatment = 78,
RULE_string = 79, RULE_timeZoneSpecifier = 80, RULE_comparisonOperator = 81,
RULE_comparisonQuantifier = 82, RULE_booleanValue = 83, RULE_interval = 84,
RULE_intervalField = 85, RULE_normalForm = 86, RULE_type = 87, RULE_rowField = 88,
RULE_typeParameter = 89, RULE_whenClause = 90, RULE_filter = 91, RULE_mergeCase = 92,
RULE_over = 93, RULE_windowFrame = 94, RULE_frameExtent = 95, RULE_frameBound = 96,
RULE_rowPattern = 97, RULE_patternPrimary = 98, RULE_patternQuantifier = 99,
RULE_updateAssignment = 100, RULE_explainOption = 101, RULE_transactionMode = 102,
RULE_levelOfIsolation = 103, RULE_callArgument = 104, RULE_pathElement = 105,
RULE_pathSpecification = 106, RULE_functionSpecification = 107, RULE_functionDeclaration = 108,
RULE_parameterDeclaration = 109, RULE_returnsClause = 110, RULE_routineCharacteristic = 111,
RULE_controlStatement = 112, RULE_caseStatementWhenClause = 113, RULE_elseIfClause = 114,
RULE_elseClause = 115, RULE_variableDeclaration = 116, RULE_sqlStatementList = 117,
RULE_privilege = 118, RULE_entityKind = 119, RULE_grantObject = 120, RULE_qualifiedName = 121,
RULE_queryPeriod = 122, RULE_rangeType = 123, RULE_grantor = 124, RULE_principal = 125,
RULE_roles = 126, RULE_privilegeOrRole = 127, RULE_identifier = 128, RULE_number = 129,
RULE_authorizationUser = 130, RULE_nonReserved = 131;
private static String[] makeRuleNames() {
return new String[] {
"singleStatement", "standaloneExpression", "standalonePathSpecification",
"standaloneType", "standaloneRowPattern", "standaloneFunctionSpecification",
"statement", "rootQuery", "withFunction", "query", "with", "tableElement",
"columnDefinition", "likeClause", "properties", "propertyAssignments",
"property", "propertyValue", "queryNoWith", "limitRowCount", "rowCount",
"queryTerm", "queryPrimary", "sortItem", "querySpecification", "groupBy",
"groupingElement", "groupingSet", "windowDefinition", "windowSpecification",
"namedQuery", "setQuantifier", "selectItem", "relation", "joinType",
"joinCriteria", "sampledRelation", "sampleType", "trimsSpecification",
"listAggOverflowBehavior", "listaggCountIndication", "patternRecognition",
"measureDefinition", "rowsPerMatch", "emptyMatchHandling", "skipTo",
"subsetDefinition", "variableDefinition", "aliasedRelation", "columnAliases",
"relationPrimary", "jsonTableColumn", "jsonTableSpecificPlan", "jsonTablePathName",
"planPrimary", "jsonTableDefaultPlan", "tableFunctionCall", "tableFunctionArgument",
"tableArgument", "tableArgumentRelation", "descriptorArgument", "descriptorField",
"copartitionTables", "expression", "booleanExpression", "predicate",
"valueExpression", "primaryExpression", "jsonPathInvocation", "jsonValueExpression",
"jsonRepresentation", "jsonArgument", "jsonExistsErrorBehavior", "jsonValueBehavior",
"jsonQueryWrapperBehavior", "jsonQueryBehavior", "jsonObjectMember",
"processingMode", "nullTreatment", "string", "timeZoneSpecifier", "comparisonOperator",
"comparisonQuantifier", "booleanValue", "interval", "intervalField",
"normalForm", "type", "rowField", "typeParameter", "whenClause", "filter",
"mergeCase", "over", "windowFrame", "frameExtent", "frameBound", "rowPattern",
"patternPrimary", "patternQuantifier", "updateAssignment", "explainOption",
"transactionMode", "levelOfIsolation", "callArgument", "pathElement",
"pathSpecification", "functionSpecification", "functionDeclaration",
"parameterDeclaration", "returnsClause", "routineCharacteristic", "controlStatement",
"caseStatementWhenClause", "elseIfClause", "elseClause", "variableDeclaration",
"sqlStatementList", "privilege", "entityKind", "grantObject", "qualifiedName",
"queryPeriod", "rangeType", "grantor", "principal", "roles", "privilegeOrRole",
"identifier", "number", "authorizationUser", "nonReserved"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'ABSENT'", "'ADD'", "'ADMIN'", "'AFTER'", "'ALL'", "'ALTER'",
"'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORIZATION'",
"'BEGIN'", "'BERNOULLI'", "'BETWEEN'", "'BOTH'", "'BY'", "'CALL'", "'CALLED'",
"'CASCADE'", "'CASE'", "'CAST'", "'CATALOG'", "'CATALOGS'", "'COLUMN'",
"'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMMITTED'", "'CONDITIONAL'",
"'CONSTRAINT'", "'COUNT'", "'COPARTITION'", "'CREATE'", "'CROSS'", "'CUBE'",
"'CURRENT'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", "'CURRENT_PATH'",
"'CURRENT_ROLE'", "'CURRENT_SCHEMA'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'",
"'CURRENT_USER'", "'DATA'", "'DATE'", "'DAY'", "'DEALLOCATE'", "'DECLARE'",
"'DEFAULT'", "'DEFINE'", "'DEFINER'", "'DELETE'", "'DENY'", "'DESC'",
"'DESCRIBE'", "'DESCRIPTOR'", "'DETERMINISTIC'", "'DISTINCT'", "'DISTRIBUTED'",
"'DO'", "'DOUBLE'", "'DROP'", "'ELSE'", "'EMPTY'", "'ELSEIF'", "'ENCODING'",
"'END'", "'ERROR'", "'ESCAPE'", "'EXCEPT'", "'EXCLUDING'", "'EXECUTE'",
"'EXISTS'", "'EXPLAIN'", "'EXTRACT'", "'FALSE'", "'FETCH'", "'FILTER'",
"'FINAL'", "'FIRST'", "'FOLLOWING'", "'FOR'", "'FORMAT'", "'FROM'", "'FULL'",
"'FUNCTION'", "'FUNCTIONS'", "'GRACE'", "'GRANT'", "'GRANTED'", "'GRANTS'",
"'GRAPHVIZ'", "'GROUP'", "'GROUPING'", "'GROUPS'", "'HAVING'", "'HOUR'",
"'IF'", "'IGNORE'", "'IMMEDIATE'", "'IN'", "'INCLUDING'", "'INITIAL'",
"'INNER'", "'INPUT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INTO'",
"'INVOKER'", "'IO'", "'IS'", "'ISOLATION'", "'ITERATE'", "'JOIN'", "'JSON'",
"'JSON_ARRAY'", "'JSON_EXISTS'", "'JSON_OBJECT'", "'JSON_QUERY'", "'JSON_TABLE'",
"'JSON_VALUE'", "'KEEP'", "'KEY'", "'KEYS'", "'LANGUAGE'", "'LAST'",
"'LATERAL'", "'LEADING'", "'LEAVE'", "'LEFT'", "'LEVEL'", "'LIKE'", "'LIMIT'",
"'LISTAGG'", "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'LOGICAL'",
"'LOOP'", "'MAP'", "'MATCH'", "'MATCHED'", "'MATCHES'", "'MATCH_RECOGNIZE'",
"'MATERIALIZED'", "'MEASURES'", "'MERGE'", "'MINUTE'", "'MONTH'", "'NATURAL'",
"'NESTED'", "'NEXT'", "'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'NO'", "'NONE'",
"'NORMALIZE'", "'NOT'", "'NULL'", "'NULLIF'", "'NULLS'", "'OBJECT'",
"'OF'", "'OFFSET'", "'OMIT'", "'ON'", "'ONE'", "'ONLY'", "'OPTION'",
"'OR'", "'ORDER'", "'ORDINALITY'", "'OUTER'", "'OUTPUT'", "'OVER'", "'OVERFLOW'",
"'PARTITION'", "'PARTITIONS'", "'PASSING'", "'PAST'", "'PATH'", "'PATTERN'",
"'PER'", "'PERIOD'", "'PERMUTE'", "'PLAN'", "'POSITION'", "'PRECEDING'",
"'PRECISION'", "'PREPARE'", "'PRIVILEGES'", "'PROPERTIES'", "'PRUNE'",
"'QUOTES'", "'RANGE'", "'READ'", "'RECURSIVE'", "'REFRESH'", "'RENAME'",
"'REPEAT'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'", "'RESTRICT'",
"'RETURN'", "'RETURNING'", "'RETURNS'", "'REVOKE'", "'RIGHT'", "'ROLE'",
"'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'RUNNING'",
"'SCALAR'", "'SCHEMA'", "'SCHEMAS'", "'SECOND'", "'SECURITY'", "'SEEK'",
"'SELECT'", "'SERIALIZABLE'", "'SESSION'", "'SET'", "'SETS'", "'SHOW'",
"'SOME'", "'START'", "'STATS'", "'SUBSET'", "'SUBSTRING'", "'SYSTEM'",
"'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TEXT'", "'STRING'", "'THEN'",
"'TIES'", "'TIME'", "'TIMESTAMP'", "'TO'", "'TRAILING'", "'TRANSACTION'",
"'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'", "'TYPE'", "'UESCAPE'",
"'UNBOUNDED'", "'UNCOMMITTED'", "'UNCONDITIONAL'", "'UNION'", "'UNIQUE'",
"'UNKNOWN'", "'UNMATCHED'", "'UNNEST'", "'UNTIL'", "'UPDATE'", "'USE'",
"'USER'", "'USING'", "'UTF16'", "'UTF32'", "'UTF8'", "'VALIDATE'", "'VALUE'",
"'VALUES'", "'VERBOSE'", "'VERSION'", "'VIEW'", "'WHEN'", "'WHERE'",
"'WHILE'", "'WINDOW'", "'WITH'", "'WITHIN'", "'WITHOUT'", "'WORK'", "'WRAPPER'",
"'WRITE'", "'YEAR'", "'ZONE'", "'='", null, null, "'<='", null, "'>='",
"'+'", "'-'", "'*'", "'/'", "'%'", "'||'", "'?'", "';'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, "CALL", "CALLED", "CASCADE",
"CASE", "CAST", "CATALOG", "CATALOGS", "COLUMN", "COLUMNS", "COMMENT",
"COMMIT", "COMMITTED", "CONDITIONAL", "CONSTRAINT", "COUNT", "COPARTITION",
"CREATE", "CROSS", "CUBE", "CURRENT", "CURRENT_CATALOG", "CURRENT_DATE",
"CURRENT_PATH", "CURRENT_ROLE", "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP",
"CURRENT_USER", "DATA", "DATE", "DAY", "DEALLOCATE", "DECLARE", "DEFAULT",
"DEFINE", "DEFINER", "DELETE", "DENY", "DESC", "DESCRIBE", "DESCRIPTOR",
"DETERMINISTIC", "DISTINCT", "DISTRIBUTED", "DO", "DOUBLE", "DROP", "ELSE",
"EMPTY", "ELSEIF", "ENCODING", "END", "ERROR", "ESCAPE", "EXCEPT", "EXCLUDING",
"EXECUTE", "EXISTS", "EXPLAIN", "EXTRACT", "FALSE", "FETCH", "FILTER",
"FINAL", "FIRST", "FOLLOWING", "FOR", "FORMAT", "FROM", "FULL", "FUNCTION",
"FUNCTIONS", "GRACE", "GRANT", "GRANTED", "GRANTS", "GRAPHVIZ", "GROUP",
"GROUPING", "GROUPS", "HAVING", "HOUR", "IF", "IGNORE", "IMMEDIATE",
"IN", "INCLUDING", "INITIAL", "INNER", "INPUT", "INSERT", "INTERSECT",
"INTERVAL", "INTO", "INVOKER", "IO", "IS", "ISOLATION", "ITERATE", "JOIN",
"JSON", "JSON_ARRAY", "JSON_EXISTS", "JSON_OBJECT", "JSON_QUERY", "JSON_TABLE",
"JSON_VALUE", "KEEP", "KEY", "KEYS", "LANGUAGE", "LAST", "LATERAL", "LEADING",
"LEAVE", "LEFT", "LEVEL", "LIKE", "LIMIT", "LISTAGG", "LOCAL", "LOCALTIME",
"LOCALTIMESTAMP", "LOGICAL", "LOOP", "MAP", "MATCH", "MATCHED", "MATCHES",
"MATCH_RECOGNIZE", "MATERIALIZED", "MEASURES", "MERGE", "MINUTE", "MONTH",
"NATURAL", "NESTED", "NEXT", "NFC", "NFD", "NFKC", "NFKD", "NO", "NONE",
"NORMALIZE", "NOT", "NULL", "NULLIF", "NULLS", "OBJECT", "OF", "OFFSET",
"OMIT", "ON", "ONE", "ONLY", "OPTION", "OR", "ORDER", "ORDINALITY", "OUTER",
"OUTPUT", "OVER", "OVERFLOW", "PARTITION", "PARTITIONS", "PASSING", "PAST",
"PATH", "PATTERN", "PER", "PERIOD", "PERMUTE", "PLAN", "POSITION", "PRECEDING",
"PRECISION", "PREPARE", "PRIVILEGES", "PROPERTIES", "PRUNE", "QUOTES",
"RANGE", "READ", "RECURSIVE", "REFRESH", "RENAME", "REPEAT", "REPEATABLE",
"REPLACE", "RESET", "RESPECT", "RESTRICT", "RETURN", "RETURNING", "RETURNS",
"REVOKE", "RIGHT", "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROW", "ROWS",
"RUNNING", "SCALAR", "SCHEMA", "SCHEMAS", "SECOND", "SECURITY", "SEEK",
"SELECT", "SERIALIZABLE", "SESSION", "SET", "SETS", "SHOW", "SOME", "START",
"STATS", "SUBSET", "SUBSTRING", "SYSTEM", "TABLE", "TABLES", "TABLESAMPLE",
"TEXT", "TEXT_STRING", "THEN", "TIES", "TIME", "TIMESTAMP", "TO", "TRAILING",
"TRANSACTION", "TRIM", "TRUE", "TRUNCATE", "TRY_CAST", "TYPE", "UESCAPE",
"UNBOUNDED", "UNCOMMITTED", "UNCONDITIONAL", "UNION", "UNIQUE", "UNKNOWN",
"UNMATCHED", "UNNEST", "UNTIL", "UPDATE", "USE", "USER", "USING", "UTF16",
"UTF32", "UTF8", "VALIDATE", "VALUE", "VALUES", "VERBOSE", "VERSION",
"VIEW", "WHEN", "WHERE", "WHILE", "WINDOW", "WITH", "WITHIN", "WITHOUT",
"WORK", "WRAPPER", "WRITE", "YEAR", "ZONE", "EQ", "NEQ", "LT", "LTE",
"GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "CONCAT",
"QUESTION_MARK", "SEMICOLON", "STRING", "UNICODE_STRING", "BINARY_LITERAL",
"INTEGER_VALUE", "DECIMAL_VALUE", "DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER",
"QUOTED_IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT",
"WS", "UNRECOGNIZED", "DELIMITER"
};
}
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 "StructuresSqlParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public StructuresSqlParserParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class SingleStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public SingleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSingleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SingleStatementContext singleStatement() throws RecognitionException {
SingleStatementContext _localctx = new SingleStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_singleStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(264);
statement();
setState(265);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StandaloneExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public StandaloneExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standaloneExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStandaloneExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStandaloneExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStandaloneExpression(this);
else return visitor.visitChildren(this);
}
}
public final StandaloneExpressionContext standaloneExpression() throws RecognitionException {
StandaloneExpressionContext _localctx = new StandaloneExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_standaloneExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(267);
expression();
setState(268);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StandalonePathSpecificationContext extends ParserRuleContext {
public PathSpecificationContext pathSpecification() {
return getRuleContext(PathSpecificationContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public StandalonePathSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standalonePathSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStandalonePathSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStandalonePathSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStandalonePathSpecification(this);
else return visitor.visitChildren(this);
}
}
public final StandalonePathSpecificationContext standalonePathSpecification() throws RecognitionException {
StandalonePathSpecificationContext _localctx = new StandalonePathSpecificationContext(_ctx, getState());
enterRule(_localctx, 4, RULE_standalonePathSpecification);
try {
enterOuterAlt(_localctx, 1);
{
setState(270);
pathSpecification();
setState(271);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StandaloneTypeContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public StandaloneTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standaloneType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStandaloneType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStandaloneType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStandaloneType(this);
else return visitor.visitChildren(this);
}
}
public final StandaloneTypeContext standaloneType() throws RecognitionException {
StandaloneTypeContext _localctx = new StandaloneTypeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_standaloneType);
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
type(0);
setState(274);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StandaloneRowPatternContext extends ParserRuleContext {
public RowPatternContext rowPattern() {
return getRuleContext(RowPatternContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public StandaloneRowPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standaloneRowPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStandaloneRowPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStandaloneRowPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStandaloneRowPattern(this);
else return visitor.visitChildren(this);
}
}
public final StandaloneRowPatternContext standaloneRowPattern() throws RecognitionException {
StandaloneRowPatternContext _localctx = new StandaloneRowPatternContext(_ctx, getState());
enterRule(_localctx, 8, RULE_standaloneRowPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
rowPattern(0);
setState(277);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StandaloneFunctionSpecificationContext extends ParserRuleContext {
public FunctionSpecificationContext functionSpecification() {
return getRuleContext(FunctionSpecificationContext.class,0);
}
public TerminalNode EOF() { return getToken(StructuresSqlParserParser.EOF, 0); }
public StandaloneFunctionSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standaloneFunctionSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStandaloneFunctionSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStandaloneFunctionSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStandaloneFunctionSpecification(this);
else return visitor.visitChildren(this);
}
}
public final StandaloneFunctionSpecificationContext standaloneFunctionSpecification() throws RecognitionException {
StandaloneFunctionSpecificationContext _localctx = new StandaloneFunctionSpecificationContext(_ctx, getState());
enterRule(_localctx, 10, RULE_standaloneFunctionSpecification);
try {
enterOuterAlt(_localctx, 1);
{
setState(279);
functionSpecification();
setState(280);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StatementDefaultContext extends StatementContext {
public RootQueryContext rootQuery() {
return getRuleContext(RootQueryContext.class,0);
}
public StatementDefaultContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStatementDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStatementDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStatementDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UseContext extends StatementContext {
public IdentifierContext schema;
public IdentifierContext catalog;
public TerminalNode USE() { return getToken(StructuresSqlParserParser.USE, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public UseContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterUse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitUse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitUse(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UpdateContext extends StatementContext {
public BooleanExpressionContext where;
public TerminalNode UPDATE() { return getToken(StructuresSqlParserParser.UPDATE, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode SET() { return getToken(StructuresSqlParserParser.SET, 0); }
public List updateAssignment() {
return getRuleContexts(UpdateAssignmentContext.class);
}
public UpdateAssignmentContext updateAssignment(int i) {
return getRuleContext(UpdateAssignmentContext.class,i);
}
public TerminalNode WHERE() { return getToken(StructuresSqlParserParser.WHERE, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public UpdateContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitUpdate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitUpdate(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 12, RULE_statement);
int _la;
try {
setState(305);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
_localctx = new StatementDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(282);
rootQuery();
}
break;
case 2:
_localctx = new UseContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(283);
match(USE);
setState(284);
((UseContext)_localctx).schema = identifier();
}
break;
case 3:
_localctx = new UseContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(285);
match(USE);
setState(286);
((UseContext)_localctx).catalog = identifier();
setState(287);
match(T__0);
setState(288);
((UseContext)_localctx).schema = identifier();
}
break;
case 4:
_localctx = new UpdateContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(290);
match(UPDATE);
setState(291);
qualifiedName();
setState(292);
match(SET);
setState(293);
updateAssignment();
setState(298);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(294);
match(T__1);
setState(295);
updateAssignment();
}
}
setState(300);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(301);
match(WHERE);
setState(302);
((UpdateContext)_localctx).where = booleanExpression(0);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RootQueryContext extends ParserRuleContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public WithFunctionContext withFunction() {
return getRuleContext(WithFunctionContext.class,0);
}
public RootQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rootQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRootQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRootQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRootQuery(this);
else return visitor.visitChildren(this);
}
}
public final RootQueryContext rootQuery() throws RecognitionException {
RootQueryContext _localctx = new RootQueryContext(_ctx, getState());
enterRule(_localctx, 14, RULE_rootQuery);
try {
enterOuterAlt(_localctx, 1);
{
setState(308);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
setState(307);
withFunction();
}
break;
}
setState(310);
query();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithFunctionContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public List functionSpecification() {
return getRuleContexts(FunctionSpecificationContext.class);
}
public FunctionSpecificationContext functionSpecification(int i) {
return getRuleContext(FunctionSpecificationContext.class,i);
}
public WithFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterWithFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitWithFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitWithFunction(this);
else return visitor.visitChildren(this);
}
}
public final WithFunctionContext withFunction() throws RecognitionException {
WithFunctionContext _localctx = new WithFunctionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_withFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(312);
match(WITH);
setState(313);
functionSpecification();
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(314);
match(T__1);
setState(315);
functionSpecification();
}
}
setState(320);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryContext extends ParserRuleContext {
public QueryNoWithContext queryNoWith() {
return getRuleContext(QueryNoWithContext.class,0);
}
public WithContext with() {
return getRuleContext(WithContext.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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQuery(this);
else return visitor.visitChildren(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 18, RULE_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(321);
with();
}
}
setState(324);
queryNoWith();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public List namedQuery() {
return getRuleContexts(NamedQueryContext.class);
}
public NamedQueryContext namedQuery(int i) {
return getRuleContext(NamedQueryContext.class,i);
}
public TerminalNode RECURSIVE() { return getToken(StructuresSqlParserParser.RECURSIVE, 0); }
public WithContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterWith(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitWith(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitWith(this);
else return visitor.visitChildren(this);
}
}
public final WithContext with() throws RecognitionException {
WithContext _localctx = new WithContext(_ctx, getState());
enterRule(_localctx, 20, RULE_with);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
match(WITH);
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECURSIVE) {
{
setState(327);
match(RECURSIVE);
}
}
setState(330);
namedQuery();
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(331);
match(T__1);
setState(332);
namedQuery();
}
}
setState(337);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class TableElementContext extends ParserRuleContext {
public ColumnDefinitionContext columnDefinition() {
return getRuleContext(ColumnDefinitionContext.class,0);
}
public LikeClauseContext likeClause() {
return getRuleContext(LikeClauseContext.class,0);
}
public TableElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableElement(this);
else return visitor.visitChildren(this);
}
}
public final TableElementContext tableElement() throws RecognitionException {
TableElementContext _localctx = new TableElementContext(_ctx, getState());
enterRule(_localctx, 22, RULE_tableElement);
try {
setState(340);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__6:
case T__8:
case T__9:
case T__11:
case T__12:
case T__13:
case T__14:
case T__15:
case T__17:
case CALL:
case CALLED:
case CASCADE:
case CATALOG:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CONDITIONAL:
case COUNT:
case COPARTITION:
case CURRENT:
case DATA:
case DATE:
case DAY:
case DECLARE:
case DEFAULT:
case DEFINE:
case DEFINER:
case DENY:
case DESC:
case DESCRIPTOR:
case DETERMINISTIC:
case DISTRIBUTED:
case DO:
case DOUBLE:
case EMPTY:
case ELSEIF:
case ENCODING:
case ERROR:
case EXCLUDING:
case EXPLAIN:
case FETCH:
case FILTER:
case FINAL:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTION:
case FUNCTIONS:
case GRACE:
case GRANT:
case GRANTED:
case GRANTS:
case GRAPHVIZ:
case GROUPS:
case HOUR:
case IF:
case IGNORE:
case IMMEDIATE:
case INCLUDING:
case INITIAL:
case INPUT:
case INTERVAL:
case INVOKER:
case IO:
case ISOLATION:
case ITERATE:
case JSON:
case KEEP:
case KEY:
case KEYS:
case LANGUAGE:
case LAST:
case LATERAL:
case LEADING:
case LEAVE:
case LEVEL:
case LIMIT:
case LOCAL:
case LOGICAL:
case LOOP:
case MAP:
case MATCH:
case MATCHED:
case MATCHES:
case MATCH_RECOGNIZE:
case MATERIALIZED:
case MEASURES:
case MERGE:
case MINUTE:
case MONTH:
case NESTED:
case NEXT:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NONE:
case NULLIF:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case OMIT:
case ONE:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case OVERFLOW:
case PARTITION:
case PARTITIONS:
case PASSING:
case PAST:
case PATH:
case PATTERN:
case PER:
case PERIOD:
case PERMUTE:
case PLAN:
case POSITION:
case PRECEDING:
case PRECISION:
case PRIVILEGES:
case PROPERTIES:
case PRUNE:
case QUOTES:
case RANGE:
case READ:
case REFRESH:
case RENAME:
case REPEAT:
case REPEATABLE:
case REPLACE:
case RESET:
case RESPECT:
case RESTRICT:
case RETURN:
case RETURNING:
case RETURNS:
case REVOKE:
case ROLE:
case ROLES:
case ROLLBACK:
case ROW:
case ROWS:
case RUNNING:
case SCALAR:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SECURITY:
case SEEK:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSET:
case SUBSTRING:
case SYSTEM:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TEXT_STRING:
case TIES:
case TIME:
case TIMESTAMP:
case TO:
case TRAILING:
case TRANSACTION:
case TRUNCATE:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case UNCONDITIONAL:
case UNIQUE:
case UNKNOWN:
case UNMATCHED:
case UNTIL:
case UPDATE:
case USE:
case USER:
case UTF16:
case UTF32:
case UTF8:
case VALIDATE:
case VALUE:
case VERBOSE:
case VERSION:
case VIEW:
case WHILE:
case WINDOW:
case WITHIN:
case WITHOUT:
case WORK:
case WRAPPER:
case WRITE:
case YEAR:
case ZONE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(338);
columnDefinition();
}
break;
case LIKE:
enterOuterAlt(_localctx, 2);
{
setState(339);
likeClause();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnDefinitionContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public TerminalNode COMMENT() { return getToken(StructuresSqlParserParser.COMMENT, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public PropertiesContext properties() {
return getRuleContext(PropertiesContext.class,0);
}
public ColumnDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterColumnDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitColumnDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitColumnDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ColumnDefinitionContext columnDefinition() throws RecognitionException {
ColumnDefinitionContext _localctx = new ColumnDefinitionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_columnDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(342);
qualifiedName();
setState(343);
type(0);
setState(346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(344);
match(NOT);
setState(345);
match(NULL);
}
}
setState(350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(348);
match(COMMENT);
setState(349);
string();
}
}
setState(354);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(352);
match(WITH);
setState(353);
properties();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LikeClauseContext extends ParserRuleContext {
public Token optionType;
public TerminalNode LIKE() { return getToken(StructuresSqlParserParser.LIKE, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode PROPERTIES() { return getToken(StructuresSqlParserParser.PROPERTIES, 0); }
public TerminalNode INCLUDING() { return getToken(StructuresSqlParserParser.INCLUDING, 0); }
public TerminalNode EXCLUDING() { return getToken(StructuresSqlParserParser.EXCLUDING, 0); }
public LikeClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_likeClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLikeClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLikeClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLikeClause(this);
else return visitor.visitChildren(this);
}
}
public final LikeClauseContext likeClause() throws RecognitionException {
LikeClauseContext _localctx = new LikeClauseContext(_ctx, getState());
enterRule(_localctx, 26, RULE_likeClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(356);
match(LIKE);
setState(357);
qualifiedName();
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDING || _la==INCLUDING) {
{
setState(358);
((LikeClauseContext)_localctx).optionType = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXCLUDING || _la==INCLUDING) ) {
((LikeClauseContext)_localctx).optionType = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(359);
match(PROPERTIES);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertiesContext extends ParserRuleContext {
public PropertyAssignmentsContext propertyAssignments() {
return getRuleContext(PropertyAssignmentsContext.class,0);
}
public PropertiesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_properties; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterProperties(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitProperties(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitProperties(this);
else return visitor.visitChildren(this);
}
}
public final PropertiesContext properties() throws RecognitionException {
PropertiesContext _localctx = new PropertiesContext(_ctx, getState());
enterRule(_localctx, 28, RULE_properties);
try {
enterOuterAlt(_localctx, 1);
{
setState(362);
match(T__2);
setState(363);
propertyAssignments();
setState(364);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyAssignmentsContext extends ParserRuleContext {
public List property() {
return getRuleContexts(PropertyContext.class);
}
public PropertyContext property(int i) {
return getRuleContext(PropertyContext.class,i);
}
public PropertyAssignmentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyAssignments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterPropertyAssignments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitPropertyAssignments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitPropertyAssignments(this);
else return visitor.visitChildren(this);
}
}
public final PropertyAssignmentsContext propertyAssignments() throws RecognitionException {
PropertyAssignmentsContext _localctx = new PropertyAssignmentsContext(_ctx, getState());
enterRule(_localctx, 30, RULE_propertyAssignments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(366);
property();
setState(371);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(367);
match(T__1);
setState(368);
property();
}
}
setState(373);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode EQ() { return getToken(StructuresSqlParserParser.EQ, 0); }
public PropertyValueContext propertyValue() {
return getRuleContext(PropertyValueContext.class,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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitProperty(this);
else return visitor.visitChildren(this);
}
}
public final PropertyContext property() throws RecognitionException {
PropertyContext _localctx = new PropertyContext(_ctx, getState());
enterRule(_localctx, 32, RULE_property);
try {
enterOuterAlt(_localctx, 1);
{
setState(374);
identifier();
setState(375);
match(EQ);
setState(376);
propertyValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PropertyValueContext extends ParserRuleContext {
public PropertyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyValue; }
public PropertyValueContext() { }
public void copyFrom(PropertyValueContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DefaultPropertyValueContext extends PropertyValueContext {
public TerminalNode DEFAULT() { return getToken(StructuresSqlParserParser.DEFAULT, 0); }
public DefaultPropertyValueContext(PropertyValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterDefaultPropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitDefaultPropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitDefaultPropertyValue(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NonDefaultPropertyValueContext extends PropertyValueContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NonDefaultPropertyValueContext(PropertyValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNonDefaultPropertyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNonDefaultPropertyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNonDefaultPropertyValue(this);
else return visitor.visitChildren(this);
}
}
public final PropertyValueContext propertyValue() throws RecognitionException {
PropertyValueContext _localctx = new PropertyValueContext(_ctx, getState());
enterRule(_localctx, 34, RULE_propertyValue);
try {
setState(380);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
_localctx = new DefaultPropertyValueContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(378);
match(DEFAULT);
}
break;
case 2:
_localctx = new NonDefaultPropertyValueContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(379);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QueryNoWithContext extends ParserRuleContext {
public RowCountContext offset;
public LimitRowCountContext limit;
public RowCountContext fetchFirst;
public QueryTermContext queryTerm() {
return getRuleContext(QueryTermContext.class,0);
}
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public TerminalNode BY() { return getToken(StructuresSqlParserParser.BY, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public TerminalNode OFFSET() { return getToken(StructuresSqlParserParser.OFFSET, 0); }
public List rowCount() {
return getRuleContexts(RowCountContext.class);
}
public RowCountContext rowCount(int i) {
return getRuleContext(RowCountContext.class,i);
}
public TerminalNode LIMIT() { return getToken(StructuresSqlParserParser.LIMIT, 0); }
public TerminalNode FETCH() { return getToken(StructuresSqlParserParser.FETCH, 0); }
public LimitRowCountContext limitRowCount() {
return getRuleContext(LimitRowCountContext.class,0);
}
public TerminalNode FIRST() { return getToken(StructuresSqlParserParser.FIRST, 0); }
public TerminalNode NEXT() { return getToken(StructuresSqlParserParser.NEXT, 0); }
public List ROW() { return getTokens(StructuresSqlParserParser.ROW); }
public TerminalNode ROW(int i) {
return getToken(StructuresSqlParserParser.ROW, i);
}
public List ROWS() { return getTokens(StructuresSqlParserParser.ROWS); }
public TerminalNode ROWS(int i) {
return getToken(StructuresSqlParserParser.ROWS, i);
}
public TerminalNode ONLY() { return getToken(StructuresSqlParserParser.ONLY, 0); }
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode TIES() { return getToken(StructuresSqlParserParser.TIES, 0); }
public QueryNoWithContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryNoWith; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQueryNoWith(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQueryNoWith(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQueryNoWith(this);
else return visitor.visitChildren(this);
}
}
public final QueryNoWithContext queryNoWith() throws RecognitionException {
QueryNoWithContext _localctx = new QueryNoWithContext(_ctx, getState());
enterRule(_localctx, 36, RULE_queryNoWith);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(382);
queryTerm(0);
setState(393);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(383);
match(ORDER);
setState(384);
match(T__18);
setState(385);
sortItem();
setState(390);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(386);
match(T__1);
setState(387);
sortItem();
}
}
setState(392);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OFFSET) {
{
setState(395);
match(OFFSET);
setState(396);
((QueryNoWithContext)_localctx).offset = rowCount();
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROW || _la==ROWS) {
{
setState(397);
_la = _input.LA(1);
if ( !(_la==ROW || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
setState(415);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
{
{
setState(402);
match(LIMIT);
setState(403);
((QueryNoWithContext)_localctx).limit = limitRowCount();
}
}
break;
case FETCH:
{
{
setState(404);
match(FETCH);
setState(405);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==NEXT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUESTION_MARK || _la==INTEGER_VALUE) {
{
setState(406);
((QueryNoWithContext)_localctx).fetchFirst = rowCount();
}
}
setState(409);
_la = _input.LA(1);
if ( !(_la==ROW || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(413);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ONLY:
{
setState(410);
match(ONLY);
}
break;
case WITH:
{
setState(411);
match(WITH);
setState(412);
match(TIES);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case EOF:
case T__3:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LimitRowCountContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(StructuresSqlParserParser.ALL, 0); }
public RowCountContext rowCount() {
return getRuleContext(RowCountContext.class,0);
}
public LimitRowCountContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitRowCount; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLimitRowCount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLimitRowCount(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLimitRowCount(this);
else return visitor.visitChildren(this);
}
}
public final LimitRowCountContext limitRowCount() throws RecognitionException {
LimitRowCountContext _localctx = new LimitRowCountContext(_ctx, getState());
enterRule(_localctx, 38, RULE_limitRowCount);
try {
setState(419);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__4:
enterOuterAlt(_localctx, 1);
{
setState(417);
match(T__4);
}
break;
case QUESTION_MARK:
case INTEGER_VALUE:
enterOuterAlt(_localctx, 2);
{
setState(418);
rowCount();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RowCountContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(StructuresSqlParserParser.INTEGER_VALUE, 0); }
public TerminalNode QUESTION_MARK() { return getToken(StructuresSqlParserParser.QUESTION_MARK, 0); }
public RowCountContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowCount; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRowCount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRowCount(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRowCount(this);
else return visitor.visitChildren(this);
}
}
public final RowCountContext rowCount() throws RecognitionException {
RowCountContext _localctx = new RowCountContext(_ctx, getState());
enterRule(_localctx, 40, RULE_rowCount);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(421);
_la = _input.LA(1);
if ( !(_la==QUESTION_MARK || _la==INTEGER_VALUE) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
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);
}
}
@SuppressWarnings("CheckReturnValue")
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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQueryTermDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQueryTermDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQueryTermDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
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(StructuresSqlParserParser.INTERSECT, 0); }
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public TerminalNode UNION() { return getToken(StructuresSqlParserParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(StructuresSqlParserParser.EXCEPT, 0); }
public SetOperationContext(QueryTermContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSetOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSetOperation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)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 = 42;
enterRecursionRule(_localctx, 42, RULE_queryTerm, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new QueryTermDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(424);
queryPrimary();
}
_ctx.stop = _input.LT(-1);
setState(440);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(438);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(426);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(427);
((SetOperationContext)_localctx).operator = match(INTERSECT);
setState(429);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4 || _la==DISTINCT) {
{
setState(428);
setQuantifier();
}
}
setState(431);
((SetOperationContext)_localctx).right = queryTerm(3);
}
break;
case 2:
{
_localctx = new SetOperationContext(new QueryTermContext(_parentctx, _parentState));
((SetOperationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_queryTerm);
setState(432);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(433);
((SetOperationContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==UNION) ) {
((SetOperationContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(435);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4 || _la==DISTINCT) {
{
setState(434);
setQuantifier();
}
}
setState(437);
((SetOperationContext)_localctx).right = queryTerm(2);
}
break;
}
}
}
setState(442);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubqueryContext extends QueryPrimaryContext {
public QueryNoWithContext queryNoWith() {
return getRuleContext(QueryNoWithContext.class,0);
}
public SubqueryContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubquery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQueryPrimaryDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQueryPrimaryDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQueryPrimaryDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableContext extends QueryPrimaryContext {
public TerminalNode TABLE() { return getToken(StructuresSqlParserParser.TABLE, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TableContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InlineTableContext extends QueryPrimaryContext {
public TerminalNode VALUES() { return getToken(StructuresSqlParserParser.VALUES, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public InlineTableContext(QueryPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterInlineTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitInlineTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitInlineTable(this);
else return visitor.visitChildren(this);
}
}
public final QueryPrimaryContext queryPrimary() throws RecognitionException {
QueryPrimaryContext _localctx = new QueryPrimaryContext(_ctx, getState());
enterRule(_localctx, 44, RULE_queryPrimary);
try {
int _alt;
setState(459);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
_localctx = new QueryPrimaryDefaultContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(443);
querySpecification();
}
break;
case TABLE:
_localctx = new TableContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(444);
match(TABLE);
setState(445);
qualifiedName();
}
break;
case VALUES:
_localctx = new InlineTableContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(446);
match(VALUES);
setState(447);
expression();
setState(452);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(448);
match(T__1);
setState(449);
expression();
}
}
}
setState(454);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
}
}
break;
case T__2:
_localctx = new SubqueryContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(455);
match(T__2);
setState(456);
queryNoWith();
setState(457);
match(T__3);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SortItemContext extends ParserRuleContext {
public Token ordering;
public Token nullOrdering;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NULLS() { return getToken(StructuresSqlParserParser.NULLS, 0); }
public TerminalNode ASC() { return getToken(StructuresSqlParserParser.ASC, 0); }
public TerminalNode DESC() { return getToken(StructuresSqlParserParser.DESC, 0); }
public TerminalNode FIRST() { return getToken(StructuresSqlParserParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(StructuresSqlParserParser.LAST, 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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSortItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSortItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSortItem(this);
else return visitor.visitChildren(this);
}
}
public final SortItemContext sortItem() throws RecognitionException {
SortItemContext _localctx = new SortItemContext(_ctx, getState());
enterRule(_localctx, 46, RULE_sortItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(461);
expression();
setState(463);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11 || _la==DESC) {
{
setState(462);
((SortItemContext)_localctx).ordering = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==T__11 || _la==DESC) ) {
((SortItemContext)_localctx).ordering = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(467);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(465);
match(NULLS);
setState(466);
((SortItemContext)_localctx).nullOrdering = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
((SortItemContext)_localctx).nullOrdering = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QuerySpecificationContext extends ParserRuleContext {
public BooleanExpressionContext where;
public BooleanExpressionContext having;
public TerminalNode SELECT() { return getToken(StructuresSqlParserParser.SELECT, 0); }
public List selectItem() {
return getRuleContexts(SelectItemContext.class);
}
public SelectItemContext selectItem(int i) {
return getRuleContext(SelectItemContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public TerminalNode FROM() { return getToken(StructuresSqlParserParser.FROM, 0); }
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public TerminalNode WHERE() { return getToken(StructuresSqlParserParser.WHERE, 0); }
public TerminalNode GROUP() { return getToken(StructuresSqlParserParser.GROUP, 0); }
public TerminalNode BY() { return getToken(StructuresSqlParserParser.BY, 0); }
public GroupByContext groupBy() {
return getRuleContext(GroupByContext.class,0);
}
public TerminalNode HAVING() { return getToken(StructuresSqlParserParser.HAVING, 0); }
public TerminalNode WINDOW() { return getToken(StructuresSqlParserParser.WINDOW, 0); }
public List windowDefinition() {
return getRuleContexts(WindowDefinitionContext.class);
}
public WindowDefinitionContext windowDefinition(int i) {
return getRuleContext(WindowDefinitionContext.class,i);
}
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public QuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 48, RULE_querySpecification);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(469);
match(SELECT);
setState(471);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(470);
setQuantifier();
}
break;
}
setState(473);
selectItem();
setState(478);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(474);
match(T__1);
setState(475);
selectItem();
}
}
}
setState(480);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
}
setState(490);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(481);
match(FROM);
setState(482);
relation(0);
setState(487);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(483);
match(T__1);
setState(484);
relation(0);
}
}
}
setState(489);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
}
break;
}
setState(494);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
{
setState(492);
match(WHERE);
setState(493);
((QuerySpecificationContext)_localctx).where = booleanExpression(0);
}
break;
}
setState(499);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(496);
match(GROUP);
setState(497);
match(T__18);
setState(498);
groupBy();
}
break;
}
setState(503);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(501);
match(HAVING);
setState(502);
((QuerySpecificationContext)_localctx).having = booleanExpression(0);
}
break;
}
setState(514);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(505);
match(WINDOW);
setState(506);
windowDefinition();
setState(511);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(507);
match(T__1);
setState(508);
windowDefinition();
}
}
}
setState(513);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GroupByContext extends ParserRuleContext {
public List groupingElement() {
return getRuleContexts(GroupingElementContext.class);
}
public GroupingElementContext groupingElement(int i) {
return getRuleContext(GroupingElementContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public GroupByContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupBy; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterGroupBy(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitGroupBy(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitGroupBy(this);
else return visitor.visitChildren(this);
}
}
public final GroupByContext groupBy() throws RecognitionException {
GroupByContext _localctx = new GroupByContext(_ctx, getState());
enterRule(_localctx, 50, RULE_groupBy);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(517);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
{
setState(516);
setQuantifier();
}
break;
}
setState(519);
groupingElement();
setState(524);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(520);
match(T__1);
setState(521);
groupingElement();
}
}
}
setState(526);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GroupingElementContext extends ParserRuleContext {
public GroupingElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingElement; }
public GroupingElementContext() { }
public void copyFrom(GroupingElementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MultipleGroupingSetsContext extends GroupingElementContext {
public TerminalNode GROUPING() { return getToken(StructuresSqlParserParser.GROUPING, 0); }
public TerminalNode SETS() { return getToken(StructuresSqlParserParser.SETS, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public MultipleGroupingSetsContext(GroupingElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterMultipleGroupingSets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitMultipleGroupingSets(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitMultipleGroupingSets(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SingleGroupingSetContext extends GroupingElementContext {
public GroupingSetContext groupingSet() {
return getRuleContext(GroupingSetContext.class,0);
}
public SingleGroupingSetContext(GroupingElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSingleGroupingSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSingleGroupingSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSingleGroupingSet(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CubeContext extends GroupingElementContext {
public TerminalNode CUBE() { return getToken(StructuresSqlParserParser.CUBE, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public CubeContext(GroupingElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCube(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCube(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCube(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RollupContext extends GroupingElementContext {
public TerminalNode ROLLUP() { return getToken(StructuresSqlParserParser.ROLLUP, 0); }
public List groupingSet() {
return getRuleContexts(GroupingSetContext.class);
}
public GroupingSetContext groupingSet(int i) {
return getRuleContext(GroupingSetContext.class,i);
}
public RollupContext(GroupingElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRollup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRollup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRollup(this);
else return visitor.visitChildren(this);
}
}
public final GroupingElementContext groupingElement() throws RecognitionException {
GroupingElementContext _localctx = new GroupingElementContext(_ctx, getState());
enterRule(_localctx, 52, RULE_groupingElement);
int _la;
try {
setState(567);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
_localctx = new SingleGroupingSetContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(527);
groupingSet();
}
break;
case 2:
_localctx = new RollupContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(528);
match(ROLLUP);
setState(529);
match(T__2);
setState(538);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
{
setState(530);
groupingSet();
setState(535);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(531);
match(T__1);
setState(532);
groupingSet();
}
}
setState(537);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(540);
match(T__3);
}
break;
case 3:
_localctx = new CubeContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(541);
match(CUBE);
setState(542);
match(T__2);
setState(551);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(543);
groupingSet();
setState(548);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(544);
match(T__1);
setState(545);
groupingSet();
}
}
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(553);
match(T__3);
}
break;
case 4:
_localctx = new MultipleGroupingSetsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(554);
match(GROUPING);
setState(555);
match(SETS);
setState(556);
match(T__2);
setState(557);
groupingSet();
setState(562);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(558);
match(T__1);
setState(559);
groupingSet();
}
}
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(565);
match(T__3);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GroupingSetContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public GroupingSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterGroupingSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitGroupingSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitGroupingSet(this);
else return visitor.visitChildren(this);
}
}
public final GroupingSetContext groupingSet() throws RecognitionException {
GroupingSetContext _localctx = new GroupingSetContext(_ctx, getState());
enterRule(_localctx, 54, RULE_groupingSet);
int _la;
try {
setState(582);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(569);
match(T__2);
setState(578);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(570);
expression();
setState(575);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(571);
match(T__1);
setState(572);
expression();
}
}
setState(577);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(580);
match(T__3);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(581);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WindowDefinitionContext extends ParserRuleContext {
public IdentifierContext name;
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public WindowSpecificationContext windowSpecification() {
return getRuleContext(WindowSpecificationContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public WindowDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterWindowDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitWindowDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitWindowDefinition(this);
else return visitor.visitChildren(this);
}
}
public final WindowDefinitionContext windowDefinition() throws RecognitionException {
WindowDefinitionContext _localctx = new WindowDefinitionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_windowDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(584);
((WindowDefinitionContext)_localctx).name = identifier();
setState(585);
match(T__10);
setState(586);
match(T__2);
setState(587);
windowSpecification();
setState(588);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WindowSpecificationContext extends ParserRuleContext {
public IdentifierContext existingWindowName;
public ExpressionContext expression;
public List partition = new ArrayList();
public TerminalNode PARTITION() { return getToken(StructuresSqlParserParser.PARTITION, 0); }
public List BY() { return getTokens(StructuresSqlParserParser.BY); }
public TerminalNode BY(int i) {
return getToken(StructuresSqlParserParser.BY, i);
}
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public WindowFrameContext windowFrame() {
return getRuleContext(WindowFrameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public WindowSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterWindowSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitWindowSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitWindowSpecification(this);
else return visitor.visitChildren(this);
}
}
public final WindowSpecificationContext windowSpecification() throws RecognitionException {
WindowSpecificationContext _localctx = new WindowSpecificationContext(_ctx, getState());
enterRule(_localctx, 58, RULE_windowSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(591);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
{
setState(590);
((WindowSpecificationContext)_localctx).existingWindowName = identifier();
}
break;
}
setState(603);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(593);
match(PARTITION);
setState(594);
match(T__18);
setState(595);
((WindowSpecificationContext)_localctx).expression = expression();
((WindowSpecificationContext)_localctx).partition.add(((WindowSpecificationContext)_localctx).expression);
setState(600);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(596);
match(T__1);
setState(597);
((WindowSpecificationContext)_localctx).expression = expression();
((WindowSpecificationContext)_localctx).partition.add(((WindowSpecificationContext)_localctx).expression);
}
}
setState(602);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(615);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(605);
match(ORDER);
setState(606);
match(T__18);
setState(607);
sortItem();
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(608);
match(T__1);
setState(609);
sortItem();
}
}
setState(614);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUPS || _la==MEASURES || _la==RANGE || _la==ROWS) {
{
setState(617);
windowFrame();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NamedQueryContext extends ParserRuleContext {
public IdentifierContext name;
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.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 StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNamedQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNamedQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNamedQuery(this);
else return visitor.visitChildren(this);
}
}
public final NamedQueryContext namedQuery() throws RecognitionException {
NamedQueryContext _localctx = new NamedQueryContext(_ctx, getState());
enterRule(_localctx, 60, RULE_namedQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(620);
((NamedQueryContext)_localctx).name = identifier();
setState(622);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(621);
columnAliases();
}
}
setState(624);
match(T__10);
setState(625);
match(T__2);
setState(626);
query();
setState(627);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SetQuantifierContext extends ParserRuleContext {
public TerminalNode DISTINCT() { return getToken(StructuresSqlParserParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(StructuresSqlParserParser.ALL, 0); }
public SetQuantifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setQuantifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSetQuantifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSetQuantifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSetQuantifier(this);
else return visitor.visitChildren(this);
}
}
public final SetQuantifierContext setQuantifier() throws RecognitionException {
SetQuantifierContext _localctx = new SetQuantifierContext(_ctx, getState());
enterRule(_localctx, 62, RULE_setQuantifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(629);
_la = _input.LA(1);
if ( !(_la==T__4 || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectItemContext extends ParserRuleContext {
public SelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectItem; }
public SelectItemContext() { }
public void copyFrom(SelectItemContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SelectAllContext extends SelectItemContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(StructuresSqlParserParser.ASTERISK, 0); }
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public SelectAllContext(SelectItemContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSelectAll(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSelectAll(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSelectAll(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SelectSingleContext extends SelectItemContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public SelectSingleContext(SelectItemContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSelectSingle(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSelectSingle(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSelectSingle(this);
else return visitor.visitChildren(this);
}
}
public final SelectItemContext selectItem() throws RecognitionException {
SelectItemContext _localctx = new SelectItemContext(_ctx, getState());
enterRule(_localctx, 64, RULE_selectItem);
int _la;
try {
setState(646);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
_localctx = new SelectSingleContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(631);
expression();
setState(636);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
setState(633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(632);
match(T__10);
}
}
setState(635);
identifier();
}
break;
}
}
break;
case 2:
_localctx = new SelectAllContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(638);
primaryExpression(0);
setState(639);
match(T__0);
setState(640);
match(ASTERISK);
setState(643);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
{
setState(641);
match(T__10);
setState(642);
columnAliases();
}
break;
}
}
break;
case 3:
_localctx = new SelectAllContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(645);
match(ASTERISK);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationContext extends ParserRuleContext {
public RelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relation; }
public RelationContext() { }
public void copyFrom(RelationContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RelationDefaultContext extends RelationContext {
public SampledRelationContext sampledRelation() {
return getRuleContext(SampledRelationContext.class,0);
}
public RelationDefaultContext(RelationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRelationDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRelationDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRelationDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JoinRelationContext extends RelationContext {
public RelationContext left;
public SampledRelationContext right;
public RelationContext rightRelation;
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public TerminalNode CROSS() { return getToken(StructuresSqlParserParser.CROSS, 0); }
public TerminalNode JOIN() { return getToken(StructuresSqlParserParser.JOIN, 0); }
public JoinTypeContext joinType() {
return getRuleContext(JoinTypeContext.class,0);
}
public JoinCriteriaContext joinCriteria() {
return getRuleContext(JoinCriteriaContext.class,0);
}
public TerminalNode NATURAL() { return getToken(StructuresSqlParserParser.NATURAL, 0); }
public SampledRelationContext sampledRelation() {
return getRuleContext(SampledRelationContext.class,0);
}
public JoinRelationContext(RelationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJoinRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJoinRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJoinRelation(this);
else return visitor.visitChildren(this);
}
}
public final RelationContext relation() throws RecognitionException {
return relation(0);
}
private RelationContext relation(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelationContext _localctx = new RelationContext(_ctx, _parentState);
RelationContext _prevctx = _localctx;
int _startState = 66;
enterRecursionRule(_localctx, 66, RULE_relation, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new RelationDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(649);
sampledRelation();
}
_ctx.stop = _input.LT(-1);
setState(669);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new JoinRelationContext(new RelationContext(_parentctx, _parentState));
((JoinRelationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_relation);
setState(651);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(665);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(652);
match(CROSS);
setState(653);
match(JOIN);
setState(654);
((JoinRelationContext)_localctx).right = sampledRelation();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case RIGHT:
{
setState(655);
joinType();
setState(656);
match(JOIN);
setState(657);
((JoinRelationContext)_localctx).rightRelation = relation(0);
setState(658);
joinCriteria();
}
break;
case NATURAL:
{
setState(660);
match(NATURAL);
setState(661);
joinType();
setState(662);
match(JOIN);
setState(663);
((JoinRelationContext)_localctx).right = sampledRelation();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(671);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,63,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JoinTypeContext extends ParserRuleContext {
public TerminalNode INNER() { return getToken(StructuresSqlParserParser.INNER, 0); }
public TerminalNode LEFT() { return getToken(StructuresSqlParserParser.LEFT, 0); }
public TerminalNode OUTER() { return getToken(StructuresSqlParserParser.OUTER, 0); }
public TerminalNode RIGHT() { return getToken(StructuresSqlParserParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(StructuresSqlParserParser.FULL, 0); }
public JoinTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJoinType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJoinType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJoinType(this);
else return visitor.visitChildren(this);
}
}
public final JoinTypeContext joinType() throws RecognitionException {
JoinTypeContext _localctx = new JoinTypeContext(_ctx, getState());
enterRule(_localctx, 68, RULE_joinType);
int _la;
try {
setState(687);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INNER:
case JOIN:
enterOuterAlt(_localctx, 1);
{
setState(673);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(672);
match(INNER);
}
}
}
break;
case LEFT:
enterOuterAlt(_localctx, 2);
{
setState(675);
match(LEFT);
setState(677);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(676);
match(OUTER);
}
}
}
break;
case RIGHT:
enterOuterAlt(_localctx, 3);
{
setState(679);
match(RIGHT);
setState(681);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(680);
match(OUTER);
}
}
}
break;
case FULL:
enterOuterAlt(_localctx, 4);
{
setState(683);
match(FULL);
setState(685);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(684);
match(OUTER);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JoinCriteriaContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public TerminalNode USING() { return getToken(StructuresSqlParserParser.USING, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public JoinCriteriaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinCriteria; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJoinCriteria(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJoinCriteria(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJoinCriteria(this);
else return visitor.visitChildren(this);
}
}
public final JoinCriteriaContext joinCriteria() throws RecognitionException {
JoinCriteriaContext _localctx = new JoinCriteriaContext(_ctx, getState());
enterRule(_localctx, 70, RULE_joinCriteria);
int _la;
try {
setState(703);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ON:
enterOuterAlt(_localctx, 1);
{
setState(689);
match(ON);
setState(690);
booleanExpression(0);
}
break;
case USING:
enterOuterAlt(_localctx, 2);
{
setState(691);
match(USING);
setState(692);
match(T__2);
setState(693);
identifier();
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(694);
match(T__1);
setState(695);
identifier();
}
}
setState(700);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(701);
match(T__3);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SampledRelationContext extends ParserRuleContext {
public ExpressionContext percentage;
public PatternRecognitionContext patternRecognition() {
return getRuleContext(PatternRecognitionContext.class,0);
}
public TerminalNode TABLESAMPLE() { return getToken(StructuresSqlParserParser.TABLESAMPLE, 0); }
public SampleTypeContext sampleType() {
return getRuleContext(SampleTypeContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SampledRelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampledRelation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSampledRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSampledRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSampledRelation(this);
else return visitor.visitChildren(this);
}
}
public final SampledRelationContext sampledRelation() throws RecognitionException {
SampledRelationContext _localctx = new SampledRelationContext(_ctx, getState());
enterRule(_localctx, 72, RULE_sampledRelation);
try {
enterOuterAlt(_localctx, 1);
{
setState(705);
patternRecognition();
setState(712);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(706);
match(TABLESAMPLE);
setState(707);
sampleType();
setState(708);
match(T__2);
setState(709);
((SampledRelationContext)_localctx).percentage = expression();
setState(710);
match(T__3);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SampleTypeContext extends ParserRuleContext {
public TerminalNode BERNOULLI() { return getToken(StructuresSqlParserParser.BERNOULLI, 0); }
public TerminalNode SYSTEM() { return getToken(StructuresSqlParserParser.SYSTEM, 0); }
public SampleTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampleType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSampleType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSampleType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSampleType(this);
else return visitor.visitChildren(this);
}
}
public final SampleTypeContext sampleType() throws RecognitionException {
SampleTypeContext _localctx = new SampleTypeContext(_ctx, getState());
enterRule(_localctx, 74, RULE_sampleType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(714);
_la = _input.LA(1);
if ( !(_la==T__15 || _la==SYSTEM) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class TrimsSpecificationContext extends ParserRuleContext {
public TerminalNode LEADING() { return getToken(StructuresSqlParserParser.LEADING, 0); }
public TerminalNode TRAILING() { return getToken(StructuresSqlParserParser.TRAILING, 0); }
public TerminalNode BOTH() { return getToken(StructuresSqlParserParser.BOTH, 0); }
public TrimsSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimsSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTrimsSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTrimsSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTrimsSpecification(this);
else return visitor.visitChildren(this);
}
}
public final TrimsSpecificationContext trimsSpecification() throws RecognitionException {
TrimsSpecificationContext _localctx = new TrimsSpecificationContext(_ctx, getState());
enterRule(_localctx, 76, RULE_trimsSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(716);
_la = _input.LA(1);
if ( !(_la==T__17 || _la==LEADING || _la==TRAILING) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class ListAggOverflowBehaviorContext extends ParserRuleContext {
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public TerminalNode TRUNCATE() { return getToken(StructuresSqlParserParser.TRUNCATE, 0); }
public ListaggCountIndicationContext listaggCountIndication() {
return getRuleContext(ListaggCountIndicationContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public ListAggOverflowBehaviorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listAggOverflowBehavior; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterListAggOverflowBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitListAggOverflowBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitListAggOverflowBehavior(this);
else return visitor.visitChildren(this);
}
}
public final ListAggOverflowBehaviorContext listAggOverflowBehavior() throws RecognitionException {
ListAggOverflowBehaviorContext _localctx = new ListAggOverflowBehaviorContext(_ctx, getState());
enterRule(_localctx, 78, RULE_listAggOverflowBehavior);
int _la;
try {
setState(724);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ERROR:
enterOuterAlt(_localctx, 1);
{
setState(718);
match(ERROR);
}
break;
case TRUNCATE:
enterOuterAlt(_localctx, 2);
{
setState(719);
match(TRUNCATE);
setState(721);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING || _la==UNICODE_STRING) {
{
setState(720);
string();
}
}
setState(723);
listaggCountIndication();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ListaggCountIndicationContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode COUNT() { return getToken(StructuresSqlParserParser.COUNT, 0); }
public TerminalNode WITHOUT() { return getToken(StructuresSqlParserParser.WITHOUT, 0); }
public ListaggCountIndicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listaggCountIndication; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterListaggCountIndication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitListaggCountIndication(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitListaggCountIndication(this);
else return visitor.visitChildren(this);
}
}
public final ListaggCountIndicationContext listaggCountIndication() throws RecognitionException {
ListaggCountIndicationContext _localctx = new ListaggCountIndicationContext(_ctx, getState());
enterRule(_localctx, 80, RULE_listaggCountIndication);
try {
setState(730);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WITH:
enterOuterAlt(_localctx, 1);
{
setState(726);
match(WITH);
setState(727);
match(COUNT);
}
break;
case WITHOUT:
enterOuterAlt(_localctx, 2);
{
setState(728);
match(WITHOUT);
setState(729);
match(COUNT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PatternRecognitionContext extends ParserRuleContext {
public ExpressionContext expression;
public List partition = new ArrayList();
public AliasedRelationContext aliasedRelation() {
return getRuleContext(AliasedRelationContext.class,0);
}
public TerminalNode MATCH_RECOGNIZE() { return getToken(StructuresSqlParserParser.MATCH_RECOGNIZE, 0); }
public TerminalNode PATTERN() { return getToken(StructuresSqlParserParser.PATTERN, 0); }
public RowPatternContext rowPattern() {
return getRuleContext(RowPatternContext.class,0);
}
public TerminalNode DEFINE() { return getToken(StructuresSqlParserParser.DEFINE, 0); }
public List variableDefinition() {
return getRuleContexts(VariableDefinitionContext.class);
}
public VariableDefinitionContext variableDefinition(int i) {
return getRuleContext(VariableDefinitionContext.class,i);
}
public TerminalNode PARTITION() { return getToken(StructuresSqlParserParser.PARTITION, 0); }
public List BY() { return getTokens(StructuresSqlParserParser.BY); }
public TerminalNode BY(int i) {
return getToken(StructuresSqlParserParser.BY, i);
}
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public TerminalNode MEASURES() { return getToken(StructuresSqlParserParser.MEASURES, 0); }
public List measureDefinition() {
return getRuleContexts(MeasureDefinitionContext.class);
}
public MeasureDefinitionContext measureDefinition(int i) {
return getRuleContext(MeasureDefinitionContext.class,i);
}
public RowsPerMatchContext rowsPerMatch() {
return getRuleContext(RowsPerMatchContext.class,0);
}
public TerminalNode AFTER() { return getToken(StructuresSqlParserParser.AFTER, 0); }
public TerminalNode MATCH() { return getToken(StructuresSqlParserParser.MATCH, 0); }
public SkipToContext skipTo() {
return getRuleContext(SkipToContext.class,0);
}
public TerminalNode SUBSET() { return getToken(StructuresSqlParserParser.SUBSET, 0); }
public List subsetDefinition() {
return getRuleContexts(SubsetDefinitionContext.class);
}
public SubsetDefinitionContext subsetDefinition(int i) {
return getRuleContext(SubsetDefinitionContext.class,i);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode INITIAL() { return getToken(StructuresSqlParserParser.INITIAL, 0); }
public TerminalNode SEEK() { return getToken(StructuresSqlParserParser.SEEK, 0); }
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public PatternRecognitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternRecognition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterPatternRecognition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitPatternRecognition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitPatternRecognition(this);
else return visitor.visitChildren(this);
}
}
public final PatternRecognitionContext patternRecognition() throws RecognitionException {
PatternRecognitionContext _localctx = new PatternRecognitionContext(_ctx, getState());
enterRule(_localctx, 82, RULE_patternRecognition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(732);
aliasedRelation();
setState(815);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(733);
match(MATCH_RECOGNIZE);
setState(734);
match(T__2);
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(735);
match(PARTITION);
setState(736);
match(T__18);
setState(737);
((PatternRecognitionContext)_localctx).expression = expression();
((PatternRecognitionContext)_localctx).partition.add(((PatternRecognitionContext)_localctx).expression);
setState(742);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(738);
match(T__1);
setState(739);
((PatternRecognitionContext)_localctx).expression = expression();
((PatternRecognitionContext)_localctx).partition.add(((PatternRecognitionContext)_localctx).expression);
}
}
setState(744);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(747);
match(ORDER);
setState(748);
match(T__18);
setState(749);
sortItem();
setState(754);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(750);
match(T__1);
setState(751);
sortItem();
}
}
setState(756);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MEASURES) {
{
setState(759);
match(MEASURES);
setState(760);
measureDefinition();
setState(765);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(761);
match(T__1);
setState(762);
measureDefinition();
}
}
setState(767);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(771);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4 || _la==ONE) {
{
setState(770);
rowsPerMatch();
}
}
setState(776);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__3) {
{
setState(773);
match(T__3);
setState(774);
match(MATCH);
setState(775);
skipTo();
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INITIAL || _la==SEEK) {
{
setState(778);
_la = _input.LA(1);
if ( !(_la==INITIAL || _la==SEEK) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(781);
match(PATTERN);
setState(782);
match(T__2);
setState(783);
rowPattern(0);
setState(784);
match(T__3);
setState(794);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SUBSET) {
{
setState(785);
match(SUBSET);
setState(786);
subsetDefinition();
setState(791);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(787);
match(T__1);
setState(788);
subsetDefinition();
}
}
setState(793);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(796);
match(DEFINE);
setState(797);
variableDefinition();
setState(802);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(798);
match(T__1);
setState(799);
variableDefinition();
}
}
setState(804);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(805);
match(T__3);
setState(813);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(807);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(806);
match(T__10);
}
}
setState(809);
identifier();
setState(811);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(810);
columnAliases();
}
break;
}
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MeasureDefinitionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MeasureDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_measureDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterMeasureDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitMeasureDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitMeasureDefinition(this);
else return visitor.visitChildren(this);
}
}
public final MeasureDefinitionContext measureDefinition() throws RecognitionException {
MeasureDefinitionContext _localctx = new MeasureDefinitionContext(_ctx, getState());
enterRule(_localctx, 84, RULE_measureDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(817);
expression();
setState(818);
match(T__10);
setState(819);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RowsPerMatchContext extends ParserRuleContext {
public TerminalNode ONE() { return getToken(StructuresSqlParserParser.ONE, 0); }
public TerminalNode ROW() { return getToken(StructuresSqlParserParser.ROW, 0); }
public TerminalNode PER() { return getToken(StructuresSqlParserParser.PER, 0); }
public TerminalNode MATCH() { return getToken(StructuresSqlParserParser.MATCH, 0); }
public TerminalNode ALL() { return getToken(StructuresSqlParserParser.ALL, 0); }
public TerminalNode ROWS() { return getToken(StructuresSqlParserParser.ROWS, 0); }
public EmptyMatchHandlingContext emptyMatchHandling() {
return getRuleContext(EmptyMatchHandlingContext.class,0);
}
public RowsPerMatchContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rowsPerMatch; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRowsPerMatch(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRowsPerMatch(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRowsPerMatch(this);
else return visitor.visitChildren(this);
}
}
public final RowsPerMatchContext rowsPerMatch() throws RecognitionException {
RowsPerMatchContext _localctx = new RowsPerMatchContext(_ctx, getState());
enterRule(_localctx, 86, RULE_rowsPerMatch);
int _la;
try {
setState(832);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ONE:
enterOuterAlt(_localctx, 1);
{
setState(821);
match(ONE);
setState(822);
match(ROW);
setState(823);
match(PER);
setState(824);
match(MATCH);
}
break;
case T__4:
enterOuterAlt(_localctx, 2);
{
setState(825);
match(T__4);
setState(826);
match(ROWS);
setState(827);
match(PER);
setState(828);
match(MATCH);
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OMIT || _la==SHOW || _la==WITH) {
{
setState(829);
emptyMatchHandling();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EmptyMatchHandlingContext extends ParserRuleContext {
public TerminalNode SHOW() { return getToken(StructuresSqlParserParser.SHOW, 0); }
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode MATCHES() { return getToken(StructuresSqlParserParser.MATCHES, 0); }
public TerminalNode OMIT() { return getToken(StructuresSqlParserParser.OMIT, 0); }
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode UNMATCHED() { return getToken(StructuresSqlParserParser.UNMATCHED, 0); }
public TerminalNode ROWS() { return getToken(StructuresSqlParserParser.ROWS, 0); }
public EmptyMatchHandlingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyMatchHandling; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterEmptyMatchHandling(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitEmptyMatchHandling(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitEmptyMatchHandling(this);
else return visitor.visitChildren(this);
}
}
public final EmptyMatchHandlingContext emptyMatchHandling() throws RecognitionException {
EmptyMatchHandlingContext _localctx = new EmptyMatchHandlingContext(_ctx, getState());
enterRule(_localctx, 88, RULE_emptyMatchHandling);
try {
setState(843);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SHOW:
enterOuterAlt(_localctx, 1);
{
setState(834);
match(SHOW);
setState(835);
match(EMPTY);
setState(836);
match(MATCHES);
}
break;
case OMIT:
enterOuterAlt(_localctx, 2);
{
setState(837);
match(OMIT);
setState(838);
match(EMPTY);
setState(839);
match(MATCHES);
}
break;
case WITH:
enterOuterAlt(_localctx, 3);
{
setState(840);
match(WITH);
setState(841);
match(UNMATCHED);
setState(842);
match(ROWS);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SkipToContext extends ParserRuleContext {
public TerminalNode TO() { return getToken(StructuresSqlParserParser.TO, 0); }
public TerminalNode NEXT() { return getToken(StructuresSqlParserParser.NEXT, 0); }
public TerminalNode ROW() { return getToken(StructuresSqlParserParser.ROW, 0); }
public TerminalNode PAST() { return getToken(StructuresSqlParserParser.PAST, 0); }
public TerminalNode LAST() { return getToken(StructuresSqlParserParser.LAST, 0); }
public TerminalNode FIRST() { return getToken(StructuresSqlParserParser.FIRST, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SkipToContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_skipTo; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSkipTo(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSkipTo(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSkipTo(this);
else return visitor.visitChildren(this);
}
}
public final SkipToContext skipTo() throws RecognitionException {
SkipToContext _localctx = new SkipToContext(_ctx, getState());
enterRule(_localctx, 90, RULE_skipTo);
try {
setState(864);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(845);
match(T__4);
setState(846);
match(TO);
setState(847);
match(NEXT);
setState(848);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(849);
match(T__4);
setState(850);
match(PAST);
setState(851);
match(LAST);
setState(852);
match(ROW);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(853);
match(T__4);
setState(854);
match(TO);
setState(855);
match(FIRST);
setState(856);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(857);
match(T__4);
setState(858);
match(TO);
setState(859);
match(LAST);
setState(860);
identifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(861);
match(T__4);
setState(862);
match(TO);
setState(863);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubsetDefinitionContext extends ParserRuleContext {
public IdentifierContext name;
public IdentifierContext identifier;
public List union = new ArrayList();
public TerminalNode EQ() { return getToken(StructuresSqlParserParser.EQ, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public SubsetDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subsetDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubsetDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubsetDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubsetDefinition(this);
else return visitor.visitChildren(this);
}
}
public final SubsetDefinitionContext subsetDefinition() throws RecognitionException {
SubsetDefinitionContext _localctx = new SubsetDefinitionContext(_ctx, getState());
enterRule(_localctx, 92, RULE_subsetDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(866);
((SubsetDefinitionContext)_localctx).name = identifier();
setState(867);
match(EQ);
setState(868);
match(T__2);
setState(869);
((SubsetDefinitionContext)_localctx).identifier = identifier();
((SubsetDefinitionContext)_localctx).union.add(((SubsetDefinitionContext)_localctx).identifier);
setState(874);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(870);
match(T__1);
setState(871);
((SubsetDefinitionContext)_localctx).identifier = identifier();
((SubsetDefinitionContext)_localctx).union.add(((SubsetDefinitionContext)_localctx).identifier);
}
}
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(877);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariableDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public VariableDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterVariableDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitVariableDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitVariableDefinition(this);
else return visitor.visitChildren(this);
}
}
public final VariableDefinitionContext variableDefinition() throws RecognitionException {
VariableDefinitionContext _localctx = new VariableDefinitionContext(_ctx, getState());
enterRule(_localctx, 94, RULE_variableDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(879);
identifier();
setState(880);
match(T__10);
setState(881);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AliasedRelationContext extends ParserRuleContext {
public RelationPrimaryContext relationPrimary() {
return getRuleContext(RelationPrimaryContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public AliasedRelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliasedRelation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterAliasedRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitAliasedRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitAliasedRelation(this);
else return visitor.visitChildren(this);
}
}
public final AliasedRelationContext aliasedRelation() throws RecognitionException {
AliasedRelationContext _localctx = new AliasedRelationContext(_ctx, getState());
enterRule(_localctx, 96, RULE_aliasedRelation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(883);
relationPrimary();
setState(891);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(885);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(884);
match(T__10);
}
}
setState(887);
identifier();
setState(889);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(888);
columnAliases();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnAliasesContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public ColumnAliasesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columnAliases; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterColumnAliases(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitColumnAliases(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitColumnAliases(this);
else return visitor.visitChildren(this);
}
}
public final ColumnAliasesContext columnAliases() throws RecognitionException {
ColumnAliasesContext _localctx = new ColumnAliasesContext(_ctx, getState());
enterRule(_localctx, 98, RULE_columnAliases);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(893);
match(T__2);
setState(894);
identifier();
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(895);
match(T__1);
setState(896);
identifier();
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(902);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationPrimaryContext extends ParserRuleContext {
public RelationPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationPrimary; }
public RelationPrimaryContext() { }
public void copyFrom(RelationPrimaryContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubqueryRelationContext extends RelationPrimaryContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public SubqueryRelationContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubqueryRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubqueryRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubqueryRelation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonTableContext extends RelationPrimaryContext {
public TerminalNode JSON_TABLE() { return getToken(StructuresSqlParserParser.JSON_TABLE, 0); }
public JsonPathInvocationContext jsonPathInvocation() {
return getRuleContext(JsonPathInvocationContext.class,0);
}
public TerminalNode COLUMNS() { return getToken(StructuresSqlParserParser.COLUMNS, 0); }
public List jsonTableColumn() {
return getRuleContexts(JsonTableColumnContext.class);
}
public JsonTableColumnContext jsonTableColumn(int i) {
return getRuleContext(JsonTableColumnContext.class,i);
}
public TerminalNode PLAN() { return getToken(StructuresSqlParserParser.PLAN, 0); }
public JsonTableSpecificPlanContext jsonTableSpecificPlan() {
return getRuleContext(JsonTableSpecificPlanContext.class,0);
}
public TerminalNode DEFAULT() { return getToken(StructuresSqlParserParser.DEFAULT, 0); }
public JsonTableDefaultPlanContext jsonTableDefaultPlan() {
return getRuleContext(JsonTableDefaultPlanContext.class,0);
}
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public List ERROR() { return getTokens(StructuresSqlParserParser.ERROR); }
public TerminalNode ERROR(int i) {
return getToken(StructuresSqlParserParser.ERROR, i);
}
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public JsonTableContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonTable(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedRelationContext extends RelationPrimaryContext {
public RelationContext relation() {
return getRuleContext(RelationContext.class,0);
}
public ParenthesizedRelationContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterParenthesizedRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitParenthesizedRelation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitParenthesizedRelation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnnestContext extends RelationPrimaryContext {
public TerminalNode UNNEST() { return getToken(StructuresSqlParserParser.UNNEST, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode ORDINALITY() { return getToken(StructuresSqlParserParser.ORDINALITY, 0); }
public UnnestContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterUnnest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitUnnest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitUnnest(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableFunctionInvocationContext extends RelationPrimaryContext {
public TerminalNode TABLE() { return getToken(StructuresSqlParserParser.TABLE, 0); }
public TableFunctionCallContext tableFunctionCall() {
return getRuleContext(TableFunctionCallContext.class,0);
}
public TableFunctionInvocationContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableFunctionInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableFunctionInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableFunctionInvocation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LateralContext extends RelationPrimaryContext {
public TerminalNode LATERAL() { return getToken(StructuresSqlParserParser.LATERAL, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public LateralContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLateral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLateral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLateral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableNameContext extends RelationPrimaryContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public QueryPeriodContext queryPeriod() {
return getRuleContext(QueryPeriodContext.class,0);
}
public TableNameContext(RelationPrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableName(this);
else return visitor.visitChildren(this);
}
}
public final RelationPrimaryContext relationPrimary() throws RecognitionException {
RelationPrimaryContext _localctx = new RelationPrimaryContext(_ctx, getState());
enterRule(_localctx, 100, RULE_relationPrimary);
int _la;
try {
setState(975);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
_localctx = new TableNameContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(904);
qualifiedName();
setState(906);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
setState(905);
queryPeriod();
}
break;
}
}
break;
case 2:
_localctx = new SubqueryRelationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(908);
match(T__2);
setState(909);
query();
setState(910);
match(T__3);
}
break;
case 3:
_localctx = new UnnestContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(912);
match(UNNEST);
setState(913);
match(T__2);
setState(914);
expression();
setState(919);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(915);
match(T__1);
setState(916);
expression();
}
}
setState(921);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(922);
match(T__3);
setState(925);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
{
setState(923);
match(WITH);
setState(924);
match(ORDINALITY);
}
break;
}
}
break;
case 4:
_localctx = new LateralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(927);
match(LATERAL);
setState(928);
match(T__2);
setState(929);
query();
setState(930);
match(T__3);
}
break;
case 5:
_localctx = new TableFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(932);
match(TABLE);
setState(933);
match(T__2);
setState(934);
tableFunctionCall();
setState(935);
match(T__3);
}
break;
case 6:
_localctx = new ParenthesizedRelationContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(937);
match(T__2);
setState(938);
relation(0);
setState(939);
match(T__3);
}
break;
case 7:
_localctx = new JsonTableContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(941);
match(JSON_TABLE);
setState(942);
match(T__2);
setState(943);
jsonPathInvocation();
setState(944);
match(COLUMNS);
setState(945);
match(T__2);
setState(946);
jsonTableColumn();
setState(951);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(947);
match(T__1);
setState(948);
jsonTableColumn();
}
}
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(954);
match(T__3);
setState(966);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
{
setState(955);
match(PLAN);
setState(956);
match(T__2);
setState(957);
jsonTableSpecificPlan();
setState(958);
match(T__3);
}
break;
case 2:
{
setState(960);
match(PLAN);
setState(961);
match(DEFAULT);
setState(962);
match(T__2);
setState(963);
jsonTableDefaultPlan();
setState(964);
match(T__3);
}
break;
}
setState(971);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EMPTY || _la==ERROR) {
{
setState(968);
_la = _input.LA(1);
if ( !(_la==EMPTY || _la==ERROR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(969);
match(ON);
setState(970);
match(ERROR);
}
}
setState(973);
match(T__3);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonTableColumnContext extends ParserRuleContext {
public JsonTableColumnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonTableColumn; }
public JsonTableColumnContext() { }
public void copyFrom(JsonTableColumnContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QueryColumnContext extends JsonTableColumnContext {
public JsonQueryBehaviorContext emptyBehavior;
public JsonQueryBehaviorContext errorBehavior;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode FORMAT() { return getToken(StructuresSqlParserParser.FORMAT, 0); }
public JsonRepresentationContext jsonRepresentation() {
return getRuleContext(JsonRepresentationContext.class,0);
}
public TerminalNode PATH() { return getToken(StructuresSqlParserParser.PATH, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public JsonQueryWrapperBehaviorContext jsonQueryWrapperBehavior() {
return getRuleContext(JsonQueryWrapperBehaviorContext.class,0);
}
public TerminalNode WRAPPER() { return getToken(StructuresSqlParserParser.WRAPPER, 0); }
public TerminalNode QUOTES() { return getToken(StructuresSqlParserParser.QUOTES, 0); }
public List ON() { return getTokens(StructuresSqlParserParser.ON); }
public TerminalNode ON(int i) {
return getToken(StructuresSqlParserParser.ON, i);
}
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public TerminalNode KEEP() { return getToken(StructuresSqlParserParser.KEEP, 0); }
public TerminalNode OMIT() { return getToken(StructuresSqlParserParser.OMIT, 0); }
public List jsonQueryBehavior() {
return getRuleContexts(JsonQueryBehaviorContext.class);
}
public JsonQueryBehaviorContext jsonQueryBehavior(int i) {
return getRuleContext(JsonQueryBehaviorContext.class,i);
}
public TerminalNode SCALAR() { return getToken(StructuresSqlParserParser.SCALAR, 0); }
public TerminalNode TEXT_STRING() { return getToken(StructuresSqlParserParser.TEXT_STRING, 0); }
public QueryColumnContext(JsonTableColumnContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQueryColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQueryColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQueryColumn(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NestedColumnsContext extends JsonTableColumnContext {
public TerminalNode NESTED() { return getToken(StructuresSqlParserParser.NESTED, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode COLUMNS() { return getToken(StructuresSqlParserParser.COLUMNS, 0); }
public List jsonTableColumn() {
return getRuleContexts(JsonTableColumnContext.class);
}
public JsonTableColumnContext jsonTableColumn(int i) {
return getRuleContext(JsonTableColumnContext.class,i);
}
public TerminalNode PATH() { return getToken(StructuresSqlParserParser.PATH, 0); }
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NestedColumnsContext(JsonTableColumnContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNestedColumns(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNestedColumns(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNestedColumns(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValueColumnContext extends JsonTableColumnContext {
public JsonValueBehaviorContext emptyBehavior;
public JsonValueBehaviorContext errorBehavior;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode PATH() { return getToken(StructuresSqlParserParser.PATH, 0); }
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public List ON() { return getTokens(StructuresSqlParserParser.ON); }
public TerminalNode ON(int i) {
return getToken(StructuresSqlParserParser.ON, i);
}
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public List jsonValueBehavior() {
return getRuleContexts(JsonValueBehaviorContext.class);
}
public JsonValueBehaviorContext jsonValueBehavior(int i) {
return getRuleContext(JsonValueBehaviorContext.class,i);
}
public ValueColumnContext(JsonTableColumnContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterValueColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitValueColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitValueColumn(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrdinalityColumnContext extends JsonTableColumnContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode FOR() { return getToken(StructuresSqlParserParser.FOR, 0); }
public TerminalNode ORDINALITY() { return getToken(StructuresSqlParserParser.ORDINALITY, 0); }
public OrdinalityColumnContext(JsonTableColumnContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterOrdinalityColumn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitOrdinalityColumn(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitOrdinalityColumn(this);
else return visitor.visitChildren(this);
}
}
public final JsonTableColumnContext jsonTableColumn() throws RecognitionException {
JsonTableColumnContext _localctx = new JsonTableColumnContext(_ctx, getState());
enterRule(_localctx, 102, RULE_jsonTableColumn);
int _la;
try {
setState(1054);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
_localctx = new OrdinalityColumnContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(977);
identifier();
setState(978);
match(FOR);
setState(979);
match(ORDINALITY);
}
break;
case 2:
_localctx = new ValueColumnContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(981);
identifier();
setState(982);
type(0);
setState(985);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PATH) {
{
setState(983);
match(PATH);
setState(984);
string();
}
}
setState(991);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
case 1:
{
setState(987);
((ValueColumnContext)_localctx).emptyBehavior = jsonValueBehavior();
setState(988);
match(ON);
setState(989);
match(EMPTY);
}
break;
}
setState(997);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT || _la==ERROR || _la==NULL) {
{
setState(993);
((ValueColumnContext)_localctx).errorBehavior = jsonValueBehavior();
setState(994);
match(ON);
setState(995);
match(ERROR);
}
}
}
break;
case 3:
_localctx = new QueryColumnContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(999);
identifier();
setState(1000);
type(0);
setState(1001);
match(FORMAT);
setState(1002);
jsonRepresentation();
setState(1005);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PATH) {
{
setState(1003);
match(PATH);
setState(1004);
string();
}
}
setState(1010);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH || _la==WITHOUT) {
{
setState(1007);
jsonQueryWrapperBehavior();
setState(1008);
match(WRAPPER);
}
}
setState(1019);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KEEP || _la==OMIT) {
{
setState(1012);
_la = _input.LA(1);
if ( !(_la==KEEP || _la==OMIT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1013);
match(QUOTES);
setState(1017);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1014);
match(ON);
setState(1015);
match(SCALAR);
setState(1016);
match(TEXT_STRING);
}
}
}
}
setState(1025);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(1021);
((QueryColumnContext)_localctx).emptyBehavior = jsonQueryBehavior();
setState(1022);
match(ON);
setState(1023);
match(EMPTY);
}
break;
}
setState(1031);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EMPTY || _la==ERROR || _la==NULL) {
{
setState(1027);
((QueryColumnContext)_localctx).errorBehavior = jsonQueryBehavior();
setState(1028);
match(ON);
setState(1029);
match(ERROR);
}
}
}
break;
case 4:
_localctx = new NestedColumnsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1033);
match(NESTED);
setState(1035);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PATH) {
{
setState(1034);
match(PATH);
}
}
setState(1037);
string();
setState(1040);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(1038);
match(T__10);
setState(1039);
identifier();
}
}
setState(1042);
match(COLUMNS);
setState(1043);
match(T__2);
setState(1044);
jsonTableColumn();
setState(1049);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1045);
match(T__1);
setState(1046);
jsonTableColumn();
}
}
setState(1051);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1052);
match(T__3);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonTableSpecificPlanContext extends ParserRuleContext {
public JsonTableSpecificPlanContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonTableSpecificPlan; }
public JsonTableSpecificPlanContext() { }
public void copyFrom(JsonTableSpecificPlanContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CrossPlanContext extends JsonTableSpecificPlanContext {
public List planPrimary() {
return getRuleContexts(PlanPrimaryContext.class);
}
public PlanPrimaryContext planPrimary(int i) {
return getRuleContext(PlanPrimaryContext.class,i);
}
public List CROSS() { return getTokens(StructuresSqlParserParser.CROSS); }
public TerminalNode CROSS(int i) {
return getToken(StructuresSqlParserParser.CROSS, i);
}
public CrossPlanContext(JsonTableSpecificPlanContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCrossPlan(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCrossPlan(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCrossPlan(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JoinPlanContext extends JsonTableSpecificPlanContext {
public JsonTablePathNameContext jsonTablePathName() {
return getRuleContext(JsonTablePathNameContext.class,0);
}
public PlanPrimaryContext planPrimary() {
return getRuleContext(PlanPrimaryContext.class,0);
}
public TerminalNode OUTER() { return getToken(StructuresSqlParserParser.OUTER, 0); }
public TerminalNode INNER() { return getToken(StructuresSqlParserParser.INNER, 0); }
public JoinPlanContext(JsonTableSpecificPlanContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJoinPlan(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJoinPlan(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJoinPlan(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LeafPlanContext extends JsonTableSpecificPlanContext {
public JsonTablePathNameContext jsonTablePathName() {
return getRuleContext(JsonTablePathNameContext.class,0);
}
public LeafPlanContext(JsonTableSpecificPlanContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLeafPlan(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLeafPlan(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLeafPlan(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnionPlanContext extends JsonTableSpecificPlanContext {
public List planPrimary() {
return getRuleContexts(PlanPrimaryContext.class);
}
public PlanPrimaryContext planPrimary(int i) {
return getRuleContext(PlanPrimaryContext.class,i);
}
public List UNION() { return getTokens(StructuresSqlParserParser.UNION); }
public TerminalNode UNION(int i) {
return getToken(StructuresSqlParserParser.UNION, i);
}
public UnionPlanContext(JsonTableSpecificPlanContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterUnionPlan(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitUnionPlan(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitUnionPlan(this);
else return visitor.visitChildren(this);
}
}
public final JsonTableSpecificPlanContext jsonTableSpecificPlan() throws RecognitionException {
JsonTableSpecificPlanContext _localctx = new JsonTableSpecificPlanContext(_ctx, getState());
enterRule(_localctx, 104, RULE_jsonTableSpecificPlan);
int _la;
try {
setState(1081);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
_localctx = new LeafPlanContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1056);
jsonTablePathName();
}
break;
case 2:
_localctx = new JoinPlanContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1057);
jsonTablePathName();
setState(1058);
_la = _input.LA(1);
if ( !(_la==INNER || _la==OUTER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1059);
planPrimary();
}
break;
case 3:
_localctx = new UnionPlanContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1061);
planPrimary();
setState(1062);
match(UNION);
setState(1063);
planPrimary();
setState(1068);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==UNION) {
{
{
setState(1064);
match(UNION);
setState(1065);
planPrimary();
}
}
setState(1070);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 4:
_localctx = new CrossPlanContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1071);
planPrimary();
setState(1072);
match(CROSS);
setState(1073);
planPrimary();
setState(1078);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CROSS) {
{
{
setState(1074);
match(CROSS);
setState(1075);
planPrimary();
}
}
setState(1080);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonTablePathNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public JsonTablePathNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonTablePathName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonTablePathName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonTablePathName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonTablePathName(this);
else return visitor.visitChildren(this);
}
}
public final JsonTablePathNameContext jsonTablePathName() throws RecognitionException {
JsonTablePathNameContext _localctx = new JsonTablePathNameContext(_ctx, getState());
enterRule(_localctx, 106, RULE_jsonTablePathName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1083);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PlanPrimaryContext extends ParserRuleContext {
public JsonTablePathNameContext jsonTablePathName() {
return getRuleContext(JsonTablePathNameContext.class,0);
}
public JsonTableSpecificPlanContext jsonTableSpecificPlan() {
return getRuleContext(JsonTableSpecificPlanContext.class,0);
}
public PlanPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_planPrimary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterPlanPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitPlanPrimary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitPlanPrimary(this);
else return visitor.visitChildren(this);
}
}
public final PlanPrimaryContext planPrimary() throws RecognitionException {
PlanPrimaryContext _localctx = new PlanPrimaryContext(_ctx, getState());
enterRule(_localctx, 108, RULE_planPrimary);
try {
setState(1090);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1085);
jsonTablePathName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1086);
match(T__2);
setState(1087);
jsonTableSpecificPlan();
setState(1088);
match(T__3);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonTableDefaultPlanContext extends ParserRuleContext {
public TerminalNode OUTER() { return getToken(StructuresSqlParserParser.OUTER, 0); }
public TerminalNode INNER() { return getToken(StructuresSqlParserParser.INNER, 0); }
public TerminalNode UNION() { return getToken(StructuresSqlParserParser.UNION, 0); }
public TerminalNode CROSS() { return getToken(StructuresSqlParserParser.CROSS, 0); }
public JsonTableDefaultPlanContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonTableDefaultPlan; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonTableDefaultPlan(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonTableDefaultPlan(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonTableDefaultPlan(this);
else return visitor.visitChildren(this);
}
}
public final JsonTableDefaultPlanContext jsonTableDefaultPlan() throws RecognitionException {
JsonTableDefaultPlanContext _localctx = new JsonTableDefaultPlanContext(_ctx, getState());
enterRule(_localctx, 110, RULE_jsonTableDefaultPlan);
int _la;
try {
setState(1102);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INNER:
case OUTER:
enterOuterAlt(_localctx, 1);
{
setState(1092);
_la = _input.LA(1);
if ( !(_la==INNER || _la==OUTER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1095);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(1093);
match(T__1);
setState(1094);
_la = _input.LA(1);
if ( !(_la==CROSS || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
case CROSS:
case UNION:
enterOuterAlt(_localctx, 2);
{
setState(1097);
_la = _input.LA(1);
if ( !(_la==CROSS || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1100);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(1098);
match(T__1);
setState(1099);
_la = _input.LA(1);
if ( !(_la==INNER || _la==OUTER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableFunctionCallContext extends ParserRuleContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public List tableFunctionArgument() {
return getRuleContexts(TableFunctionArgumentContext.class);
}
public TableFunctionArgumentContext tableFunctionArgument(int i) {
return getRuleContext(TableFunctionArgumentContext.class,i);
}
public TerminalNode COPARTITION() { return getToken(StructuresSqlParserParser.COPARTITION, 0); }
public List copartitionTables() {
return getRuleContexts(CopartitionTablesContext.class);
}
public CopartitionTablesContext copartitionTables(int i) {
return getRuleContext(CopartitionTablesContext.class,i);
}
public TableFunctionCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableFunctionCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableFunctionCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableFunctionCall(this);
else return visitor.visitChildren(this);
}
}
public final TableFunctionCallContext tableFunctionCall() throws RecognitionException {
TableFunctionCallContext _localctx = new TableFunctionCallContext(_ctx, getState());
enterRule(_localctx, 112, RULE_tableFunctionCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1104);
qualifiedName();
setState(1105);
match(T__2);
setState(1114);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
{
setState(1106);
tableFunctionArgument();
setState(1111);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1107);
match(T__1);
setState(1108);
tableFunctionArgument();
}
}
setState(1113);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1125);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COPARTITION) {
{
setState(1116);
match(COPARTITION);
setState(1117);
copartitionTables();
setState(1122);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1118);
match(T__1);
setState(1119);
copartitionTables();
}
}
setState(1124);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1127);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableFunctionArgumentContext extends ParserRuleContext {
public TableArgumentContext tableArgument() {
return getRuleContext(TableArgumentContext.class,0);
}
public DescriptorArgumentContext descriptorArgument() {
return getRuleContext(DescriptorArgumentContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TableFunctionArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableFunctionArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableFunctionArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableFunctionArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableFunctionArgument(this);
else return visitor.visitChildren(this);
}
}
public final TableFunctionArgumentContext tableFunctionArgument() throws RecognitionException {
TableFunctionArgumentContext _localctx = new TableFunctionArgumentContext(_ctx, getState());
enterRule(_localctx, 114, RULE_tableFunctionArgument);
try {
enterOuterAlt(_localctx, 1);
{
setState(1132);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1129);
identifier();
setState(1130);
match(T__5);
}
break;
}
setState(1137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
{
setState(1134);
tableArgument();
}
break;
case 2:
{
setState(1135);
descriptorArgument();
}
break;
case 3:
{
setState(1136);
expression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableArgumentContext extends ParserRuleContext {
public TableArgumentRelationContext tableArgumentRelation() {
return getRuleContext(TableArgumentRelationContext.class,0);
}
public TerminalNode PARTITION() { return getToken(StructuresSqlParserParser.PARTITION, 0); }
public List BY() { return getTokens(StructuresSqlParserParser.BY); }
public TerminalNode BY(int i) {
return getToken(StructuresSqlParserParser.BY, i);
}
public TerminalNode PRUNE() { return getToken(StructuresSqlParserParser.PRUNE, 0); }
public TerminalNode WHEN() { return getToken(StructuresSqlParserParser.WHEN, 0); }
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode KEEP() { return getToken(StructuresSqlParserParser.KEEP, 0); }
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public TableArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableArgument(this);
else return visitor.visitChildren(this);
}
}
public final TableArgumentContext tableArgument() throws RecognitionException {
TableArgumentContext _localctx = new TableArgumentContext(_ctx, getState());
enterRule(_localctx, 116, RULE_tableArgument);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1139);
tableArgumentRelation();
setState(1157);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(1140);
match(PARTITION);
setState(1141);
match(T__18);
setState(1155);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
{
setState(1142);
match(T__2);
setState(1151);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,134,_ctx) ) {
case 1:
{
setState(1143);
expression();
setState(1148);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1144);
match(T__1);
setState(1145);
expression();
}
}
setState(1150);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1153);
match(T__3);
}
break;
case 2:
{
setState(1154);
expression();
}
break;
}
}
}
setState(1165);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRUNE:
{
setState(1159);
match(PRUNE);
setState(1160);
match(WHEN);
setState(1161);
match(EMPTY);
}
break;
case KEEP:
{
setState(1162);
match(KEEP);
setState(1163);
match(WHEN);
setState(1164);
match(EMPTY);
}
break;
case T__1:
case T__3:
case COPARTITION:
case ORDER:
break;
default:
break;
}
setState(1183);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1167);
match(ORDER);
setState(1168);
match(T__18);
setState(1181);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1169);
match(T__2);
setState(1170);
sortItem();
setState(1175);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1171);
match(T__1);
setState(1172);
sortItem();
}
}
setState(1177);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1178);
match(T__3);
}
break;
case 2:
{
setState(1180);
sortItem();
}
break;
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TableArgumentRelationContext extends ParserRuleContext {
public TableArgumentRelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tableArgumentRelation; }
public TableArgumentRelationContext() { }
public void copyFrom(TableArgumentRelationContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableArgumentQueryContext extends TableArgumentRelationContext {
public TerminalNode TABLE() { return getToken(StructuresSqlParserParser.TABLE, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public TableArgumentQueryContext(TableArgumentRelationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableArgumentQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableArgumentQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableArgumentQuery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TableArgumentTableContext extends TableArgumentRelationContext {
public TerminalNode TABLE() { return getToken(StructuresSqlParserParser.TABLE, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public ColumnAliasesContext columnAliases() {
return getRuleContext(ColumnAliasesContext.class,0);
}
public TableArgumentTableContext(TableArgumentRelationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTableArgumentTable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTableArgumentTable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTableArgumentTable(this);
else return visitor.visitChildren(this);
}
}
public final TableArgumentRelationContext tableArgumentRelation() throws RecognitionException {
TableArgumentRelationContext _localctx = new TableArgumentRelationContext(_ctx, getState());
enterRule(_localctx, 118, RULE_tableArgumentRelation);
int _la;
try {
setState(1211);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
_localctx = new TableArgumentTableContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1185);
match(TABLE);
setState(1186);
match(T__2);
setState(1187);
qualifiedName();
setState(1188);
match(T__3);
setState(1196);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
{
setState(1190);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(1189);
match(T__10);
}
}
setState(1192);
identifier();
setState(1194);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(1193);
columnAliases();
}
}
}
break;
}
}
break;
case 2:
_localctx = new TableArgumentQueryContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1198);
match(TABLE);
setState(1199);
match(T__2);
setState(1200);
query();
setState(1201);
match(T__3);
setState(1209);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1203);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(1202);
match(T__10);
}
}
setState(1205);
identifier();
setState(1207);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__2) {
{
setState(1206);
columnAliases();
}
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DescriptorArgumentContext extends ParserRuleContext {
public TerminalNode DESCRIPTOR() { return getToken(StructuresSqlParserParser.DESCRIPTOR, 0); }
public List descriptorField() {
return getRuleContexts(DescriptorFieldContext.class);
}
public DescriptorFieldContext descriptorField(int i) {
return getRuleContext(DescriptorFieldContext.class,i);
}
public TerminalNode CAST() { return getToken(StructuresSqlParserParser.CAST, 0); }
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public DescriptorArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_descriptorArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterDescriptorArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitDescriptorArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitDescriptorArgument(this);
else return visitor.visitChildren(this);
}
}
public final DescriptorArgumentContext descriptorArgument() throws RecognitionException {
DescriptorArgumentContext _localctx = new DescriptorArgumentContext(_ctx, getState());
enterRule(_localctx, 120, RULE_descriptorArgument);
int _la;
try {
setState(1231);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DESCRIPTOR:
enterOuterAlt(_localctx, 1);
{
setState(1213);
match(DESCRIPTOR);
setState(1214);
match(T__2);
setState(1215);
descriptorField();
setState(1220);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1216);
match(T__1);
setState(1217);
descriptorField();
}
}
setState(1222);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1223);
match(T__3);
}
break;
case CAST:
enterOuterAlt(_localctx, 2);
{
setState(1225);
match(CAST);
setState(1226);
match(T__2);
setState(1227);
match(NULL);
setState(1228);
match(T__10);
setState(1229);
match(DESCRIPTOR);
setState(1230);
match(T__3);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DescriptorFieldContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public DescriptorFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_descriptorField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterDescriptorField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitDescriptorField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitDescriptorField(this);
else return visitor.visitChildren(this);
}
}
public final DescriptorFieldContext descriptorField() throws RecognitionException {
DescriptorFieldContext _localctx = new DescriptorFieldContext(_ctx, getState());
enterRule(_localctx, 122, RULE_descriptorField);
try {
enterOuterAlt(_localctx, 1);
{
setState(1233);
identifier();
setState(1235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1234);
type(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CopartitionTablesContext extends ParserRuleContext {
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public CopartitionTablesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_copartitionTables; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCopartitionTables(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCopartitionTables(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCopartitionTables(this);
else return visitor.visitChildren(this);
}
}
public final CopartitionTablesContext copartitionTables() throws RecognitionException {
CopartitionTablesContext _localctx = new CopartitionTablesContext(_ctx, getState());
enterRule(_localctx, 124, RULE_copartitionTables);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1237);
match(T__2);
setState(1238);
qualifiedName();
setState(1239);
match(T__1);
setState(1240);
qualifiedName();
setState(1245);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1241);
match(T__1);
setState(1242);
qualifiedName();
}
}
setState(1247);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1248);
match(T__3);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 126, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1250);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanExpressionContext extends ParserRuleContext {
public BooleanExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanExpression; }
public BooleanExpressionContext() { }
public void copyFrom(BooleanExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalNotContext extends BooleanExpressionContext {
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public LogicalNotContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLogicalNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLogicalNot(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLogicalNot(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PredicatedContext extends BooleanExpressionContext {
public ValueExpressionContext valueExpression;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public PredicatedContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterPredicated(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitPredicated(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitPredicated(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrContext extends BooleanExpressionContext {
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public TerminalNode OR() { return getToken(StructuresSqlParserParser.OR, 0); }
public OrContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitOr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AndContext extends BooleanExpressionContext {
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public TerminalNode AND() { return getToken(StructuresSqlParserParser.AND, 0); }
public AndContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitAnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public final BooleanExpressionContext booleanExpression() throws RecognitionException {
return booleanExpression(0);
}
private BooleanExpressionContext booleanExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BooleanExpressionContext _localctx = new BooleanExpressionContext(_ctx, _parentState);
BooleanExpressionContext _prevctx = _localctx;
int _startState = 128;
enterRecursionRule(_localctx, 128, RULE_booleanExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1259);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__6:
case T__8:
case T__9:
case T__11:
case T__12:
case T__13:
case T__14:
case T__15:
case T__17:
case CALL:
case CALLED:
case CASCADE:
case CASE:
case CAST:
case CATALOG:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CONDITIONAL:
case COUNT:
case COPARTITION:
case CURRENT:
case CURRENT_CATALOG:
case CURRENT_DATE:
case CURRENT_PATH:
case CURRENT_SCHEMA:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case DATA:
case DATE:
case DAY:
case DECLARE:
case DEFAULT:
case DEFINE:
case DEFINER:
case DENY:
case DESC:
case DESCRIPTOR:
case DETERMINISTIC:
case DISTRIBUTED:
case DO:
case DOUBLE:
case EMPTY:
case ELSEIF:
case ENCODING:
case ERROR:
case EXCLUDING:
case EXISTS:
case EXPLAIN:
case EXTRACT:
case FALSE:
case FETCH:
case FILTER:
case FINAL:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTION:
case FUNCTIONS:
case GRACE:
case GRANT:
case GRANTED:
case GRANTS:
case GRAPHVIZ:
case GROUPING:
case GROUPS:
case HOUR:
case IF:
case IGNORE:
case IMMEDIATE:
case INCLUDING:
case INITIAL:
case INPUT:
case INTERVAL:
case INVOKER:
case IO:
case ISOLATION:
case ITERATE:
case JSON:
case JSON_ARRAY:
case JSON_EXISTS:
case JSON_OBJECT:
case JSON_QUERY:
case JSON_VALUE:
case KEEP:
case KEY:
case KEYS:
case LANGUAGE:
case LAST:
case LATERAL:
case LEADING:
case LEAVE:
case LEVEL:
case LIMIT:
case LISTAGG:
case LOCAL:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOGICAL:
case LOOP:
case MAP:
case MATCH:
case MATCHED:
case MATCHES:
case MATCH_RECOGNIZE:
case MATERIALIZED:
case MEASURES:
case MERGE:
case MINUTE:
case MONTH:
case NESTED:
case NEXT:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NONE:
case NORMALIZE:
case NULL:
case NULLIF:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case OMIT:
case ONE:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case OVERFLOW:
case PARTITION:
case PARTITIONS:
case PASSING:
case PAST:
case PATH:
case PATTERN:
case PER:
case PERIOD:
case PERMUTE:
case PLAN:
case POSITION:
case PRECEDING:
case PRECISION:
case PRIVILEGES:
case PROPERTIES:
case PRUNE:
case QUOTES:
case RANGE:
case READ:
case REFRESH:
case RENAME:
case REPEAT:
case REPEATABLE:
case REPLACE:
case RESET:
case RESPECT:
case RESTRICT:
case RETURN:
case RETURNING:
case RETURNS:
case REVOKE:
case ROLE:
case ROLES:
case ROLLBACK:
case ROW:
case ROWS:
case RUNNING:
case SCALAR:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SECURITY:
case SEEK:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSET:
case SUBSTRING:
case SYSTEM:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TEXT_STRING:
case TIES:
case TIME:
case TIMESTAMP:
case TO:
case TRAILING:
case TRANSACTION:
case TRIM:
case TRUE:
case TRUNCATE:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case UNCONDITIONAL:
case UNIQUE:
case UNKNOWN:
case UNMATCHED:
case UNTIL:
case UPDATE:
case USE:
case USER:
case UTF16:
case UTF32:
case UTF8:
case VALIDATE:
case VALUE:
case VERBOSE:
case VERSION:
case VIEW:
case WHILE:
case WINDOW:
case WITHIN:
case WITHOUT:
case WORK:
case WRAPPER:
case WRITE:
case YEAR:
case ZONE:
case PLUS:
case MINUS:
case QUESTION_MARK:
case STRING:
case UNICODE_STRING:
case BINARY_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case DOUBLE_VALUE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
{
_localctx = new PredicatedContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1253);
((PredicatedContext)_localctx).valueExpression = valueExpression(0);
setState(1255);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1254);
predicate(((PredicatedContext)_localctx).valueExpression);
}
break;
}
}
break;
case NOT:
{
_localctx = new LogicalNotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1257);
match(NOT);
setState(1258);
booleanExpression(3);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(1269);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,155,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1267);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
{
_localctx = new AndContext(new BooleanExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(1261);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1262);
match(T__7);
setState(1263);
booleanExpression(3);
}
break;
case 2:
{
_localctx = new OrContext(new BooleanExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(1264);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1265);
match(OR);
setState(1266);
booleanExpression(2);
}
break;
}
}
}
setState(1271);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,155,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PredicateContext extends ParserRuleContext {
public ParserRuleContext value;
public PredicateContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
public PredicateContext(ParserRuleContext parent, int invokingState, ParserRuleContext value) {
super(parent, invokingState);
this.value = value;
}
@Override public int getRuleIndex() { return RULE_predicate; }
public PredicateContext() { }
public void copyFrom(PredicateContext ctx) {
super.copyFrom(ctx);
this.value = ctx.value;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends PredicateContext {
public ValueExpressionContext right;
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ComparisonContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LikeContext extends PredicateContext {
public ValueExpressionContext pattern;
public ValueExpressionContext escape;
public TerminalNode LIKE() { return getToken(StructuresSqlParserParser.LIKE, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public TerminalNode ESCAPE() { return getToken(StructuresSqlParserParser.ESCAPE, 0); }
public LikeContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLike(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLike(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLike(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InSubqueryContext extends PredicateContext {
public TerminalNode IN() { return getToken(StructuresSqlParserParser.IN, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public InSubqueryContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterInSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitInSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitInSubquery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DistinctFromContext extends PredicateContext {
public ValueExpressionContext right;
public TerminalNode IS() { return getToken(StructuresSqlParserParser.IS, 0); }
public TerminalNode DISTINCT() { return getToken(StructuresSqlParserParser.DISTINCT, 0); }
public TerminalNode FROM() { return getToken(StructuresSqlParserParser.FROM, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public DistinctFromContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterDistinctFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitDistinctFrom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitDistinctFrom(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InListContext extends PredicateContext {
public TerminalNode IN() { return getToken(StructuresSqlParserParser.IN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public InListContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterInList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitInList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitInList(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullPredicateContext extends PredicateContext {
public TerminalNode IS() { return getToken(StructuresSqlParserParser.IS, 0); }
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public NullPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNullPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNullPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNullPredicate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BetweenContext extends PredicateContext {
public ValueExpressionContext lower;
public ValueExpressionContext upper;
public TerminalNode BETWEEN() { return getToken(StructuresSqlParserParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(StructuresSqlParserParser.AND, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(StructuresSqlParserParser.NOT, 0); }
public BetweenContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterBetween(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitBetween(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitBetween(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QuantifiedComparisonContext extends PredicateContext {
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ComparisonQuantifierContext comparisonQuantifier() {
return getRuleContext(ComparisonQuantifierContext.class,0);
}
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public QuantifiedComparisonContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterQuantifiedComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitQuantifiedComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitQuantifiedComparison(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate(ParserRuleContext value) throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState(), value);
enterRule(_localctx, 130, RULE_predicate);
int _la;
try {
setState(1333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
_localctx = new ComparisonContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1272);
comparisonOperator();
setState(1273);
((ComparisonContext)_localctx).right = valueExpression(0);
}
break;
case 2:
_localctx = new QuantifiedComparisonContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1275);
comparisonOperator();
setState(1276);
comparisonQuantifier();
setState(1277);
match(T__2);
setState(1278);
query();
setState(1279);
match(T__3);
}
break;
case 3:
_localctx = new BetweenContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1281);
match(NOT);
}
}
setState(1284);
match(T__16);
setState(1285);
((BetweenContext)_localctx).lower = valueExpression(0);
setState(1286);
match(T__7);
setState(1287);
((BetweenContext)_localctx).upper = valueExpression(0);
}
break;
case 4:
_localctx = new InListContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1289);
match(NOT);
}
}
setState(1292);
match(IN);
setState(1293);
match(T__2);
setState(1294);
expression();
setState(1299);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1295);
match(T__1);
setState(1296);
expression();
}
}
setState(1301);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1302);
match(T__3);
}
break;
case 5:
_localctx = new InSubqueryContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1304);
match(NOT);
}
}
setState(1307);
match(IN);
setState(1308);
match(T__2);
setState(1309);
query();
setState(1310);
match(T__3);
}
break;
case 6:
_localctx = new LikeContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1313);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1312);
match(NOT);
}
}
setState(1315);
match(LIKE);
setState(1316);
((LikeContext)_localctx).pattern = valueExpression(0);
setState(1319);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1317);
match(ESCAPE);
setState(1318);
((LikeContext)_localctx).escape = valueExpression(0);
}
break;
}
}
break;
case 7:
_localctx = new NullPredicateContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1321);
match(IS);
setState(1323);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1322);
match(NOT);
}
}
setState(1325);
match(NULL);
}
break;
case 8:
_localctx = new DistinctFromContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(1326);
match(IS);
setState(1328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1327);
match(NOT);
}
}
setState(1330);
match(DISTINCT);
setState(1331);
match(FROM);
setState(1332);
((DistinctFromContext)_localctx).right = valueExpression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionContext extends ParserRuleContext {
public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueExpression; }
public ValueExpressionContext() { }
public void copyFrom(ValueExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionDefaultContext extends ValueExpressionContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionDefaultContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterValueExpressionDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitValueExpressionDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitValueExpressionDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConcatenationContext extends ValueExpressionContext {
public ValueExpressionContext left;
public ValueExpressionContext right;
public TerminalNode CONCAT() { return getToken(StructuresSqlParserParser.CONCAT, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public ConcatenationContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterConcatenation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitConcatenation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitConcatenation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticBinaryContext extends ValueExpressionContext {
public ValueExpressionContext left;
public Token operator;
public ValueExpressionContext right;
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode ASTERISK() { return getToken(StructuresSqlParserParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(StructuresSqlParserParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(StructuresSqlParserParser.PERCENT, 0); }
public TerminalNode PLUS() { return getToken(StructuresSqlParserParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(StructuresSqlParserParser.MINUS, 0); }
public ArithmeticBinaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterArithmeticBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitArithmeticBinary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitArithmeticBinary(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticUnaryContext extends ValueExpressionContext {
public Token operator;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode MINUS() { return getToken(StructuresSqlParserParser.MINUS, 0); }
public TerminalNode PLUS() { return getToken(StructuresSqlParserParser.PLUS, 0); }
public ArithmeticUnaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterArithmeticUnary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitArithmeticUnary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitArithmeticUnary(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AtTimeZoneContext extends ValueExpressionContext {
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode AT() { return getToken(StructuresSqlParserParser.AT, 0); }
public TimeZoneSpecifierContext timeZoneSpecifier() {
return getRuleContext(TimeZoneSpecifierContext.class,0);
}
public AtTimeZoneContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterAtTimeZone(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitAtTimeZone(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitAtTimeZone(this);
else return visitor.visitChildren(this);
}
}
public final ValueExpressionContext valueExpression() throws RecognitionException {
return valueExpression(0);
}
private ValueExpressionContext valueExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, _parentState);
ValueExpressionContext _prevctx = _localctx;
int _startState = 132;
enterRecursionRule(_localctx, 132, RULE_valueExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
{
_localctx = new ValueExpressionDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1336);
primaryExpression(0);
}
break;
case 2:
{
_localctx = new ArithmeticUnaryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1337);
((ArithmeticUnaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((ArithmeticUnaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1338);
valueExpression(4);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1355);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,167,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1353);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(1341);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1342);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 303)) & ~0x3f) == 0 && ((1L << (_la - 303)) & 7L) != 0)) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1343);
((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
}
break;
case 2:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(1344);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1345);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1346);
((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
}
break;
case 3:
{
_localctx = new ConcatenationContext(new ValueExpressionContext(_parentctx, _parentState));
((ConcatenationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(1347);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1348);
match(CONCAT);
setState(1349);
((ConcatenationContext)_localctx).right = valueExpression(2);
}
break;
case 4:
{
_localctx = new AtTimeZoneContext(new ValueExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(1350);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1351);
match(T__12);
setState(1352);
timeZoneSpecifier();
}
break;
}
}
}
setState(1357);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,167,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
public PrimaryExpressionContext() { }
public void copyFrom(PrimaryExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DereferenceContext extends PrimaryExpressionContext {
public PrimaryExpressionContext base;
public IdentifierContext fieldName;
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DereferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterDereference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitDereference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitDereference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeConstructorContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode DOUBLE() { return getToken(StructuresSqlParserParser.DOUBLE, 0); }
public TerminalNode PRECISION() { return getToken(StructuresSqlParserParser.PRECISION, 0); }
public TypeConstructorContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTypeConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTypeConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTypeConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonValueContext extends PrimaryExpressionContext {
public JsonValueBehaviorContext emptyBehavior;
public JsonValueBehaviorContext errorBehavior;
public TerminalNode JSON_VALUE() { return getToken(StructuresSqlParserParser.JSON_VALUE, 0); }
public JsonPathInvocationContext jsonPathInvocation() {
return getRuleContext(JsonPathInvocationContext.class,0);
}
public TerminalNode RETURNING() { return getToken(StructuresSqlParserParser.RETURNING, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List ON() { return getTokens(StructuresSqlParserParser.ON); }
public TerminalNode ON(int i) {
return getToken(StructuresSqlParserParser.ON, i);
}
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public List jsonValueBehavior() {
return getRuleContexts(JsonValueBehaviorContext.class);
}
public JsonValueBehaviorContext jsonValueBehavior(int i) {
return getRuleContext(JsonValueBehaviorContext.class,i);
}
public JsonValueContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonValue(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentDateContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(StructuresSqlParserParser.CURRENT_DATE, 0); }
public CurrentDateContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentDate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentDate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentDate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubstringContext extends PrimaryExpressionContext {
public TerminalNode SUBSTRING() { return getToken(StructuresSqlParserParser.SUBSTRING, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode FROM() { return getToken(StructuresSqlParserParser.FROM, 0); }
public TerminalNode FOR() { return getToken(StructuresSqlParserParser.FOR, 0); }
public SubstringContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubstring(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubstring(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubstring(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CastContext extends PrimaryExpressionContext {
public TerminalNode CAST() { return getToken(StructuresSqlParserParser.CAST, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode TRY_CAST() { return getToken(StructuresSqlParserParser.TRY_CAST, 0); }
public CastContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCast(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCast(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LambdaContext extends PrimaryExpressionContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public LambdaContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLambda(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLambda(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLambda(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedExpressionContext extends PrimaryExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParenthesizedExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterParenthesizedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitParenthesizedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitParenthesizedExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TrimContext extends PrimaryExpressionContext {
public ValueExpressionContext trimChar;
public ValueExpressionContext trimSource;
public TerminalNode TRIM() { return getToken(StructuresSqlParserParser.TRIM, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode FROM() { return getToken(StructuresSqlParserParser.FROM, 0); }
public TrimsSpecificationContext trimsSpecification() {
return getRuleContext(TrimsSpecificationContext.class,0);
}
public TrimContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterTrim(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitTrim(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitTrim(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterContext extends PrimaryExpressionContext {
public TerminalNode QUESTION_MARK() { return getToken(StructuresSqlParserParser.QUESTION_MARK, 0); }
public ParameterContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitParameter(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NormalizeContext extends PrimaryExpressionContext {
public TerminalNode NORMALIZE() { return getToken(StructuresSqlParserParser.NORMALIZE, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public NormalFormContext normalForm() {
return getRuleContext(NormalFormContext.class,0);
}
public NormalizeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNormalize(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNormalize(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNormalize(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LocalTimestampContext extends PrimaryExpressionContext {
public Token name;
public Token precision;
public TerminalNode LOCALTIMESTAMP() { return getToken(StructuresSqlParserParser.LOCALTIMESTAMP, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(StructuresSqlParserParser.INTEGER_VALUE, 0); }
public LocalTimestampContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLocalTimestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLocalTimestamp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLocalTimestamp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonObjectContext extends PrimaryExpressionContext {
public TerminalNode JSON_OBJECT() { return getToken(StructuresSqlParserParser.JSON_OBJECT, 0); }
public List jsonObjectMember() {
return getRuleContexts(JsonObjectMemberContext.class);
}
public JsonObjectMemberContext jsonObjectMember(int i) {
return getRuleContext(JsonObjectMemberContext.class,i);
}
public TerminalNode RETURNING() { return getToken(StructuresSqlParserParser.RETURNING, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List NULL() { return getTokens(StructuresSqlParserParser.NULL); }
public TerminalNode NULL(int i) {
return getToken(StructuresSqlParserParser.NULL, i);
}
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public TerminalNode ABSENT() { return getToken(StructuresSqlParserParser.ABSENT, 0); }
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode UNIQUE() { return getToken(StructuresSqlParserParser.UNIQUE, 0); }
public TerminalNode WITHOUT() { return getToken(StructuresSqlParserParser.WITHOUT, 0); }
public TerminalNode FORMAT() { return getToken(StructuresSqlParserParser.FORMAT, 0); }
public JsonRepresentationContext jsonRepresentation() {
return getRuleContext(JsonRepresentationContext.class,0);
}
public TerminalNode KEYS() { return getToken(StructuresSqlParserParser.KEYS, 0); }
public JsonObjectContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonObject(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonObject(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntervalLiteralContext extends PrimaryExpressionContext {
public IntervalContext interval() {
return getRuleContext(IntervalContext.class,0);
}
public IntervalLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterIntervalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitIntervalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitIntervalLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NumericLiteralContext extends PrimaryExpressionContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends PrimaryExpressionContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonArrayContext extends PrimaryExpressionContext {
public TerminalNode JSON_ARRAY() { return getToken(StructuresSqlParserParser.JSON_ARRAY, 0); }
public List jsonValueExpression() {
return getRuleContexts(JsonValueExpressionContext.class);
}
public JsonValueExpressionContext jsonValueExpression(int i) {
return getRuleContext(JsonValueExpressionContext.class,i);
}
public TerminalNode RETURNING() { return getToken(StructuresSqlParserParser.RETURNING, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List NULL() { return getTokens(StructuresSqlParserParser.NULL); }
public TerminalNode NULL(int i) {
return getToken(StructuresSqlParserParser.NULL, i);
}
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public TerminalNode ABSENT() { return getToken(StructuresSqlParserParser.ABSENT, 0); }
public TerminalNode FORMAT() { return getToken(StructuresSqlParserParser.FORMAT, 0); }
public JsonRepresentationContext jsonRepresentation() {
return getRuleContext(JsonRepresentationContext.class,0);
}
public JsonArrayContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonArray(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonArray(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleCaseContext extends PrimaryExpressionContext {
public ExpressionContext operand;
public ExpressionContext elseExpression;
public TerminalNode CASE() { return getToken(StructuresSqlParserParser.CASE, 0); }
public TerminalNode END() { return getToken(StructuresSqlParserParser.END, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public TerminalNode ELSE() { return getToken(StructuresSqlParserParser.ELSE, 0); }
public SimpleCaseContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSimpleCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSimpleCase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSimpleCase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnReferenceContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ColumnReferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterColumnReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitColumnReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitColumnReference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullLiteralContext extends PrimaryExpressionContext {
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public NullLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNullLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNullLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RowConstructorContext extends PrimaryExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ROW() { return getToken(StructuresSqlParserParser.ROW, 0); }
public RowConstructorContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterRowConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitRowConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitRowConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubscriptContext extends PrimaryExpressionContext {
public PrimaryExpressionContext value;
public ValueExpressionContext index;
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public SubscriptContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubscript(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubscript(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubscript(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonExistsContext extends PrimaryExpressionContext {
public TerminalNode JSON_EXISTS() { return getToken(StructuresSqlParserParser.JSON_EXISTS, 0); }
public JsonPathInvocationContext jsonPathInvocation() {
return getRuleContext(JsonPathInvocationContext.class,0);
}
public JsonExistsErrorBehaviorContext jsonExistsErrorBehavior() {
return getRuleContext(JsonExistsErrorBehaviorContext.class,0);
}
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public JsonExistsContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonExists(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonExists(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonExists(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentPathContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_PATH() { return getToken(StructuresSqlParserParser.CURRENT_PATH, 0); }
public CurrentPathContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentPath(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubqueryExpressionContext extends PrimaryExpressionContext {
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public SubqueryExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSubqueryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSubqueryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSubqueryExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BinaryLiteralContext extends PrimaryExpressionContext {
public TerminalNode BINARY_LITERAL() { return getToken(StructuresSqlParserParser.BINARY_LITERAL, 0); }
public BinaryLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterBinaryLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitBinaryLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitBinaryLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentTimeContext extends PrimaryExpressionContext {
public Token name;
public Token precision;
public TerminalNode CURRENT_TIME() { return getToken(StructuresSqlParserParser.CURRENT_TIME, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(StructuresSqlParserParser.INTEGER_VALUE, 0); }
public CurrentTimeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentTime(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentTime(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LocalTimeContext extends PrimaryExpressionContext {
public Token name;
public Token precision;
public TerminalNode LOCALTIME() { return getToken(StructuresSqlParserParser.LOCALTIME, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(StructuresSqlParserParser.INTEGER_VALUE, 0); }
public LocalTimeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterLocalTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitLocalTime(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitLocalTime(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentUserContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_USER() { return getToken(StructuresSqlParserParser.CURRENT_USER, 0); }
public CurrentUserContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentUser(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class JsonQueryContext extends PrimaryExpressionContext {
public JsonQueryBehaviorContext emptyBehavior;
public JsonQueryBehaviorContext errorBehavior;
public TerminalNode JSON_QUERY() { return getToken(StructuresSqlParserParser.JSON_QUERY, 0); }
public JsonPathInvocationContext jsonPathInvocation() {
return getRuleContext(JsonPathInvocationContext.class,0);
}
public TerminalNode RETURNING() { return getToken(StructuresSqlParserParser.RETURNING, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public JsonQueryWrapperBehaviorContext jsonQueryWrapperBehavior() {
return getRuleContext(JsonQueryWrapperBehaviorContext.class,0);
}
public TerminalNode WRAPPER() { return getToken(StructuresSqlParserParser.WRAPPER, 0); }
public TerminalNode QUOTES() { return getToken(StructuresSqlParserParser.QUOTES, 0); }
public List ON() { return getTokens(StructuresSqlParserParser.ON); }
public TerminalNode ON(int i) {
return getToken(StructuresSqlParserParser.ON, i);
}
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public TerminalNode KEEP() { return getToken(StructuresSqlParserParser.KEEP, 0); }
public TerminalNode OMIT() { return getToken(StructuresSqlParserParser.OMIT, 0); }
public List jsonQueryBehavior() {
return getRuleContexts(JsonQueryBehaviorContext.class);
}
public JsonQueryBehaviorContext jsonQueryBehavior(int i) {
return getRuleContext(JsonQueryBehaviorContext.class,i);
}
public TerminalNode FORMAT() { return getToken(StructuresSqlParserParser.FORMAT, 0); }
public JsonRepresentationContext jsonRepresentation() {
return getRuleContext(JsonRepresentationContext.class,0);
}
public TerminalNode SCALAR() { return getToken(StructuresSqlParserParser.SCALAR, 0); }
public TerminalNode TEXT_STRING() { return getToken(StructuresSqlParserParser.TEXT_STRING, 0); }
public JsonQueryContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonQuery(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MeasureContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OverContext over() {
return getRuleContext(OverContext.class,0);
}
public MeasureContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterMeasure(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitMeasure(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitMeasure(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExtractContext extends PrimaryExpressionContext {
public TerminalNode EXTRACT() { return getToken(StructuresSqlParserParser.EXTRACT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode FROM() { return getToken(StructuresSqlParserParser.FROM, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ExtractContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterExtract(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitExtract(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitExtract(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends PrimaryExpressionContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public StringLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayConstructorContext extends PrimaryExpressionContext {
public TerminalNode ARRAY() { return getToken(StructuresSqlParserParser.ARRAY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArrayConstructorContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterArrayConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitArrayConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitArrayConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionCallContext extends PrimaryExpressionContext {
public IdentifierContext label;
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(StructuresSqlParserParser.ASTERISK, 0); }
public ProcessingModeContext processingMode() {
return getRuleContext(ProcessingModeContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public OverContext over() {
return getRuleContext(OverContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public TerminalNode BY() { return getToken(StructuresSqlParserParser.BY, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public NullTreatmentContext nullTreatment() {
return getRuleContext(NullTreatmentContext.class,0);
}
public FunctionCallContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitFunctionCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitFunctionCall(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentTimestampContext extends PrimaryExpressionContext {
public Token name;
public Token precision;
public TerminalNode CURRENT_TIMESTAMP() { return getToken(StructuresSqlParserParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(StructuresSqlParserParser.INTEGER_VALUE, 0); }
public CurrentTimestampContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentTimestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentTimestamp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentTimestamp(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentSchemaContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_SCHEMA() { return getToken(StructuresSqlParserParser.CURRENT_SCHEMA, 0); }
public CurrentSchemaContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentSchema(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentSchema(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentSchema(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExistsContext extends PrimaryExpressionContext {
public TerminalNode EXISTS() { return getToken(StructuresSqlParserParser.EXISTS, 0); }
public QueryContext query() {
return getRuleContext(QueryContext.class,0);
}
public ExistsContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterExists(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitExists(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitExists(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PositionContext extends PrimaryExpressionContext {
public TerminalNode POSITION() { return getToken(StructuresSqlParserParser.POSITION, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode IN() { return getToken(StructuresSqlParserParser.IN, 0); }
public PositionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterPosition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitPosition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitPosition(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ListaggContext extends PrimaryExpressionContext {
public Token name;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LISTAGG() { return getToken(StructuresSqlParserParser.LISTAGG, 0); }
public TerminalNode WITHIN() { return getToken(StructuresSqlParserParser.WITHIN, 0); }
public TerminalNode GROUP() { return getToken(StructuresSqlParserParser.GROUP, 0); }
public TerminalNode ORDER() { return getToken(StructuresSqlParserParser.ORDER, 0); }
public TerminalNode BY() { return getToken(StructuresSqlParserParser.BY, 0); }
public List sortItem() {
return getRuleContexts(SortItemContext.class);
}
public SortItemContext sortItem(int i) {
return getRuleContext(SortItemContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode ON() { return getToken(StructuresSqlParserParser.ON, 0); }
public TerminalNode OVERFLOW() { return getToken(StructuresSqlParserParser.OVERFLOW, 0); }
public ListAggOverflowBehaviorContext listAggOverflowBehavior() {
return getRuleContext(ListAggOverflowBehaviorContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public ListaggContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterListagg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitListagg(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitListagg(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SearchedCaseContext extends PrimaryExpressionContext {
public ExpressionContext elseExpression;
public TerminalNode CASE() { return getToken(StructuresSqlParserParser.CASE, 0); }
public TerminalNode END() { return getToken(StructuresSqlParserParser.END, 0); }
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public TerminalNode ELSE() { return getToken(StructuresSqlParserParser.ELSE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SearchedCaseContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterSearchedCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitSearchedCase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitSearchedCase(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentCatalogContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_CATALOG() { return getToken(StructuresSqlParserParser.CURRENT_CATALOG, 0); }
public CurrentCatalogContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterCurrentCatalog(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitCurrentCatalog(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitCurrentCatalog(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GroupingOperationContext extends PrimaryExpressionContext {
public TerminalNode GROUPING() { return getToken(StructuresSqlParserParser.GROUPING, 0); }
public List qualifiedName() {
return getRuleContexts(QualifiedNameContext.class);
}
public QualifiedNameContext qualifiedName(int i) {
return getRuleContext(QualifiedNameContext.class,i);
}
public GroupingOperationContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterGroupingOperation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitGroupingOperation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitGroupingOperation(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
return primaryExpression(0);
}
private PrimaryExpressionContext primaryExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, _parentState);
PrimaryExpressionContext _prevctx = _localctx;
int _startState = 134;
enterRecursionRule(_localctx, 134, RULE_primaryExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1811);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) {
case 1:
{
_localctx = new NullLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1359);
match(NULL);
}
break;
case 2:
{
_localctx = new IntervalLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1360);
interval();
}
break;
case 3:
{
_localctx = new TypeConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1361);
identifier();
setState(1362);
string();
}
break;
case 4:
{
_localctx = new TypeConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1364);
match(DOUBLE);
setState(1365);
match(PRECISION);
setState(1366);
string();
}
break;
case 5:
{
_localctx = new NumericLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1367);
number();
}
break;
case 6:
{
_localctx = new BooleanLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1368);
booleanValue();
}
break;
case 7:
{
_localctx = new StringLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1369);
string();
}
break;
case 8:
{
_localctx = new BinaryLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1370);
match(BINARY_LITERAL);
}
break;
case 9:
{
_localctx = new ParameterContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1371);
match(QUESTION_MARK);
}
break;
case 10:
{
_localctx = new PositionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1372);
match(POSITION);
setState(1373);
match(T__2);
setState(1374);
valueExpression(0);
setState(1375);
match(IN);
setState(1376);
valueExpression(0);
setState(1377);
match(T__3);
}
break;
case 11:
{
_localctx = new RowConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1379);
match(T__2);
setState(1380);
expression();
setState(1383);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1381);
match(T__1);
setState(1382);
expression();
}
}
setState(1385);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__1 );
setState(1387);
match(T__3);
}
break;
case 12:
{
_localctx = new RowConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1389);
match(ROW);
setState(1390);
match(T__2);
setState(1391);
expression();
setState(1396);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1392);
match(T__1);
setState(1393);
expression();
}
}
setState(1398);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1399);
match(T__3);
}
break;
case 13:
{
_localctx = new ListaggContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1401);
((ListaggContext)_localctx).name = match(LISTAGG);
setState(1402);
match(T__2);
setState(1404);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
{
setState(1403);
setQuantifier();
}
break;
}
setState(1406);
expression();
setState(1409);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(1407);
match(T__1);
setState(1408);
string();
}
}
setState(1414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1411);
match(ON);
setState(1412);
match(OVERFLOW);
setState(1413);
listAggOverflowBehavior();
}
}
setState(1416);
match(T__3);
{
setState(1417);
match(WITHIN);
setState(1418);
match(GROUP);
setState(1419);
match(T__2);
setState(1420);
match(ORDER);
setState(1421);
match(T__18);
setState(1422);
sortItem();
setState(1427);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1423);
match(T__1);
setState(1424);
sortItem();
}
}
setState(1429);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1430);
match(T__3);
}
setState(1433);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
{
setState(1432);
filter();
}
break;
}
}
break;
case 14:
{
_localctx = new FunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1436);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
{
setState(1435);
processingMode();
}
break;
}
setState(1438);
qualifiedName();
setState(1439);
match(T__2);
setState(1443);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5262737029699602754L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -9120583187364427405L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -6228115030305409L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & 9149062092676919263L) != 0) || ((((_la - 257)) & ~0x3f) == 0 && ((1L << (_la - 257)) & 4323455915874252663L) != 0)) {
{
setState(1440);
((FunctionCallContext)_localctx).label = identifier();
setState(1441);
match(T__0);
}
}
setState(1445);
match(ASTERISK);
setState(1446);
match(T__3);
setState(1448);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
{
setState(1447);
filter();
}
break;
}
setState(1451);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1450);
over();
}
break;
}
}
break;
case 15:
{
_localctx = new FunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1454);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
{
setState(1453);
processingMode();
}
break;
}
setState(1456);
qualifiedName();
setState(1457);
match(T__2);
setState(1469);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
{
setState(1459);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
{
setState(1458);
setQuantifier();
}
break;
}
setState(1461);
expression();
setState(1466);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1462);
match(T__1);
setState(1463);
expression();
}
}
setState(1468);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1481);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(1471);
match(ORDER);
setState(1472);
match(T__18);
setState(1473);
sortItem();
setState(1478);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1474);
match(T__1);
setState(1475);
sortItem();
}
}
setState(1480);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1483);
match(T__3);
setState(1485);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
{
setState(1484);
filter();
}
break;
}
setState(1491);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) {
case 1:
{
setState(1488);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IGNORE || _la==RESPECT) {
{
setState(1487);
nullTreatment();
}
}
setState(1490);
over();
}
break;
}
}
break;
case 16:
{
_localctx = new MeasureContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1493);
identifier();
setState(1494);
over();
}
break;
case 17:
{
_localctx = new LambdaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1496);
identifier();
setState(1497);
match(T__6);
setState(1498);
expression();
}
break;
case 18:
{
_localctx = new LambdaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1500);
match(T__2);
setState(1509);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
setState(1501);
identifier();
setState(1506);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1502);
match(T__1);
setState(1503);
identifier();
}
}
setState(1508);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1511);
match(T__3);
setState(1512);
match(T__6);
setState(1513);
expression();
}
break;
case 19:
{
_localctx = new SubqueryExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1514);
match(T__2);
setState(1515);
query();
setState(1516);
match(T__3);
}
break;
case 20:
{
_localctx = new ExistsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1518);
match(EXISTS);
setState(1519);
match(T__2);
setState(1520);
query();
setState(1521);
match(T__3);
}
break;
case 21:
{
_localctx = new SimpleCaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1523);
match(CASE);
setState(1524);
((SimpleCaseContext)_localctx).operand = expression();
setState(1526);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1525);
whenClause();
}
}
setState(1528);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(1532);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1530);
match(ELSE);
setState(1531);
((SimpleCaseContext)_localctx).elseExpression = expression();
}
}
setState(1534);
match(END);
}
break;
case 22:
{
_localctx = new SearchedCaseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1536);
match(CASE);
setState(1538);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1537);
whenClause();
}
}
setState(1540);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(1544);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(1542);
match(ELSE);
setState(1543);
((SearchedCaseContext)_localctx).elseExpression = expression();
}
}
setState(1546);
match(END);
}
break;
case 23:
{
_localctx = new CastContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1548);
match(CAST);
setState(1549);
match(T__2);
setState(1550);
expression();
setState(1551);
match(T__10);
setState(1552);
type(0);
setState(1553);
match(T__3);
}
break;
case 24:
{
_localctx = new CastContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1555);
match(TRY_CAST);
setState(1556);
match(T__2);
setState(1557);
expression();
setState(1558);
match(T__10);
setState(1559);
type(0);
setState(1560);
match(T__3);
}
break;
case 25:
{
_localctx = new ArrayConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1562);
match(T__9);
setState(1563);
match(T__7);
setState(1572);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
{
setState(1564);
expression();
setState(1569);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1565);
match(T__1);
setState(1566);
expression();
}
}
setState(1571);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1574);
match(T__8);
}
break;
case 26:
{
_localctx = new ColumnReferenceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1575);
identifier();
}
break;
case 27:
{
_localctx = new CurrentDateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1576);
((CurrentDateContext)_localctx).name = match(CURRENT_DATE);
}
break;
case 28:
{
_localctx = new CurrentTimeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1577);
((CurrentTimeContext)_localctx).name = match(CURRENT_TIME);
setState(1581);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
case 1:
{
setState(1578);
match(T__2);
setState(1579);
((CurrentTimeContext)_localctx).precision = match(INTEGER_VALUE);
setState(1580);
match(T__3);
}
break;
}
}
break;
case 29:
{
_localctx = new CurrentTimestampContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1583);
((CurrentTimestampContext)_localctx).name = match(CURRENT_TIMESTAMP);
setState(1587);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) {
case 1:
{
setState(1584);
match(T__2);
setState(1585);
((CurrentTimestampContext)_localctx).precision = match(INTEGER_VALUE);
setState(1586);
match(T__3);
}
break;
}
}
break;
case 30:
{
_localctx = new LocalTimeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1589);
((LocalTimeContext)_localctx).name = match(LOCALTIME);
setState(1593);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
case 1:
{
setState(1590);
match(T__2);
setState(1591);
((LocalTimeContext)_localctx).precision = match(INTEGER_VALUE);
setState(1592);
match(T__3);
}
break;
}
}
break;
case 31:
{
_localctx = new LocalTimestampContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1595);
((LocalTimestampContext)_localctx).name = match(LOCALTIMESTAMP);
setState(1599);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
case 1:
{
setState(1596);
match(T__2);
setState(1597);
((LocalTimestampContext)_localctx).precision = match(INTEGER_VALUE);
setState(1598);
match(T__3);
}
break;
}
}
break;
case 32:
{
_localctx = new CurrentUserContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1601);
((CurrentUserContext)_localctx).name = match(CURRENT_USER);
}
break;
case 33:
{
_localctx = new CurrentCatalogContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1602);
((CurrentCatalogContext)_localctx).name = match(CURRENT_CATALOG);
}
break;
case 34:
{
_localctx = new CurrentSchemaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1603);
((CurrentSchemaContext)_localctx).name = match(CURRENT_SCHEMA);
}
break;
case 35:
{
_localctx = new CurrentPathContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1604);
((CurrentPathContext)_localctx).name = match(CURRENT_PATH);
}
break;
case 36:
{
_localctx = new TrimContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1605);
match(TRIM);
setState(1606);
match(T__2);
setState(1614);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
setState(1608);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
setState(1607);
trimsSpecification();
}
break;
}
setState(1611);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -5262465450302376258L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -2347169330619225741L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & -6227771432895105L) != 0) || ((((_la - 192)) & ~0x3f) == 0 && ((1L << (_la - 192)) & -74309944177856545L) != 0) || ((((_la - 256)) & ~0x3f) == 0 && ((1L << (_la - 256)) & 9216722737727139567L) != 0)) {
{
setState(1610);
((TrimContext)_localctx).trimChar = valueExpression(0);
}
}
setState(1613);
match(FROM);
}
break;
}
setState(1616);
((TrimContext)_localctx).trimSource = valueExpression(0);
setState(1617);
match(T__3);
}
break;
case 37:
{
_localctx = new TrimContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1619);
match(TRIM);
setState(1620);
match(T__2);
setState(1621);
((TrimContext)_localctx).trimSource = valueExpression(0);
setState(1622);
match(T__1);
setState(1623);
((TrimContext)_localctx).trimChar = valueExpression(0);
setState(1624);
match(T__3);
}
break;
case 38:
{
_localctx = new SubstringContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1626);
match(SUBSTRING);
setState(1627);
match(T__2);
setState(1628);
valueExpression(0);
setState(1629);
match(FROM);
setState(1630);
valueExpression(0);
setState(1633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR) {
{
setState(1631);
match(FOR);
setState(1632);
valueExpression(0);
}
}
setState(1635);
match(T__3);
}
break;
case 39:
{
_localctx = new NormalizeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1637);
match(NORMALIZE);
setState(1638);
match(T__2);
setState(1639);
valueExpression(0);
setState(1642);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(1640);
match(T__1);
setState(1641);
normalForm();
}
}
setState(1644);
match(T__3);
}
break;
case 40:
{
_localctx = new ExtractContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1646);
match(EXTRACT);
setState(1647);
match(T__2);
setState(1648);
identifier();
setState(1649);
match(FROM);
setState(1650);
valueExpression(0);
setState(1651);
match(T__3);
}
break;
case 41:
{
_localctx = new ParenthesizedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1653);
match(T__2);
setState(1654);
expression();
setState(1655);
match(T__3);
}
break;
case 42:
{
_localctx = new GroupingOperationContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1657);
match(GROUPING);
setState(1658);
match(T__2);
setState(1667);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
{
setState(1659);
qualifiedName();
setState(1664);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1660);
match(T__1);
setState(1661);
qualifiedName();
}
}
setState(1666);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(1669);
match(T__3);
}
break;
case 43:
{
_localctx = new JsonExistsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1670);
match(JSON_EXISTS);
setState(1671);
match(T__2);
setState(1672);
jsonPathInvocation();
setState(1677);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ERROR || _la==FALSE || _la==TRUE || _la==UNKNOWN) {
{
setState(1673);
jsonExistsErrorBehavior();
setState(1674);
match(ON);
setState(1675);
match(ERROR);
}
}
setState(1679);
match(T__3);
}
break;
case 44:
{
_localctx = new JsonValueContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1681);
match(JSON_VALUE);
setState(1682);
match(T__2);
setState(1683);
jsonPathInvocation();
setState(1686);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1684);
match(RETURNING);
setState(1685);
type(0);
}
}
setState(1692);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
case 1:
{
setState(1688);
((JsonValueContext)_localctx).emptyBehavior = jsonValueBehavior();
setState(1689);
match(ON);
setState(1690);
match(EMPTY);
}
break;
}
setState(1698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT || _la==ERROR || _la==NULL) {
{
setState(1694);
((JsonValueContext)_localctx).errorBehavior = jsonValueBehavior();
setState(1695);
match(ON);
setState(1696);
match(ERROR);
}
}
setState(1700);
match(T__3);
}
break;
case 45:
{
_localctx = new JsonQueryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1702);
match(JSON_QUERY);
setState(1703);
match(T__2);
setState(1704);
jsonPathInvocation();
setState(1711);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1705);
match(RETURNING);
setState(1706);
type(0);
setState(1709);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FORMAT) {
{
setState(1707);
match(FORMAT);
setState(1708);
jsonRepresentation();
}
}
}
}
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH || _la==WITHOUT) {
{
setState(1713);
jsonQueryWrapperBehavior();
setState(1714);
match(WRAPPER);
}
}
setState(1725);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KEEP || _la==OMIT) {
{
setState(1718);
_la = _input.LA(1);
if ( !(_la==KEEP || _la==OMIT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1719);
match(QUOTES);
setState(1723);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(1720);
match(ON);
setState(1721);
match(SCALAR);
setState(1722);
match(TEXT_STRING);
}
}
}
}
setState(1731);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
{
setState(1727);
((JsonQueryContext)_localctx).emptyBehavior = jsonQueryBehavior();
setState(1728);
match(ON);
setState(1729);
match(EMPTY);
}
break;
}
setState(1737);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EMPTY || _la==ERROR || _la==NULL) {
{
setState(1733);
((JsonQueryContext)_localctx).errorBehavior = jsonQueryBehavior();
setState(1734);
match(ON);
setState(1735);
match(ERROR);
}
}
setState(1739);
match(T__3);
}
break;
case 46:
{
_localctx = new JsonObjectContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1741);
match(JSON_OBJECT);
setState(1742);
match(T__2);
setState(1771);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,223,_ctx) ) {
case 1:
{
setState(1743);
jsonObjectMember();
setState(1748);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1744);
match(T__1);
setState(1745);
jsonObjectMember();
}
}
setState(1750);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1757);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NULL:
{
setState(1751);
match(NULL);
setState(1752);
match(ON);
setState(1753);
match(NULL);
}
break;
case T__0:
{
setState(1754);
match(T__0);
setState(1755);
match(ON);
setState(1756);
match(NULL);
}
break;
case T__3:
case RETURNING:
case WITH:
case WITHOUT:
break;
default:
break;
}
setState(1769);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WITH:
{
setState(1759);
match(WITH);
setState(1760);
match(UNIQUE);
setState(1762);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KEYS) {
{
setState(1761);
match(KEYS);
}
}
}
break;
case WITHOUT:
{
setState(1764);
match(WITHOUT);
setState(1765);
match(UNIQUE);
setState(1767);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KEYS) {
{
setState(1766);
match(KEYS);
}
}
}
break;
case T__3:
case RETURNING:
break;
default:
break;
}
}
break;
}
setState(1779);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1773);
match(RETURNING);
setState(1774);
type(0);
setState(1777);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FORMAT) {
{
setState(1775);
match(FORMAT);
setState(1776);
jsonRepresentation();
}
}
}
}
setState(1781);
match(T__3);
}
break;
case 47:
{
_localctx = new JsonArrayContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1782);
match(JSON_ARRAY);
setState(1783);
match(T__2);
setState(1800);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(1784);
jsonValueExpression();
setState(1789);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1785);
match(T__1);
setState(1786);
jsonValueExpression();
}
}
setState(1791);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1798);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NULL:
{
setState(1792);
match(NULL);
setState(1793);
match(ON);
setState(1794);
match(NULL);
}
break;
case T__0:
{
setState(1795);
match(T__0);
setState(1796);
match(ON);
setState(1797);
match(NULL);
}
break;
case T__3:
case RETURNING:
break;
default:
break;
}
}
break;
}
setState(1808);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(1802);
match(RETURNING);
setState(1803);
type(0);
setState(1806);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FORMAT) {
{
setState(1804);
match(FORMAT);
setState(1805);
jsonRepresentation();
}
}
}
}
setState(1810);
match(T__3);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1823);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1821);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
case 1:
{
_localctx = new SubscriptContext(new PrimaryExpressionContext(_parentctx, _parentState));
((SubscriptContext)_localctx).value = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(1813);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(1814);
match(T__7);
setState(1815);
((SubscriptContext)_localctx).index = valueExpression(0);
setState(1816);
match(T__8);
}
break;
case 2:
{
_localctx = new DereferenceContext(new PrimaryExpressionContext(_parentctx, _parentState));
((DereferenceContext)_localctx).base = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(1818);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(1819);
match(T__0);
setState(1820);
((DereferenceContext)_localctx).fieldName = identifier();
}
break;
}
}
}
setState(1825);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonPathInvocationContext extends ParserRuleContext {
public StringContext path;
public IdentifierContext pathName;
public JsonValueExpressionContext jsonValueExpression() {
return getRuleContext(JsonValueExpressionContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public TerminalNode PASSING() { return getToken(StructuresSqlParserParser.PASSING, 0); }
public List jsonArgument() {
return getRuleContexts(JsonArgumentContext.class);
}
public JsonArgumentContext jsonArgument(int i) {
return getRuleContext(JsonArgumentContext.class,i);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public JsonPathInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonPathInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonPathInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonPathInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonPathInvocation(this);
else return visitor.visitChildren(this);
}
}
public final JsonPathInvocationContext jsonPathInvocation() throws RecognitionException {
JsonPathInvocationContext _localctx = new JsonPathInvocationContext(_ctx, getState());
enterRule(_localctx, 136, RULE_jsonPathInvocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1826);
jsonValueExpression();
setState(1827);
match(T__1);
setState(1828);
((JsonPathInvocationContext)_localctx).path = string();
setState(1831);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(1829);
match(T__10);
setState(1830);
((JsonPathInvocationContext)_localctx).pathName = identifier();
}
}
setState(1842);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PASSING) {
{
setState(1833);
match(PASSING);
setState(1834);
jsonArgument();
setState(1839);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(1835);
match(T__1);
setState(1836);
jsonArgument();
}
}
setState(1841);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonValueExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode FORMAT() { return getToken(StructuresSqlParserParser.FORMAT, 0); }
public JsonRepresentationContext jsonRepresentation() {
return getRuleContext(JsonRepresentationContext.class,0);
}
public JsonValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonValueExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonValueExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonValueExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonValueExpression(this);
else return visitor.visitChildren(this);
}
}
public final JsonValueExpressionContext jsonValueExpression() throws RecognitionException {
JsonValueExpressionContext _localctx = new JsonValueExpressionContext(_ctx, getState());
enterRule(_localctx, 138, RULE_jsonValueExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1844);
expression();
setState(1847);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FORMAT) {
{
setState(1845);
match(FORMAT);
setState(1846);
jsonRepresentation();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonRepresentationContext extends ParserRuleContext {
public TerminalNode JSON() { return getToken(StructuresSqlParserParser.JSON, 0); }
public TerminalNode ENCODING() { return getToken(StructuresSqlParserParser.ENCODING, 0); }
public TerminalNode UTF8() { return getToken(StructuresSqlParserParser.UTF8, 0); }
public TerminalNode UTF16() { return getToken(StructuresSqlParserParser.UTF16, 0); }
public TerminalNode UTF32() { return getToken(StructuresSqlParserParser.UTF32, 0); }
public JsonRepresentationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonRepresentation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonRepresentation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonRepresentation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonRepresentation(this);
else return visitor.visitChildren(this);
}
}
public final JsonRepresentationContext jsonRepresentation() throws RecognitionException {
JsonRepresentationContext _localctx = new JsonRepresentationContext(_ctx, getState());
enterRule(_localctx, 140, RULE_jsonRepresentation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1849);
match(JSON);
setState(1852);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ENCODING) {
{
setState(1850);
match(ENCODING);
setState(1851);
_la = _input.LA(1);
if ( !(((((_la - 274)) & ~0x3f) == 0 && ((1L << (_la - 274)) & 7L) != 0)) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonArgumentContext extends ParserRuleContext {
public JsonValueExpressionContext jsonValueExpression() {
return getRuleContext(JsonValueExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(StructuresSqlParserParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public JsonArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonArgument(this);
else return visitor.visitChildren(this);
}
}
public final JsonArgumentContext jsonArgument() throws RecognitionException {
JsonArgumentContext _localctx = new JsonArgumentContext(_ctx, getState());
enterRule(_localctx, 142, RULE_jsonArgument);
try {
enterOuterAlt(_localctx, 1);
{
setState(1854);
jsonValueExpression();
setState(1855);
match(T__10);
setState(1856);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonExistsErrorBehaviorContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(StructuresSqlParserParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(StructuresSqlParserParser.FALSE, 0); }
public TerminalNode UNKNOWN() { return getToken(StructuresSqlParserParser.UNKNOWN, 0); }
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public JsonExistsErrorBehaviorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonExistsErrorBehavior; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonExistsErrorBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonExistsErrorBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonExistsErrorBehavior(this);
else return visitor.visitChildren(this);
}
}
public final JsonExistsErrorBehaviorContext jsonExistsErrorBehavior() throws RecognitionException {
JsonExistsErrorBehaviorContext _localctx = new JsonExistsErrorBehaviorContext(_ctx, getState());
enterRule(_localctx, 144, RULE_jsonExistsErrorBehavior);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1858);
_la = _input.LA(1);
if ( !(_la==ERROR || _la==FALSE || _la==TRUE || _la==UNKNOWN) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonValueBehaviorContext extends ParserRuleContext {
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public TerminalNode DEFAULT() { return getToken(StructuresSqlParserParser.DEFAULT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public JsonValueBehaviorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonValueBehavior; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonValueBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonValueBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonValueBehavior(this);
else return visitor.visitChildren(this);
}
}
public final JsonValueBehaviorContext jsonValueBehavior() throws RecognitionException {
JsonValueBehaviorContext _localctx = new JsonValueBehaviorContext(_ctx, getState());
enterRule(_localctx, 146, RULE_jsonValueBehavior);
try {
setState(1864);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ERROR:
enterOuterAlt(_localctx, 1);
{
setState(1860);
match(ERROR);
}
break;
case NULL:
enterOuterAlt(_localctx, 2);
{
setState(1861);
match(NULL);
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 3);
{
setState(1862);
match(DEFAULT);
setState(1863);
expression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonQueryWrapperBehaviorContext extends ParserRuleContext {
public TerminalNode WITHOUT() { return getToken(StructuresSqlParserParser.WITHOUT, 0); }
public TerminalNode ARRAY() { return getToken(StructuresSqlParserParser.ARRAY, 0); }
public TerminalNode WITH() { return getToken(StructuresSqlParserParser.WITH, 0); }
public TerminalNode CONDITIONAL() { return getToken(StructuresSqlParserParser.CONDITIONAL, 0); }
public TerminalNode UNCONDITIONAL() { return getToken(StructuresSqlParserParser.UNCONDITIONAL, 0); }
public JsonQueryWrapperBehaviorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonQueryWrapperBehavior; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonQueryWrapperBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonQueryWrapperBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonQueryWrapperBehavior(this);
else return visitor.visitChildren(this);
}
}
public final JsonQueryWrapperBehaviorContext jsonQueryWrapperBehavior() throws RecognitionException {
JsonQueryWrapperBehaviorContext _localctx = new JsonQueryWrapperBehaviorContext(_ctx, getState());
enterRule(_localctx, 148, RULE_jsonQueryWrapperBehavior);
int _la;
try {
setState(1877);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WITHOUT:
enterOuterAlt(_localctx, 1);
{
setState(1866);
match(WITHOUT);
setState(1868);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(1867);
match(T__9);
}
}
}
break;
case WITH:
enterOuterAlt(_localctx, 2);
{
setState(1870);
match(WITH);
setState(1872);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONDITIONAL || _la==UNCONDITIONAL) {
{
setState(1871);
_la = _input.LA(1);
if ( !(_la==CONDITIONAL || _la==UNCONDITIONAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(1875);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(1874);
match(T__9);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonQueryBehaviorContext extends ParserRuleContext {
public TerminalNode ERROR() { return getToken(StructuresSqlParserParser.ERROR, 0); }
public TerminalNode NULL() { return getToken(StructuresSqlParserParser.NULL, 0); }
public TerminalNode EMPTY() { return getToken(StructuresSqlParserParser.EMPTY, 0); }
public TerminalNode ARRAY() { return getToken(StructuresSqlParserParser.ARRAY, 0); }
public TerminalNode OBJECT() { return getToken(StructuresSqlParserParser.OBJECT, 0); }
public JsonQueryBehaviorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonQueryBehavior; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonQueryBehavior(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonQueryBehavior(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonQueryBehavior(this);
else return visitor.visitChildren(this);
}
}
public final JsonQueryBehaviorContext jsonQueryBehavior() throws RecognitionException {
JsonQueryBehaviorContext _localctx = new JsonQueryBehaviorContext(_ctx, getState());
enterRule(_localctx, 150, RULE_jsonQueryBehavior);
try {
setState(1885);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1879);
match(ERROR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1880);
match(NULL);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1881);
match(EMPTY);
setState(1882);
match(T__9);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1883);
match(EMPTY);
setState(1884);
match(OBJECT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonObjectMemberContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode VALUE() { return getToken(StructuresSqlParserParser.VALUE, 0); }
public JsonValueExpressionContext jsonValueExpression() {
return getRuleContext(JsonValueExpressionContext.class,0);
}
public TerminalNode KEY() { return getToken(StructuresSqlParserParser.KEY, 0); }
public JsonObjectMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jsonObjectMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterJsonObjectMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitJsonObjectMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitJsonObjectMember(this);
else return visitor.visitChildren(this);
}
}
public final JsonObjectMemberContext jsonObjectMember() throws RecognitionException {
JsonObjectMemberContext _localctx = new JsonObjectMemberContext(_ctx, getState());
enterRule(_localctx, 152, RULE_jsonObjectMember);
try {
setState(1898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,246,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1888);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,245,_ctx) ) {
case 1:
{
setState(1887);
match(KEY);
}
break;
}
setState(1890);
expression();
setState(1891);
match(VALUE);
setState(1892);
jsonValueExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1894);
expression();
setState(1895);
match(T__9);
setState(1896);
jsonValueExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ProcessingModeContext extends ParserRuleContext {
public TerminalNode RUNNING() { return getToken(StructuresSqlParserParser.RUNNING, 0); }
public TerminalNode FINAL() { return getToken(StructuresSqlParserParser.FINAL, 0); }
public ProcessingModeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_processingMode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterProcessingMode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitProcessingMode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitProcessingMode(this);
else return visitor.visitChildren(this);
}
}
public final ProcessingModeContext processingMode() throws RecognitionException {
ProcessingModeContext _localctx = new ProcessingModeContext(_ctx, getState());
enterRule(_localctx, 154, RULE_processingMode);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1900);
_la = _input.LA(1);
if ( !(_la==FINAL || _la==RUNNING) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class NullTreatmentContext extends ParserRuleContext {
public TerminalNode IGNORE() { return getToken(StructuresSqlParserParser.IGNORE, 0); }
public TerminalNode NULLS() { return getToken(StructuresSqlParserParser.NULLS, 0); }
public TerminalNode RESPECT() { return getToken(StructuresSqlParserParser.RESPECT, 0); }
public NullTreatmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nullTreatment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterNullTreatment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitNullTreatment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitNullTreatment(this);
else return visitor.visitChildren(this);
}
}
public final NullTreatmentContext nullTreatment() throws RecognitionException {
NullTreatmentContext _localctx = new NullTreatmentContext(_ctx, getState());
enterRule(_localctx, 156, RULE_nullTreatment);
try {
setState(1906);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IGNORE:
enterOuterAlt(_localctx, 1);
{
setState(1902);
match(IGNORE);
setState(1903);
match(NULLS);
}
break;
case RESPECT:
enterOuterAlt(_localctx, 2);
{
setState(1904);
match(RESPECT);
setState(1905);
match(NULLS);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends ParserRuleContext {
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
public StringContext() { }
public void copyFrom(StringContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnicodeStringLiteralContext extends StringContext {
public TerminalNode UNICODE_STRING() { return getToken(StructuresSqlParserParser.UNICODE_STRING, 0); }
public TerminalNode UESCAPE() { return getToken(StructuresSqlParserParser.UESCAPE, 0); }
public TerminalNode STRING() { return getToken(StructuresSqlParserParser.STRING, 0); }
public UnicodeStringLiteralContext(StringContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterUnicodeStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitUnicodeStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof StructuresSqlParserVisitor ) return ((StructuresSqlParserVisitor)visitor).visitUnicodeStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BasicStringLiteralContext extends StringContext {
public TerminalNode STRING() { return getToken(StructuresSqlParserParser.STRING, 0); }
public BasicStringLiteralContext(StringContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).enterBasicStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof StructuresSqlParserListener ) ((StructuresSqlParserListener)listener).exitBasicStringLiteral(this);
}
@Override
public