org.apache.spark.sql.catalyst.parser.extensions.IcebergSqlExtensionsParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of iceberg-spark-extensions-3.5_2.13 Show documentation
Show all versions of iceberg-spark-extensions-3.5_2.13 Show documentation
A table format for huge analytic datasets
The newest version!
// Generated from org.apache.spark.sql.catalyst.parser.extensions/IcebergSqlExtensions.g4 by ANTLR 4.9.3
package org.apache.spark.sql.catalyst.parser.extensions;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class IcebergSqlExtensionsParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, ADD=6, ALTER=7, AS=8, ASC=9, BRANCH=10,
BY=11, CALL=12, DAYS=13, DESC=14, DISTRIBUTED=15, DROP=16, EXISTS=17,
FIELD=18, FIELDS=19, FIRST=20, HOURS=21, IF=22, LAST=23, LOCALLY=24, MINUTES=25,
MONTHS=26, CREATE=27, NOT=28, NULLS=29, OF=30, OR=31, ORDERED=32, PARTITION=33,
REPLACE=34, RETAIN=35, RETENTION=36, IDENTIFIER_KW=37, SET=38, SNAPSHOT=39,
SNAPSHOTS=40, TABLE=41, TAG=42, UNORDERED=43, VERSION=44, WITH=45, WRITE=46,
TRUE=47, FALSE=48, MAP=49, ARRAY=50, PLUS=51, MINUS=52, STRING=53, BIGINT_LITERAL=54,
SMALLINT_LITERAL=55, TINYINT_LITERAL=56, INTEGER_VALUE=57, EXPONENT_VALUE=58,
DECIMAL_VALUE=59, FLOAT_LITERAL=60, DOUBLE_LITERAL=61, BIGDECIMAL_LITERAL=62,
IDENTIFIER=63, BACKQUOTED_IDENTIFIER=64, SIMPLE_COMMENT=65, BRACKETED_COMMENT=66,
WS=67, UNRECOGNIZED=68;
public static final int
RULE_singleStatement = 0, RULE_statement = 1, RULE_createReplaceTagClause = 2,
RULE_createReplaceBranchClause = 3, RULE_tagOptions = 4, RULE_branchOptions = 5,
RULE_snapshotRetention = 6, RULE_refRetain = 7, RULE_maxSnapshotAge = 8,
RULE_minSnapshotsToKeep = 9, RULE_writeSpec = 10, RULE_writeDistributionSpec = 11,
RULE_writeOrderingSpec = 12, RULE_callArgument = 13, RULE_singleOrder = 14,
RULE_order = 15, RULE_orderField = 16, RULE_transform = 17, RULE_transformArgument = 18,
RULE_expression = 19, RULE_constant = 20, RULE_stringMap = 21, RULE_stringArray = 22,
RULE_booleanValue = 23, RULE_number = 24, RULE_multipartIdentifier = 25,
RULE_identifier = 26, RULE_quotedIdentifier = 27, RULE_fieldList = 28,
RULE_nonReserved = 29, RULE_snapshotId = 30, RULE_numSnapshots = 31, RULE_timeUnit = 32;
private static String[] makeRuleNames() {
return new String[] {
"singleStatement", "statement", "createReplaceTagClause", "createReplaceBranchClause",
"tagOptions", "branchOptions", "snapshotRetention", "refRetain", "maxSnapshotAge",
"minSnapshotsToKeep", "writeSpec", "writeDistributionSpec", "writeOrderingSpec",
"callArgument", "singleOrder", "order", "orderField", "transform", "transformArgument",
"expression", "constant", "stringMap", "stringArray", "booleanValue",
"number", "multipartIdentifier", "identifier", "quotedIdentifier", "fieldList",
"nonReserved", "snapshotId", "numSnapshots", "timeUnit"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'('", "','", "')'", "'=>'", "'.'", "'ADD'", "'ALTER'", "'AS'",
"'ASC'", "'BRANCH'", "'BY'", "'CALL'", "'DAYS'", "'DESC'", "'DISTRIBUTED'",
"'DROP'", "'EXISTS'", "'FIELD'", "'FIELDS'", "'FIRST'", "'HOURS'", "'IF'",
"'LAST'", "'LOCALLY'", "'MINUTES'", "'MONTHS'", "'CREATE'", "'NOT'",
"'NULLS'", "'OF'", "'OR'", "'ORDERED'", "'PARTITION'", "'REPLACE'", "'RETAIN'",
"'RETENTION'", "'IDENTIFIER'", "'SET'", "'SNAPSHOT'", "'SNAPSHOTS'",
"'TABLE'", "'TAG'", "'UNORDERED'", "'VERSION'", "'WITH'", "'WRITE'",
"'TRUE'", "'FALSE'", "'MAP'", "'ARRAY'", "'+'", "'-'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, "ADD", "ALTER", "AS", "ASC", "BRANCH",
"BY", "CALL", "DAYS", "DESC", "DISTRIBUTED", "DROP", "EXISTS", "FIELD",
"FIELDS", "FIRST", "HOURS", "IF", "LAST", "LOCALLY", "MINUTES", "MONTHS",
"CREATE", "NOT", "NULLS", "OF", "OR", "ORDERED", "PARTITION", "REPLACE",
"RETAIN", "RETENTION", "IDENTIFIER_KW", "SET", "SNAPSHOT", "SNAPSHOTS",
"TABLE", "TAG", "UNORDERED", "VERSION", "WITH", "WRITE", "TRUE", "FALSE",
"MAP", "ARRAY", "PLUS", "MINUS", "STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL",
"TINYINT_LITERAL", "INTEGER_VALUE", "EXPONENT_VALUE", "DECIMAL_VALUE",
"FLOAT_LITERAL", "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", "IDENTIFIER",
"BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS",
"UNRECOGNIZED"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "IcebergSqlExtensions.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public IcebergSqlExtensionsParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class SingleStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode EOF() { return getToken(IcebergSqlExtensionsParser.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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)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(66);
statement();
setState(67);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class CallContext extends StatementContext {
public TerminalNode CALL() { return getToken(IcebergSqlExtensionsParser.CALL, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List callArgument() {
return getRuleContexts(CallArgumentContext.class);
}
public CallArgumentContext callArgument(int i) {
return getRuleContext(CallArgumentContext.class,i);
}
public CallContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCall(this);
else return visitor.visitChildren(this);
}
}
public static class SetIdentifierFieldsContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode SET() { return getToken(IcebergSqlExtensionsParser.SET, 0); }
public TerminalNode IDENTIFIER_KW() { return getToken(IcebergSqlExtensionsParser.IDENTIFIER_KW, 0); }
public TerminalNode FIELDS() { return getToken(IcebergSqlExtensionsParser.FIELDS, 0); }
public FieldListContext fieldList() {
return getRuleContext(FieldListContext.class,0);
}
public SetIdentifierFieldsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSetIdentifierFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSetIdentifierFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSetIdentifierFields(this);
else return visitor.visitChildren(this);
}
}
public static class ReplacePartitionFieldContext extends StatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode REPLACE() { return getToken(IcebergSqlExtensionsParser.REPLACE, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public List transform() {
return getRuleContexts(TransformContext.class);
}
public TransformContext transform(int i) {
return getRuleContext(TransformContext.class,i);
}
public TerminalNode WITH() { return getToken(IcebergSqlExtensionsParser.WITH, 0); }
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ReplacePartitionFieldContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterReplacePartitionField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitReplacePartitionField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitReplacePartitionField(this);
else return visitor.visitChildren(this);
}
}
public static class CreateOrReplaceTagContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public CreateReplaceTagClauseContext createReplaceTagClause() {
return getRuleContext(CreateReplaceTagClauseContext.class,0);
}
public CreateOrReplaceTagContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCreateOrReplaceTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCreateOrReplaceTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCreateOrReplaceTag(this);
else return visitor.visitChildren(this);
}
}
public static class DropBranchContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode BRANCH() { return getToken(IcebergSqlExtensionsParser.BRANCH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(IcebergSqlExtensionsParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(IcebergSqlExtensionsParser.EXISTS, 0); }
public DropBranchContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDropBranch(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDropBranch(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDropBranch(this);
else return visitor.visitChildren(this);
}
}
public static class DropTagContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode TAG() { return getToken(IcebergSqlExtensionsParser.TAG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IF() { return getToken(IcebergSqlExtensionsParser.IF, 0); }
public TerminalNode EXISTS() { return getToken(IcebergSqlExtensionsParser.EXISTS, 0); }
public DropTagContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDropTag(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDropTag(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDropTag(this);
else return visitor.visitChildren(this);
}
}
public static class DropIdentifierFieldsContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode IDENTIFIER_KW() { return getToken(IcebergSqlExtensionsParser.IDENTIFIER_KW, 0); }
public TerminalNode FIELDS() { return getToken(IcebergSqlExtensionsParser.FIELDS, 0); }
public FieldListContext fieldList() {
return getRuleContext(FieldListContext.class,0);
}
public DropIdentifierFieldsContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDropIdentifierFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDropIdentifierFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDropIdentifierFields(this);
else return visitor.visitChildren(this);
}
}
public static class CreateOrReplaceBranchContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public CreateReplaceBranchClauseContext createReplaceBranchClause() {
return getRuleContext(CreateReplaceBranchClauseContext.class,0);
}
public CreateOrReplaceBranchContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCreateOrReplaceBranch(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCreateOrReplaceBranch(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCreateOrReplaceBranch(this);
else return visitor.visitChildren(this);
}
}
public static class AddPartitionFieldContext extends StatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(IcebergSqlExtensionsParser.ADD, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AddPartitionFieldContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterAddPartitionField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitAddPartitionField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitAddPartitionField(this);
else return visitor.visitChildren(this);
}
}
public static class DropPartitionFieldContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public DropPartitionFieldContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDropPartitionField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDropPartitionField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDropPartitionField(this);
else return visitor.visitChildren(this);
}
}
public static class SetWriteDistributionAndOrderingContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode WRITE() { return getToken(IcebergSqlExtensionsParser.WRITE, 0); }
public WriteSpecContext writeSpec() {
return getRuleContext(WriteSpecContext.class,0);
}
public SetWriteDistributionAndOrderingContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSetWriteDistributionAndOrdering(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSetWriteDistributionAndOrdering(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSetWriteDistributionAndOrdering(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 2, RULE_statement);
int _la;
try {
setState(170);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
_localctx = new CallContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(69);
match(CALL);
setState(70);
multipartIdentifier();
setState(71);
match(T__0);
setState(80);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (ADD - 6)) | (1L << (ALTER - 6)) | (1L << (AS - 6)) | (1L << (ASC - 6)) | (1L << (BRANCH - 6)) | (1L << (BY - 6)) | (1L << (CALL - 6)) | (1L << (DAYS - 6)) | (1L << (DESC - 6)) | (1L << (DISTRIBUTED - 6)) | (1L << (DROP - 6)) | (1L << (EXISTS - 6)) | (1L << (FIELD - 6)) | (1L << (FIELDS - 6)) | (1L << (FIRST - 6)) | (1L << (HOURS - 6)) | (1L << (IF - 6)) | (1L << (LAST - 6)) | (1L << (LOCALLY - 6)) | (1L << (MINUTES - 6)) | (1L << (MONTHS - 6)) | (1L << (CREATE - 6)) | (1L << (NOT - 6)) | (1L << (NULLS - 6)) | (1L << (OF - 6)) | (1L << (OR - 6)) | (1L << (ORDERED - 6)) | (1L << (PARTITION - 6)) | (1L << (REPLACE - 6)) | (1L << (RETAIN - 6)) | (1L << (IDENTIFIER_KW - 6)) | (1L << (SET - 6)) | (1L << (SNAPSHOT - 6)) | (1L << (SNAPSHOTS - 6)) | (1L << (TABLE - 6)) | (1L << (TAG - 6)) | (1L << (UNORDERED - 6)) | (1L << (VERSION - 6)) | (1L << (WITH - 6)) | (1L << (WRITE - 6)) | (1L << (TRUE - 6)) | (1L << (FALSE - 6)) | (1L << (MAP - 6)) | (1L << (ARRAY - 6)) | (1L << (MINUS - 6)) | (1L << (STRING - 6)) | (1L << (BIGINT_LITERAL - 6)) | (1L << (SMALLINT_LITERAL - 6)) | (1L << (TINYINT_LITERAL - 6)) | (1L << (INTEGER_VALUE - 6)) | (1L << (EXPONENT_VALUE - 6)) | (1L << (DECIMAL_VALUE - 6)) | (1L << (FLOAT_LITERAL - 6)) | (1L << (DOUBLE_LITERAL - 6)) | (1L << (BIGDECIMAL_LITERAL - 6)) | (1L << (IDENTIFIER - 6)) | (1L << (BACKQUOTED_IDENTIFIER - 6)))) != 0)) {
{
setState(72);
callArgument();
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(73);
match(T__1);
setState(74);
callArgument();
}
}
setState(79);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(82);
match(T__2);
}
break;
case 2:
_localctx = new AddPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(84);
match(ALTER);
setState(85);
match(TABLE);
setState(86);
multipartIdentifier();
setState(87);
match(ADD);
setState(88);
match(PARTITION);
setState(89);
match(FIELD);
setState(90);
transform();
setState(93);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(91);
match(AS);
setState(92);
((AddPartitionFieldContext)_localctx).name = identifier();
}
}
}
break;
case 3:
_localctx = new DropPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(95);
match(ALTER);
setState(96);
match(TABLE);
setState(97);
multipartIdentifier();
setState(98);
match(DROP);
setState(99);
match(PARTITION);
setState(100);
match(FIELD);
setState(101);
transform();
}
break;
case 4:
_localctx = new ReplacePartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(103);
match(ALTER);
setState(104);
match(TABLE);
setState(105);
multipartIdentifier();
setState(106);
match(REPLACE);
setState(107);
match(PARTITION);
setState(108);
match(FIELD);
setState(109);
transform();
setState(110);
match(WITH);
setState(111);
transform();
setState(114);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(112);
match(AS);
setState(113);
((ReplacePartitionFieldContext)_localctx).name = identifier();
}
}
}
break;
case 5:
_localctx = new SetWriteDistributionAndOrderingContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(116);
match(ALTER);
setState(117);
match(TABLE);
setState(118);
multipartIdentifier();
setState(119);
match(WRITE);
setState(120);
writeSpec();
}
break;
case 6:
_localctx = new SetIdentifierFieldsContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(122);
match(ALTER);
setState(123);
match(TABLE);
setState(124);
multipartIdentifier();
setState(125);
match(SET);
setState(126);
match(IDENTIFIER_KW);
setState(127);
match(FIELDS);
setState(128);
fieldList();
}
break;
case 7:
_localctx = new DropIdentifierFieldsContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(130);
match(ALTER);
setState(131);
match(TABLE);
setState(132);
multipartIdentifier();
setState(133);
match(DROP);
setState(134);
match(IDENTIFIER_KW);
setState(135);
match(FIELDS);
setState(136);
fieldList();
}
break;
case 8:
_localctx = new CreateOrReplaceBranchContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(138);
match(ALTER);
setState(139);
match(TABLE);
setState(140);
multipartIdentifier();
setState(141);
createReplaceBranchClause();
}
break;
case 9:
_localctx = new CreateOrReplaceTagContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(143);
match(ALTER);
setState(144);
match(TABLE);
setState(145);
multipartIdentifier();
setState(146);
createReplaceTagClause();
}
break;
case 10:
_localctx = new DropBranchContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(148);
match(ALTER);
setState(149);
match(TABLE);
setState(150);
multipartIdentifier();
setState(151);
match(DROP);
setState(152);
match(BRANCH);
setState(155);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(153);
match(IF);
setState(154);
match(EXISTS);
}
break;
}
setState(157);
identifier();
}
break;
case 11:
_localctx = new DropTagContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(159);
match(ALTER);
setState(160);
match(TABLE);
setState(161);
multipartIdentifier();
setState(162);
match(DROP);
setState(163);
match(TAG);
setState(166);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(164);
match(IF);
setState(165);
match(EXISTS);
}
break;
}
setState(168);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateReplaceTagClauseContext extends ParserRuleContext {
public TerminalNode REPLACE() { return getToken(IcebergSqlExtensionsParser.REPLACE, 0); }
public TerminalNode TAG() { return getToken(IcebergSqlExtensionsParser.TAG, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TagOptionsContext tagOptions() {
return getRuleContext(TagOptionsContext.class,0);
}
public TerminalNode CREATE() { return getToken(IcebergSqlExtensionsParser.CREATE, 0); }
public TerminalNode OR() { return getToken(IcebergSqlExtensionsParser.OR, 0); }
public TerminalNode IF() { return getToken(IcebergSqlExtensionsParser.IF, 0); }
public TerminalNode NOT() { return getToken(IcebergSqlExtensionsParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(IcebergSqlExtensionsParser.EXISTS, 0); }
public CreateReplaceTagClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createReplaceTagClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCreateReplaceTagClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCreateReplaceTagClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCreateReplaceTagClause(this);
else return visitor.visitChildren(this);
}
}
public final CreateReplaceTagClauseContext createReplaceTagClause() throws RecognitionException {
CreateReplaceTagClauseContext _localctx = new CreateReplaceTagClauseContext(_ctx, getState());
enterRule(_localctx, 4, RULE_createReplaceTagClause);
int _la;
try {
setState(191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(174);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(172);
match(CREATE);
setState(173);
match(OR);
}
}
setState(176);
match(REPLACE);
setState(177);
match(TAG);
setState(178);
identifier();
setState(179);
tagOptions();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(181);
match(CREATE);
setState(182);
match(TAG);
setState(186);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(183);
match(IF);
setState(184);
match(NOT);
setState(185);
match(EXISTS);
}
break;
}
setState(188);
identifier();
setState(189);
tagOptions();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CreateReplaceBranchClauseContext extends ParserRuleContext {
public TerminalNode REPLACE() { return getToken(IcebergSqlExtensionsParser.REPLACE, 0); }
public TerminalNode BRANCH() { return getToken(IcebergSqlExtensionsParser.BRANCH, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public BranchOptionsContext branchOptions() {
return getRuleContext(BranchOptionsContext.class,0);
}
public TerminalNode CREATE() { return getToken(IcebergSqlExtensionsParser.CREATE, 0); }
public TerminalNode OR() { return getToken(IcebergSqlExtensionsParser.OR, 0); }
public TerminalNode IF() { return getToken(IcebergSqlExtensionsParser.IF, 0); }
public TerminalNode NOT() { return getToken(IcebergSqlExtensionsParser.NOT, 0); }
public TerminalNode EXISTS() { return getToken(IcebergSqlExtensionsParser.EXISTS, 0); }
public CreateReplaceBranchClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createReplaceBranchClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCreateReplaceBranchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCreateReplaceBranchClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCreateReplaceBranchClause(this);
else return visitor.visitChildren(this);
}
}
public final CreateReplaceBranchClauseContext createReplaceBranchClause() throws RecognitionException {
CreateReplaceBranchClauseContext _localctx = new CreateReplaceBranchClauseContext(_ctx, getState());
enterRule(_localctx, 6, RULE_createReplaceBranchClause);
int _la;
try {
setState(212);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(195);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CREATE) {
{
setState(193);
match(CREATE);
setState(194);
match(OR);
}
}
setState(197);
match(REPLACE);
setState(198);
match(BRANCH);
setState(199);
identifier();
setState(200);
branchOptions();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(202);
match(CREATE);
setState(203);
match(BRANCH);
setState(207);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(204);
match(IF);
setState(205);
match(NOT);
setState(206);
match(EXISTS);
}
break;
}
setState(209);
identifier();
setState(210);
branchOptions();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TagOptionsContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public TerminalNode OF() { return getToken(IcebergSqlExtensionsParser.OF, 0); }
public TerminalNode VERSION() { return getToken(IcebergSqlExtensionsParser.VERSION, 0); }
public SnapshotIdContext snapshotId() {
return getRuleContext(SnapshotIdContext.class,0);
}
public RefRetainContext refRetain() {
return getRuleContext(RefRetainContext.class,0);
}
public TagOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tagOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTagOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTagOptions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTagOptions(this);
else return visitor.visitChildren(this);
}
}
public final TagOptionsContext tagOptions() throws RecognitionException {
TagOptionsContext _localctx = new TagOptionsContext(_ctx, getState());
enterRule(_localctx, 8, RULE_tagOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(214);
match(AS);
setState(215);
match(OF);
setState(216);
match(VERSION);
setState(217);
snapshotId();
}
}
setState(221);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETAIN) {
{
setState(220);
refRetain();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BranchOptionsContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public TerminalNode OF() { return getToken(IcebergSqlExtensionsParser.OF, 0); }
public TerminalNode VERSION() { return getToken(IcebergSqlExtensionsParser.VERSION, 0); }
public SnapshotIdContext snapshotId() {
return getRuleContext(SnapshotIdContext.class,0);
}
public RefRetainContext refRetain() {
return getRuleContext(RefRetainContext.class,0);
}
public SnapshotRetentionContext snapshotRetention() {
return getRuleContext(SnapshotRetentionContext.class,0);
}
public BranchOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_branchOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBranchOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBranchOptions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBranchOptions(this);
else return visitor.visitChildren(this);
}
}
public final BranchOptionsContext branchOptions() throws RecognitionException {
BranchOptionsContext _localctx = new BranchOptionsContext(_ctx, getState());
enterRule(_localctx, 10, RULE_branchOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(223);
match(AS);
setState(224);
match(OF);
setState(225);
match(VERSION);
setState(226);
snapshotId();
}
}
setState(230);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETAIN) {
{
setState(229);
refRetain();
}
}
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(232);
snapshotRetention();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnapshotRetentionContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(IcebergSqlExtensionsParser.WITH, 0); }
public TerminalNode SNAPSHOT() { return getToken(IcebergSqlExtensionsParser.SNAPSHOT, 0); }
public TerminalNode RETENTION() { return getToken(IcebergSqlExtensionsParser.RETENTION, 0); }
public MinSnapshotsToKeepContext minSnapshotsToKeep() {
return getRuleContext(MinSnapshotsToKeepContext.class,0);
}
public MaxSnapshotAgeContext maxSnapshotAge() {
return getRuleContext(MaxSnapshotAgeContext.class,0);
}
public SnapshotRetentionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snapshotRetention; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSnapshotRetention(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSnapshotRetention(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSnapshotRetention(this);
else return visitor.visitChildren(this);
}
}
public final SnapshotRetentionContext snapshotRetention() throws RecognitionException {
SnapshotRetentionContext _localctx = new SnapshotRetentionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_snapshotRetention);
try {
setState(249);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(235);
match(WITH);
setState(236);
match(SNAPSHOT);
setState(237);
match(RETENTION);
setState(238);
minSnapshotsToKeep();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(239);
match(WITH);
setState(240);
match(SNAPSHOT);
setState(241);
match(RETENTION);
setState(242);
maxSnapshotAge();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(243);
match(WITH);
setState(244);
match(SNAPSHOT);
setState(245);
match(RETENTION);
setState(246);
minSnapshotsToKeep();
setState(247);
maxSnapshotAge();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RefRetainContext extends ParserRuleContext {
public TerminalNode RETAIN() { return getToken(IcebergSqlExtensionsParser.RETAIN, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TimeUnitContext timeUnit() {
return getRuleContext(TimeUnitContext.class,0);
}
public RefRetainContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_refRetain; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterRefRetain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitRefRetain(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitRefRetain(this);
else return visitor.visitChildren(this);
}
}
public final RefRetainContext refRetain() throws RecognitionException {
RefRetainContext _localctx = new RefRetainContext(_ctx, getState());
enterRule(_localctx, 14, RULE_refRetain);
try {
enterOuterAlt(_localctx, 1);
{
setState(251);
match(RETAIN);
setState(252);
number();
setState(253);
timeUnit();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MaxSnapshotAgeContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TimeUnitContext timeUnit() {
return getRuleContext(TimeUnitContext.class,0);
}
public MaxSnapshotAgeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maxSnapshotAge; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterMaxSnapshotAge(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitMaxSnapshotAge(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitMaxSnapshotAge(this);
else return visitor.visitChildren(this);
}
}
public final MaxSnapshotAgeContext maxSnapshotAge() throws RecognitionException {
MaxSnapshotAgeContext _localctx = new MaxSnapshotAgeContext(_ctx, getState());
enterRule(_localctx, 16, RULE_maxSnapshotAge);
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
number();
setState(256);
timeUnit();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MinSnapshotsToKeepContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public TerminalNode SNAPSHOTS() { return getToken(IcebergSqlExtensionsParser.SNAPSHOTS, 0); }
public MinSnapshotsToKeepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minSnapshotsToKeep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterMinSnapshotsToKeep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitMinSnapshotsToKeep(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitMinSnapshotsToKeep(this);
else return visitor.visitChildren(this);
}
}
public final MinSnapshotsToKeepContext minSnapshotsToKeep() throws RecognitionException {
MinSnapshotsToKeepContext _localctx = new MinSnapshotsToKeepContext(_ctx, getState());
enterRule(_localctx, 18, RULE_minSnapshotsToKeep);
try {
enterOuterAlt(_localctx, 1);
{
setState(258);
number();
setState(259);
match(SNAPSHOTS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteSpecContext extends ParserRuleContext {
public List writeDistributionSpec() {
return getRuleContexts(WriteDistributionSpecContext.class);
}
public WriteDistributionSpecContext writeDistributionSpec(int i) {
return getRuleContext(WriteDistributionSpecContext.class,i);
}
public List writeOrderingSpec() {
return getRuleContexts(WriteOrderingSpecContext.class);
}
public WriteOrderingSpecContext writeOrderingSpec(int i) {
return getRuleContext(WriteOrderingSpecContext.class,i);
}
public WriteSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterWriteSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitWriteSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitWriteSpec(this);
else return visitor.visitChildren(this);
}
}
public final WriteSpecContext writeSpec() throws RecognitionException {
WriteSpecContext _localctx = new WriteSpecContext(_ctx, getState());
enterRule(_localctx, 20, RULE_writeSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DISTRIBUTED) | (1L << LOCALLY) | (1L << ORDERED) | (1L << UNORDERED))) != 0)) {
{
setState(263);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DISTRIBUTED:
{
setState(261);
writeDistributionSpec();
}
break;
case LOCALLY:
case ORDERED:
case UNORDERED:
{
setState(262);
writeOrderingSpec();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(267);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteDistributionSpecContext extends ParserRuleContext {
public TerminalNode DISTRIBUTED() { return getToken(IcebergSqlExtensionsParser.DISTRIBUTED, 0); }
public TerminalNode BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public WriteDistributionSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeDistributionSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterWriteDistributionSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitWriteDistributionSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitWriteDistributionSpec(this);
else return visitor.visitChildren(this);
}
}
public final WriteDistributionSpecContext writeDistributionSpec() throws RecognitionException {
WriteDistributionSpecContext _localctx = new WriteDistributionSpecContext(_ctx, getState());
enterRule(_localctx, 22, RULE_writeDistributionSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(268);
match(DISTRIBUTED);
setState(269);
match(BY);
setState(270);
match(PARTITION);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WriteOrderingSpecContext extends ParserRuleContext {
public TerminalNode ORDERED() { return getToken(IcebergSqlExtensionsParser.ORDERED, 0); }
public TerminalNode BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public OrderContext order() {
return getRuleContext(OrderContext.class,0);
}
public TerminalNode LOCALLY() { return getToken(IcebergSqlExtensionsParser.LOCALLY, 0); }
public TerminalNode UNORDERED() { return getToken(IcebergSqlExtensionsParser.UNORDERED, 0); }
public WriteOrderingSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_writeOrderingSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterWriteOrderingSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitWriteOrderingSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitWriteOrderingSpec(this);
else return visitor.visitChildren(this);
}
}
public final WriteOrderingSpecContext writeOrderingSpec() throws RecognitionException {
WriteOrderingSpecContext _localctx = new WriteOrderingSpecContext(_ctx, getState());
enterRule(_localctx, 24, RULE_writeOrderingSpec);
int _la;
try {
setState(279);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LOCALLY:
case ORDERED:
enterOuterAlt(_localctx, 1);
{
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCALLY) {
{
setState(272);
match(LOCALLY);
}
}
setState(275);
match(ORDERED);
setState(276);
match(BY);
setState(277);
order();
}
break;
case UNORDERED:
enterOuterAlt(_localctx, 2);
{
setState(278);
match(UNORDERED);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CallArgumentContext extends ParserRuleContext {
public CallArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callArgument; }
public CallArgumentContext() { }
public void copyFrom(CallArgumentContext ctx) {
super.copyFrom(ctx);
}
}
public static class PositionalArgumentContext extends CallArgumentContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PositionalArgumentContext(CallArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterPositionalArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitPositionalArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitPositionalArgument(this);
else return visitor.visitChildren(this);
}
}
public static class NamedArgumentContext extends CallArgumentContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NamedArgumentContext(CallArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNamedArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNamedArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNamedArgument(this);
else return visitor.visitChildren(this);
}
}
public final CallArgumentContext callArgument() throws RecognitionException {
CallArgumentContext _localctx = new CallArgumentContext(_ctx, getState());
enterRule(_localctx, 26, RULE_callArgument);
try {
setState(286);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
_localctx = new PositionalArgumentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(281);
expression();
}
break;
case 2:
_localctx = new NamedArgumentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(282);
identifier();
setState(283);
match(T__3);
setState(284);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleOrderContext extends ParserRuleContext {
public OrderContext order() {
return getRuleContext(OrderContext.class,0);
}
public TerminalNode EOF() { return getToken(IcebergSqlExtensionsParser.EOF, 0); }
public SingleOrderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleOrder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSingleOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSingleOrder(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSingleOrder(this);
else return visitor.visitChildren(this);
}
}
public final SingleOrderContext singleOrder() throws RecognitionException {
SingleOrderContext _localctx = new SingleOrderContext(_ctx, getState());
enterRule(_localctx, 28, RULE_singleOrder);
try {
enterOuterAlt(_localctx, 1);
{
setState(288);
order();
setState(289);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderContext extends ParserRuleContext {
public OrderFieldContext orderField;
public List fields = new ArrayList();
public List orderField() {
return getRuleContexts(OrderFieldContext.class);
}
public OrderFieldContext orderField(int i) {
return getRuleContext(OrderFieldContext.class,i);
}
public OrderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitOrder(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitOrder(this);
else return visitor.visitChildren(this);
}
}
public final OrderContext order() throws RecognitionException {
OrderContext _localctx = new OrderContext(_ctx, getState());
enterRule(_localctx, 30, RULE_order);
int _la;
try {
setState(310);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case ALTER:
case AS:
case ASC:
case BRANCH:
case BY:
case CALL:
case DAYS:
case DESC:
case DISTRIBUTED:
case DROP:
case EXISTS:
case FIELD:
case FIELDS:
case FIRST:
case HOURS:
case IF:
case LAST:
case LOCALLY:
case MINUTES:
case MONTHS:
case CREATE:
case NOT:
case NULLS:
case OF:
case OR:
case ORDERED:
case PARTITION:
case REPLACE:
case RETAIN:
case IDENTIFIER_KW:
case SET:
case SNAPSHOT:
case SNAPSHOTS:
case TABLE:
case TAG:
case UNORDERED:
case VERSION:
case WITH:
case WRITE:
case TRUE:
case FALSE:
case MAP:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(291);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(296);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(292);
match(T__1);
setState(293);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(298);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(299);
match(T__0);
setState(300);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(301);
match(T__1);
setState(302);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(308);
match(T__2);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderFieldContext extends ParserRuleContext {
public Token direction;
public Token nullOrder;
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public TerminalNode NULLS() { return getToken(IcebergSqlExtensionsParser.NULLS, 0); }
public TerminalNode ASC() { return getToken(IcebergSqlExtensionsParser.ASC, 0); }
public TerminalNode DESC() { return getToken(IcebergSqlExtensionsParser.DESC, 0); }
public TerminalNode FIRST() { return getToken(IcebergSqlExtensionsParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(IcebergSqlExtensionsParser.LAST, 0); }
public OrderFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterOrderField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitOrderField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitOrderField(this);
else return visitor.visitChildren(this);
}
}
public final OrderFieldContext orderField() throws RecognitionException {
OrderFieldContext _localctx = new OrderFieldContext(_ctx, getState());
enterRule(_localctx, 32, RULE_orderField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(312);
transform();
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(313);
((OrderFieldContext)_localctx).direction = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
((OrderFieldContext)_localctx).direction = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(316);
match(NULLS);
setState(317);
((OrderFieldContext)_localctx).nullOrder = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
((OrderFieldContext)_localctx).nullOrder = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformContext extends ParserRuleContext {
public TransformContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transform; }
public TransformContext() { }
public void copyFrom(TransformContext ctx) {
super.copyFrom(ctx);
}
}
public static class IdentityTransformContext extends TransformContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentityTransformContext(TransformContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterIdentityTransform(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitIdentityTransform(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitIdentityTransform(this);
else return visitor.visitChildren(this);
}
}
public static class ApplyTransformContext extends TransformContext {
public IdentifierContext transformName;
public TransformArgumentContext transformArgument;
public List arguments = new ArrayList();
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List transformArgument() {
return getRuleContexts(TransformArgumentContext.class);
}
public TransformArgumentContext transformArgument(int i) {
return getRuleContext(TransformArgumentContext.class,i);
}
public ApplyTransformContext(TransformContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterApplyTransform(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitApplyTransform(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitApplyTransform(this);
else return visitor.visitChildren(this);
}
}
public final TransformContext transform() throws RecognitionException {
TransformContext _localctx = new TransformContext(_ctx, getState());
enterRule(_localctx, 34, RULE_transform);
int _la;
try {
setState(333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
_localctx = new IdentityTransformContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(320);
multipartIdentifier();
}
break;
case 2:
_localctx = new ApplyTransformContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(321);
((ApplyTransformContext)_localctx).transformName = identifier();
setState(322);
match(T__0);
setState(323);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(324);
match(T__1);
setState(325);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
}
}
setState(330);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(331);
match(T__2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformArgumentContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TransformArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transformArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTransformArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTransformArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTransformArgument(this);
else return visitor.visitChildren(this);
}
}
public final TransformArgumentContext transformArgument() throws RecognitionException {
TransformArgumentContext _localctx = new TransformArgumentContext(_ctx, getState());
enterRule(_localctx, 36, RULE_transformArgument);
try {
setState(337);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(335);
multipartIdentifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(336);
constant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public StringMapContext stringMap() {
return getRuleContext(StringMapContext.class,0);
}
public StringArrayContext stringArray() {
return getRuleContext(StringArrayContext.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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 38, RULE_expression);
try {
setState(342);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(339);
constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(340);
stringMap();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(341);
stringArray();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
public ConstantContext() { }
public void copyFrom(ConstantContext ctx) {
super.copyFrom(ctx);
}
}
public static class StringLiteralContext extends ConstantContext {
public List STRING() { return getTokens(IcebergSqlExtensionsParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(IcebergSqlExtensionsParser.STRING, i);
}
public StringLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class TypeConstructorContext extends ConstantContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING() { return getToken(IcebergSqlExtensionsParser.STRING, 0); }
public TypeConstructorContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTypeConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTypeConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTypeConstructor(this);
else return visitor.visitChildren(this);
}
}
public static class NumericLiteralContext extends ConstantContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BooleanLiteralContext extends ConstantContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 40, RULE_constant);
int _la;
try {
setState(354);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
_localctx = new NumericLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(344);
number();
}
break;
case 2:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(345);
booleanValue();
}
break;
case 3:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(346);
match(STRING);
}
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case 4:
_localctx = new TypeConstructorContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(351);
identifier();
setState(352);
match(STRING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringMapContext extends ParserRuleContext {
public TerminalNode MAP() { return getToken(IcebergSqlExtensionsParser.MAP, 0); }
public List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public StringMapContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringMap; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterStringMap(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitStringMap(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitStringMap(this);
else return visitor.visitChildren(this);
}
}
public final StringMapContext stringMap() throws RecognitionException {
StringMapContext _localctx = new StringMapContext(_ctx, getState());
enterRule(_localctx, 42, RULE_stringMap);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(356);
match(MAP);
setState(357);
match(T__0);
setState(358);
constant();
setState(363);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(359);
match(T__1);
setState(360);
constant();
}
}
setState(365);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(366);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringArrayContext extends ParserRuleContext {
public TerminalNode ARRAY() { return getToken(IcebergSqlExtensionsParser.ARRAY, 0); }
public List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public StringArrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringArray; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterStringArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitStringArray(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitStringArray(this);
else return visitor.visitChildren(this);
}
}
public final StringArrayContext stringArray() throws RecognitionException {
StringArrayContext _localctx = new StringArrayContext(_ctx, getState());
enterRule(_localctx, 44, RULE_stringArray);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(368);
match(ARRAY);
setState(369);
match(T__0);
setState(370);
constant();
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(371);
match(T__1);
setState(372);
constant();
}
}
setState(377);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(378);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BooleanValueContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(IcebergSqlExtensionsParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(IcebergSqlExtensionsParser.FALSE, 0); }
public BooleanValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 46, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(380);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
public NumberContext() { }
public void copyFrom(NumberContext ctx) {
super.copyFrom(ctx);
}
}
public static class DecimalLiteralContext extends NumberContext {
public TerminalNode DECIMAL_VALUE() { return getToken(IcebergSqlExtensionsParser.DECIMAL_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public DecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BigIntLiteralContext extends NumberContext {
public TerminalNode BIGINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.BIGINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public BigIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBigIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBigIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBigIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class TinyIntLiteralContext extends NumberContext {
public TerminalNode TINYINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.TINYINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public TinyIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTinyIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTinyIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTinyIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BigDecimalLiteralContext extends NumberContext {
public TerminalNode BIGDECIMAL_LITERAL() { return getToken(IcebergSqlExtensionsParser.BIGDECIMAL_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public BigDecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBigDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBigDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBigDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class ExponentLiteralContext extends NumberContext {
public TerminalNode EXPONENT_VALUE() { return getToken(IcebergSqlExtensionsParser.EXPONENT_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public ExponentLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterExponentLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitExponentLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitExponentLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class DoubleLiteralContext extends NumberContext {
public TerminalNode DOUBLE_LITERAL() { return getToken(IcebergSqlExtensionsParser.DOUBLE_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public DoubleLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDoubleLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDoubleLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDoubleLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class IntegerLiteralContext extends NumberContext {
public TerminalNode INTEGER_VALUE() { return getToken(IcebergSqlExtensionsParser.INTEGER_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public IntegerLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitIntegerLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class FloatLiteralContext extends NumberContext {
public TerminalNode FLOAT_LITERAL() { return getToken(IcebergSqlExtensionsParser.FLOAT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public FloatLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterFloatLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitFloatLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitFloatLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class SmallIntLiteralContext extends NumberContext {
public TerminalNode SMALLINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.SMALLINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public SmallIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSmallIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSmallIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSmallIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 48, RULE_number);
int _la;
try {
setState(418);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
_localctx = new ExponentLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(383);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(382);
match(MINUS);
}
}
setState(385);
match(EXPONENT_VALUE);
}
break;
case 2:
_localctx = new DecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(386);
match(MINUS);
}
}
setState(389);
match(DECIMAL_VALUE);
}
break;
case 3:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(390);
match(MINUS);
}
}
setState(393);
match(INTEGER_VALUE);
}
break;
case 4:
_localctx = new BigIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(394);
match(MINUS);
}
}
setState(397);
match(BIGINT_LITERAL);
}
break;
case 5:
_localctx = new SmallIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(399);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(398);
match(MINUS);
}
}
setState(401);
match(SMALLINT_LITERAL);
}
break;
case 6:
_localctx = new TinyIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(403);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(402);
match(MINUS);
}
}
setState(405);
match(TINYINT_LITERAL);
}
break;
case 7:
_localctx = new DoubleLiteralContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(406);
match(MINUS);
}
}
setState(409);
match(DOUBLE_LITERAL);
}
break;
case 8:
_localctx = new FloatLiteralContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(411);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(410);
match(MINUS);
}
}
setState(413);
match(FLOAT_LITERAL);
}
break;
case 9:
_localctx = new BigDecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(414);
match(MINUS);
}
}
setState(417);
match(BIGDECIMAL_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultipartIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier;
public List parts = new ArrayList();
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MultipartIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitMultipartIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitMultipartIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final MultipartIdentifierContext multipartIdentifier() throws RecognitionException {
MultipartIdentifierContext _localctx = new MultipartIdentifierContext(_ctx, getState());
enterRule(_localctx, 50, RULE_multipartIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(420);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
setState(425);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(421);
match(T__4);
setState(422);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
}
}
setState(427);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
public IdentifierContext() { }
public void copyFrom(IdentifierContext ctx) {
super.copyFrom(ctx);
}
}
public static class QuotedIdentifierAlternativeContext extends IdentifierContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public QuotedIdentifierAlternativeContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterQuotedIdentifierAlternative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitQuotedIdentifierAlternative(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitQuotedIdentifierAlternative(this);
else return visitor.visitChildren(this);
}
}
public static class UnquotedIdentifierContext extends IdentifierContext {
public TerminalNode IDENTIFIER() { return getToken(IcebergSqlExtensionsParser.IDENTIFIER, 0); }
public NonReservedContext nonReserved() {
return getRuleContext(NonReservedContext.class,0);
}
public UnquotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterUnquotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitUnquotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitUnquotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 52, RULE_identifier);
try {
setState(431);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(428);
match(IDENTIFIER);
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new QuotedIdentifierAlternativeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(429);
quotedIdentifier();
}
break;
case ADD:
case ALTER:
case AS:
case ASC:
case BRANCH:
case BY:
case CALL:
case DAYS:
case DESC:
case DISTRIBUTED:
case DROP:
case EXISTS:
case FIELD:
case FIELDS:
case FIRST:
case HOURS:
case IF:
case LAST:
case LOCALLY:
case MINUTES:
case MONTHS:
case CREATE:
case NOT:
case NULLS:
case OF:
case OR:
case ORDERED:
case PARTITION:
case REPLACE:
case RETAIN:
case IDENTIFIER_KW:
case SET:
case SNAPSHOT:
case SNAPSHOTS:
case TABLE:
case TAG:
case UNORDERED:
case VERSION:
case WITH:
case WRITE:
case TRUE:
case FALSE:
case MAP:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(430);
nonReserved();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuotedIdentifierContext extends ParserRuleContext {
public TerminalNode BACKQUOTED_IDENTIFIER() { return getToken(IcebergSqlExtensionsParser.BACKQUOTED_IDENTIFIER, 0); }
public QuotedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitQuotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final QuotedIdentifierContext quotedIdentifier() throws RecognitionException {
QuotedIdentifierContext _localctx = new QuotedIdentifierContext(_ctx, getState());
enterRule(_localctx, 54, RULE_quotedIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(433);
match(BACKQUOTED_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldListContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier;
public List fields = new ArrayList();
public List multipartIdentifier() {
return getRuleContexts(MultipartIdentifierContext.class);
}
public MultipartIdentifierContext multipartIdentifier(int i) {
return getRuleContext(MultipartIdentifierContext.class,i);
}
public FieldListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterFieldList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitFieldList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitFieldList(this);
else return visitor.visitChildren(this);
}
}
public final FieldListContext fieldList() throws RecognitionException {
FieldListContext _localctx = new FieldListContext(_ctx, getState());
enterRule(_localctx, 56, RULE_fieldList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(435);
((FieldListContext)_localctx).multipartIdentifier = multipartIdentifier();
((FieldListContext)_localctx).fields.add(((FieldListContext)_localctx).multipartIdentifier);
setState(440);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(436);
match(T__1);
setState(437);
((FieldListContext)_localctx).multipartIdentifier = multipartIdentifier();
((FieldListContext)_localctx).fields.add(((FieldListContext)_localctx).multipartIdentifier);
}
}
setState(442);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NonReservedContext extends ParserRuleContext {
public TerminalNode ADD() { return getToken(IcebergSqlExtensionsParser.ADD, 0); }
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public TerminalNode ASC() { return getToken(IcebergSqlExtensionsParser.ASC, 0); }
public TerminalNode BRANCH() { return getToken(IcebergSqlExtensionsParser.BRANCH, 0); }
public TerminalNode BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public TerminalNode CALL() { return getToken(IcebergSqlExtensionsParser.CALL, 0); }
public TerminalNode CREATE() { return getToken(IcebergSqlExtensionsParser.CREATE, 0); }
public TerminalNode DAYS() { return getToken(IcebergSqlExtensionsParser.DAYS, 0); }
public TerminalNode DESC() { return getToken(IcebergSqlExtensionsParser.DESC, 0); }
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode EXISTS() { return getToken(IcebergSqlExtensionsParser.EXISTS, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TerminalNode FIRST() { return getToken(IcebergSqlExtensionsParser.FIRST, 0); }
public TerminalNode HOURS() { return getToken(IcebergSqlExtensionsParser.HOURS, 0); }
public TerminalNode IF() { return getToken(IcebergSqlExtensionsParser.IF, 0); }
public TerminalNode LAST() { return getToken(IcebergSqlExtensionsParser.LAST, 0); }
public TerminalNode NOT() { return getToken(IcebergSqlExtensionsParser.NOT, 0); }
public TerminalNode NULLS() { return getToken(IcebergSqlExtensionsParser.NULLS, 0); }
public TerminalNode OF() { return getToken(IcebergSqlExtensionsParser.OF, 0); }
public TerminalNode OR() { return getToken(IcebergSqlExtensionsParser.OR, 0); }
public TerminalNode ORDERED() { return getToken(IcebergSqlExtensionsParser.ORDERED, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public TerminalNode WRITE() { return getToken(IcebergSqlExtensionsParser.WRITE, 0); }
public TerminalNode DISTRIBUTED() { return getToken(IcebergSqlExtensionsParser.DISTRIBUTED, 0); }
public TerminalNode LOCALLY() { return getToken(IcebergSqlExtensionsParser.LOCALLY, 0); }
public TerminalNode MINUTES() { return getToken(IcebergSqlExtensionsParser.MINUTES, 0); }
public TerminalNode MONTHS() { return getToken(IcebergSqlExtensionsParser.MONTHS, 0); }
public TerminalNode UNORDERED() { return getToken(IcebergSqlExtensionsParser.UNORDERED, 0); }
public TerminalNode REPLACE() { return getToken(IcebergSqlExtensionsParser.REPLACE, 0); }
public TerminalNode RETAIN() { return getToken(IcebergSqlExtensionsParser.RETAIN, 0); }
public TerminalNode VERSION() { return getToken(IcebergSqlExtensionsParser.VERSION, 0); }
public TerminalNode WITH() { return getToken(IcebergSqlExtensionsParser.WITH, 0); }
public TerminalNode IDENTIFIER_KW() { return getToken(IcebergSqlExtensionsParser.IDENTIFIER_KW, 0); }
public TerminalNode FIELDS() { return getToken(IcebergSqlExtensionsParser.FIELDS, 0); }
public TerminalNode SET() { return getToken(IcebergSqlExtensionsParser.SET, 0); }
public TerminalNode SNAPSHOT() { return getToken(IcebergSqlExtensionsParser.SNAPSHOT, 0); }
public TerminalNode SNAPSHOTS() { return getToken(IcebergSqlExtensionsParser.SNAPSHOTS, 0); }
public TerminalNode TAG() { return getToken(IcebergSqlExtensionsParser.TAG, 0); }
public TerminalNode TRUE() { return getToken(IcebergSqlExtensionsParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(IcebergSqlExtensionsParser.FALSE, 0); }
public TerminalNode MAP() { return getToken(IcebergSqlExtensionsParser.MAP, 0); }
public NonReservedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonReserved; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNonReserved(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNonReserved(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNonReserved(this);
else return visitor.visitChildren(this);
}
}
public final NonReservedContext nonReserved() throws RecognitionException {
NonReservedContext _localctx = new NonReservedContext(_ctx, getState());
enterRule(_localctx, 58, RULE_nonReserved);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(443);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALTER) | (1L << AS) | (1L << ASC) | (1L << BRANCH) | (1L << BY) | (1L << CALL) | (1L << DAYS) | (1L << DESC) | (1L << DISTRIBUTED) | (1L << DROP) | (1L << EXISTS) | (1L << FIELD) | (1L << FIELDS) | (1L << FIRST) | (1L << HOURS) | (1L << IF) | (1L << LAST) | (1L << LOCALLY) | (1L << MINUTES) | (1L << MONTHS) | (1L << CREATE) | (1L << NOT) | (1L << NULLS) | (1L << OF) | (1L << OR) | (1L << ORDERED) | (1L << PARTITION) | (1L << REPLACE) | (1L << RETAIN) | (1L << IDENTIFIER_KW) | (1L << SET) | (1L << SNAPSHOT) | (1L << SNAPSHOTS) | (1L << TABLE) | (1L << TAG) | (1L << UNORDERED) | (1L << VERSION) | (1L << WITH) | (1L << WRITE) | (1L << TRUE) | (1L << FALSE) | (1L << MAP))) != 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;
}
public static class SnapshotIdContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public SnapshotIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snapshotId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSnapshotId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSnapshotId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSnapshotId(this);
else return visitor.visitChildren(this);
}
}
public final SnapshotIdContext snapshotId() throws RecognitionException {
SnapshotIdContext _localctx = new SnapshotIdContext(_ctx, getState());
enterRule(_localctx, 60, RULE_snapshotId);
try {
enterOuterAlt(_localctx, 1);
{
setState(445);
number();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumSnapshotsContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumSnapshotsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numSnapshots; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNumSnapshots(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNumSnapshots(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNumSnapshots(this);
else return visitor.visitChildren(this);
}
}
public final NumSnapshotsContext numSnapshots() throws RecognitionException {
NumSnapshotsContext _localctx = new NumSnapshotsContext(_ctx, getState());
enterRule(_localctx, 62, RULE_numSnapshots);
try {
enterOuterAlt(_localctx, 1);
{
setState(447);
number();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeUnitContext extends ParserRuleContext {
public TerminalNode DAYS() { return getToken(IcebergSqlExtensionsParser.DAYS, 0); }
public TerminalNode HOURS() { return getToken(IcebergSqlExtensionsParser.HOURS, 0); }
public TerminalNode MINUTES() { return getToken(IcebergSqlExtensionsParser.MINUTES, 0); }
public TimeUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTimeUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTimeUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTimeUnit(this);
else return visitor.visitChildren(this);
}
}
public final TimeUnitContext timeUnit() throws RecognitionException {
TimeUnitContext _localctx = new TimeUnitContext(_ctx, getState());
enterRule(_localctx, 64, RULE_timeUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(449);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DAYS) | (1L << HOURS) | (1L << MINUTES))) != 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;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3F\u01c6\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3N\n\3\f\3\16\3Q\13"+
"\3\5\3S\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3`\n\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\5\3u\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u009e\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\5\3\u00a9\n\3\3\3\3\3\5\3\u00ad\n\3\3\4\3\4\5\4\u00b1\n\4\3\4\3"+
"\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00bd\n\4\3\4\3\4\3\4\5\4\u00c2"+
"\n\4\3\5\3\5\5\5\u00c6\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5"+
"\u00d2\n\5\3\5\3\5\3\5\5\5\u00d7\n\5\3\6\3\6\3\6\3\6\5\6\u00dd\n\6\3\6"+
"\5\6\u00e0\n\6\3\7\3\7\3\7\3\7\5\7\u00e6\n\7\3\7\5\7\u00e9\n\7\3\7\5\7"+
"\u00ec\n\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b"+
"\u00fc\n\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\7\f\u010a"+
"\n\f\f\f\16\f\u010d\13\f\3\r\3\r\3\r\3\r\3\16\5\16\u0114\n\16\3\16\3\16"+
"\3\16\3\16\5\16\u011a\n\16\3\17\3\17\3\17\3\17\3\17\5\17\u0121\n\17\3"+
"\20\3\20\3\20\3\21\3\21\3\21\7\21\u0129\n\21\f\21\16\21\u012c\13\21\3"+
"\21\3\21\3\21\3\21\7\21\u0132\n\21\f\21\16\21\u0135\13\21\3\21\3\21\5"+
"\21\u0139\n\21\3\22\3\22\5\22\u013d\n\22\3\22\3\22\5\22\u0141\n\22\3\23"+
"\3\23\3\23\3\23\3\23\3\23\7\23\u0149\n\23\f\23\16\23\u014c\13\23\3\23"+
"\3\23\5\23\u0150\n\23\3\24\3\24\5\24\u0154\n\24\3\25\3\25\3\25\5\25\u0159"+
"\n\25\3\26\3\26\3\26\6\26\u015e\n\26\r\26\16\26\u015f\3\26\3\26\3\26\5"+
"\26\u0165\n\26\3\27\3\27\3\27\3\27\3\27\7\27\u016c\n\27\f\27\16\27\u016f"+
"\13\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\7\30\u0178\n\30\f\30\16\30\u017b"+
"\13\30\3\30\3\30\3\31\3\31\3\32\5\32\u0182\n\32\3\32\3\32\5\32\u0186\n"+
"\32\3\32\3\32\5\32\u018a\n\32\3\32\3\32\5\32\u018e\n\32\3\32\3\32\5\32"+
"\u0192\n\32\3\32\3\32\5\32\u0196\n\32\3\32\3\32\5\32\u019a\n\32\3\32\3"+
"\32\5\32\u019e\n\32\3\32\3\32\5\32\u01a2\n\32\3\32\5\32\u01a5\n\32\3\33"+
"\3\33\3\33\7\33\u01aa\n\33\f\33\16\33\u01ad\13\33\3\34\3\34\3\34\5\34"+
"\u01b2\n\34\3\35\3\35\3\36\3\36\3\36\7\36\u01b9\n\36\f\36\16\36\u01bc"+
"\13\36\3\37\3\37\3 \3 \3!\3!\3\"\3\"\3\"\2\2#\2\4\6\b\n\f\16\20\22\24"+
"\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@B\2\7\4\2\13\13\20\20\4\2\26"+
"\26\31\31\3\2\61\62\4\2\b%\'\63\5\2\17\17\27\27\33\33\2\u01eb\2D\3\2\2"+
"\2\4\u00ac\3\2\2\2\6\u00c1\3\2\2\2\b\u00d6\3\2\2\2\n\u00dc\3\2\2\2\f\u00e5"+
"\3\2\2\2\16\u00fb\3\2\2\2\20\u00fd\3\2\2\2\22\u0101\3\2\2\2\24\u0104\3"+
"\2\2\2\26\u010b\3\2\2\2\30\u010e\3\2\2\2\32\u0119\3\2\2\2\34\u0120\3\2"+
"\2\2\36\u0122\3\2\2\2 \u0138\3\2\2\2\"\u013a\3\2\2\2$\u014f\3\2\2\2&\u0153"+
"\3\2\2\2(\u0158\3\2\2\2*\u0164\3\2\2\2,\u0166\3\2\2\2.\u0172\3\2\2\2\60"+
"\u017e\3\2\2\2\62\u01a4\3\2\2\2\64\u01a6\3\2\2\2\66\u01b1\3\2\2\28\u01b3"+
"\3\2\2\2:\u01b5\3\2\2\2<\u01bd\3\2\2\2>\u01bf\3\2\2\2@\u01c1\3\2\2\2B"+
"\u01c3\3\2\2\2DE\5\4\3\2EF\7\2\2\3F\3\3\2\2\2GH\7\16\2\2HI\5\64\33\2I"+
"R\7\3\2\2JO\5\34\17\2KL\7\4\2\2LN\5\34\17\2MK\3\2\2\2NQ\3\2\2\2OM\3\2"+
"\2\2OP\3\2\2\2PS\3\2\2\2QO\3\2\2\2RJ\3\2\2\2RS\3\2\2\2ST\3\2\2\2TU\7\5"+
"\2\2U\u00ad\3\2\2\2VW\7\t\2\2WX\7+\2\2XY\5\64\33\2YZ\7\b\2\2Z[\7#\2\2"+
"[\\\7\24\2\2\\_\5$\23\2]^\7\n\2\2^`\5\66\34\2_]\3\2\2\2_`\3\2\2\2`\u00ad"+
"\3\2\2\2ab\7\t\2\2bc\7+\2\2cd\5\64\33\2de\7\22\2\2ef\7#\2\2fg\7\24\2\2"+
"gh\5$\23\2h\u00ad\3\2\2\2ij\7\t\2\2jk\7+\2\2kl\5\64\33\2lm\7$\2\2mn\7"+
"#\2\2no\7\24\2\2op\5$\23\2pq\7/\2\2qt\5$\23\2rs\7\n\2\2su\5\66\34\2tr"+
"\3\2\2\2tu\3\2\2\2u\u00ad\3\2\2\2vw\7\t\2\2wx\7+\2\2xy\5\64\33\2yz\7\60"+
"\2\2z{\5\26\f\2{\u00ad\3\2\2\2|}\7\t\2\2}~\7+\2\2~\177\5\64\33\2\177\u0080"+
"\7(\2\2\u0080\u0081\7\'\2\2\u0081\u0082\7\25\2\2\u0082\u0083\5:\36\2\u0083"+
"\u00ad\3\2\2\2\u0084\u0085\7\t\2\2\u0085\u0086\7+\2\2\u0086\u0087\5\64"+
"\33\2\u0087\u0088\7\22\2\2\u0088\u0089\7\'\2\2\u0089\u008a\7\25\2\2\u008a"+
"\u008b\5:\36\2\u008b\u00ad\3\2\2\2\u008c\u008d\7\t\2\2\u008d\u008e\7+"+
"\2\2\u008e\u008f\5\64\33\2\u008f\u0090\5\b\5\2\u0090\u00ad\3\2\2\2\u0091"+
"\u0092\7\t\2\2\u0092\u0093\7+\2\2\u0093\u0094\5\64\33\2\u0094\u0095\5"+
"\6\4\2\u0095\u00ad\3\2\2\2\u0096\u0097\7\t\2\2\u0097\u0098\7+\2\2\u0098"+
"\u0099\5\64\33\2\u0099\u009a\7\22\2\2\u009a\u009d\7\f\2\2\u009b\u009c"+
"\7\30\2\2\u009c\u009e\7\23\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2"+
"\u009e\u009f\3\2\2\2\u009f\u00a0\5\66\34\2\u00a0\u00ad\3\2\2\2\u00a1\u00a2"+
"\7\t\2\2\u00a2\u00a3\7+\2\2\u00a3\u00a4\5\64\33\2\u00a4\u00a5\7\22\2\2"+
"\u00a5\u00a8\7,\2\2\u00a6\u00a7\7\30\2\2\u00a7\u00a9\7\23\2\2\u00a8\u00a6"+
"\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\5\66\34\2"+
"\u00ab\u00ad\3\2\2\2\u00acG\3\2\2\2\u00acV\3\2\2\2\u00aca\3\2\2\2\u00ac"+
"i\3\2\2\2\u00acv\3\2\2\2\u00ac|\3\2\2\2\u00ac\u0084\3\2\2\2\u00ac\u008c"+
"\3\2\2\2\u00ac\u0091\3\2\2\2\u00ac\u0096\3\2\2\2\u00ac\u00a1\3\2\2\2\u00ad"+
"\5\3\2\2\2\u00ae\u00af\7\35\2\2\u00af\u00b1\7!\2\2\u00b0\u00ae\3\2\2\2"+
"\u00b0\u00b1\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\7$\2\2\u00b3\u00b4"+
"\7,\2\2\u00b4\u00b5\5\66\34\2\u00b5\u00b6\5\n\6\2\u00b6\u00c2\3\2\2\2"+
"\u00b7\u00b8\7\35\2\2\u00b8\u00bc\7,\2\2\u00b9\u00ba\7\30\2\2\u00ba\u00bb"+
"\7\36\2\2\u00bb\u00bd\7\23\2\2\u00bc\u00b9\3\2\2\2\u00bc\u00bd\3\2\2\2"+
"\u00bd\u00be\3\2\2\2\u00be\u00bf\5\66\34\2\u00bf\u00c0\5\n\6\2\u00c0\u00c2"+
"\3\2\2\2\u00c1\u00b0\3\2\2\2\u00c1\u00b7\3\2\2\2\u00c2\7\3\2\2\2\u00c3"+
"\u00c4\7\35\2\2\u00c4\u00c6\7!\2\2\u00c5\u00c3\3\2\2\2\u00c5\u00c6\3\2"+
"\2\2\u00c6\u00c7\3\2\2\2\u00c7\u00c8\7$\2\2\u00c8\u00c9\7\f\2\2\u00c9"+
"\u00ca\5\66\34\2\u00ca\u00cb\5\f\7\2\u00cb\u00d7\3\2\2\2\u00cc\u00cd\7"+
"\35\2\2\u00cd\u00d1\7\f\2\2\u00ce\u00cf\7\30\2\2\u00cf\u00d0\7\36\2\2"+
"\u00d0\u00d2\7\23\2\2\u00d1\u00ce\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3"+
"\3\2\2\2\u00d3\u00d4\5\66\34\2\u00d4\u00d5\5\f\7\2\u00d5\u00d7\3\2\2\2"+
"\u00d6\u00c5\3\2\2\2\u00d6\u00cc\3\2\2\2\u00d7\t\3\2\2\2\u00d8\u00d9\7"+
"\n\2\2\u00d9\u00da\7 \2\2\u00da\u00db\7.\2\2\u00db\u00dd\5> \2\u00dc\u00d8"+
"\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00df\3\2\2\2\u00de\u00e0\5\20\t\2"+
"\u00df\u00de\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\13\3\2\2\2\u00e1\u00e2"+
"\7\n\2\2\u00e2\u00e3\7 \2\2\u00e3\u00e4\7.\2\2\u00e4\u00e6\5> \2\u00e5"+
"\u00e1\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e8\3\2\2\2\u00e7\u00e9\5\20"+
"\t\2\u00e8\u00e7\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9\u00eb\3\2\2\2\u00ea"+
"\u00ec\5\16\b\2\u00eb\u00ea\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\r\3\2\2"+
"\2\u00ed\u00ee\7/\2\2\u00ee\u00ef\7)\2\2\u00ef\u00f0\7&\2\2\u00f0\u00fc"+
"\5\24\13\2\u00f1\u00f2\7/\2\2\u00f2\u00f3\7)\2\2\u00f3\u00f4\7&\2\2\u00f4"+
"\u00fc\5\22\n\2\u00f5\u00f6\7/\2\2\u00f6\u00f7\7)\2\2\u00f7\u00f8\7&\2"+
"\2\u00f8\u00f9\5\24\13\2\u00f9\u00fa\5\22\n\2\u00fa\u00fc\3\2\2\2\u00fb"+
"\u00ed\3\2\2\2\u00fb\u00f1\3\2\2\2\u00fb\u00f5\3\2\2\2\u00fc\17\3\2\2"+
"\2\u00fd\u00fe\7%\2\2\u00fe\u00ff\5\62\32\2\u00ff\u0100\5B\"\2\u0100\21"+
"\3\2\2\2\u0101\u0102\5\62\32\2\u0102\u0103\5B\"\2\u0103\23\3\2\2\2\u0104"+
"\u0105\5\62\32\2\u0105\u0106\7*\2\2\u0106\25\3\2\2\2\u0107\u010a\5\30"+
"\r\2\u0108\u010a\5\32\16\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a"+
"\u010d\3\2\2\2\u010b\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\27\3\2\2"+
"\2\u010d\u010b\3\2\2\2\u010e\u010f\7\21\2\2\u010f\u0110\7\r\2\2\u0110"+
"\u0111\7#\2\2\u0111\31\3\2\2\2\u0112\u0114\7\32\2\2\u0113\u0112\3\2\2"+
"\2\u0113\u0114\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0116\7\"\2\2\u0116\u0117"+
"\7\r\2\2\u0117\u011a\5 \21\2\u0118\u011a\7-\2\2\u0119\u0113\3\2\2\2\u0119"+
"\u0118\3\2\2\2\u011a\33\3\2\2\2\u011b\u0121\5(\25\2\u011c\u011d\5\66\34"+
"\2\u011d\u011e\7\6\2\2\u011e\u011f\5(\25\2\u011f\u0121\3\2\2\2\u0120\u011b"+
"\3\2\2\2\u0120\u011c\3\2\2\2\u0121\35\3\2\2\2\u0122\u0123\5 \21\2\u0123"+
"\u0124\7\2\2\3\u0124\37\3\2\2\2\u0125\u012a\5\"\22\2\u0126\u0127\7\4\2"+
"\2\u0127\u0129\5\"\22\2\u0128\u0126\3\2\2\2\u0129\u012c\3\2\2\2\u012a"+
"\u0128\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u0139\3\2\2\2\u012c\u012a\3\2"+
"\2\2\u012d\u012e\7\3\2\2\u012e\u0133\5\"\22\2\u012f\u0130\7\4\2\2\u0130"+
"\u0132\5\"\22\2\u0131\u012f\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3"+
"\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135\u0133\3\2\2\2\u0136"+
"\u0137\7\5\2\2\u0137\u0139\3\2\2\2\u0138\u0125\3\2\2\2\u0138\u012d\3\2"+
"\2\2\u0139!\3\2\2\2\u013a\u013c\5$\23\2\u013b\u013d\t\2\2\2\u013c\u013b"+
"\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u0140\3\2\2\2\u013e\u013f\7\37\2\2"+
"\u013f\u0141\t\3\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2\u0141#\3"+
"\2\2\2\u0142\u0150\5\64\33\2\u0143\u0144\5\66\34\2\u0144\u0145\7\3\2\2"+
"\u0145\u014a\5&\24\2\u0146\u0147\7\4\2\2\u0147\u0149\5&\24\2\u0148\u0146"+
"\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2\u014b"+
"\u014d\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\7\5\2\2\u014e\u0150\3\2"+
"\2\2\u014f\u0142\3\2\2\2\u014f\u0143\3\2\2\2\u0150%\3\2\2\2\u0151\u0154"+
"\5\64\33\2\u0152\u0154\5*\26\2\u0153\u0151\3\2\2\2\u0153\u0152\3\2\2\2"+
"\u0154\'\3\2\2\2\u0155\u0159\5*\26\2\u0156\u0159\5,\27\2\u0157\u0159\5"+
".\30\2\u0158\u0155\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0157\3\2\2\2\u0159"+
")\3\2\2\2\u015a\u0165\5\62\32\2\u015b\u0165\5\60\31\2\u015c\u015e\7\67"+
"\2\2\u015d\u015c\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u015d\3\2\2\2\u015f"+
"\u0160\3\2\2\2\u0160\u0165\3\2\2\2\u0161\u0162\5\66\34\2\u0162\u0163\7"+
"\67\2\2\u0163\u0165\3\2\2\2\u0164\u015a\3\2\2\2\u0164\u015b\3\2\2\2\u0164"+
"\u015d\3\2\2\2\u0164\u0161\3\2\2\2\u0165+\3\2\2\2\u0166\u0167\7\63\2\2"+
"\u0167\u0168\7\3\2\2\u0168\u016d\5*\26\2\u0169\u016a\7\4\2\2\u016a\u016c"+
"\5*\26\2\u016b\u0169\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+
"\u016e\3\2\2\2\u016e\u0170\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0171\7\5"+
"\2\2\u0171-\3\2\2\2\u0172\u0173\7\64\2\2\u0173\u0174\7\3\2\2\u0174\u0179"+
"\5*\26\2\u0175\u0176\7\4\2\2\u0176\u0178\5*\26\2\u0177\u0175\3\2\2\2\u0178"+
"\u017b\3\2\2\2\u0179\u0177\3\2\2\2\u0179\u017a\3\2\2\2\u017a\u017c\3\2"+
"\2\2\u017b\u0179\3\2\2\2\u017c\u017d\7\5\2\2\u017d/\3\2\2\2\u017e\u017f"+
"\t\4\2\2\u017f\61\3\2\2\2\u0180\u0182\7\66\2\2\u0181\u0180\3\2\2\2\u0181"+
"\u0182\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u01a5\7<\2\2\u0184\u0186\7\66"+
"\2\2\u0185\u0184\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0187\3\2\2\2\u0187"+
"\u01a5\7=\2\2\u0188\u018a\7\66\2\2\u0189\u0188\3\2\2\2\u0189\u018a\3\2"+
"\2\2\u018a\u018b\3\2\2\2\u018b\u01a5\7;\2\2\u018c\u018e\7\66\2\2\u018d"+
"\u018c\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u01a5\78"+
"\2\2\u0190\u0192\7\66\2\2\u0191\u0190\3\2\2\2\u0191\u0192\3\2\2\2\u0192"+
"\u0193\3\2\2\2\u0193\u01a5\79\2\2\u0194\u0196\7\66\2\2\u0195\u0194\3\2"+
"\2\2\u0195\u0196\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u01a5\7:\2\2\u0198"+
"\u019a\7\66\2\2\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019b\3"+
"\2\2\2\u019b\u01a5\7?\2\2\u019c\u019e\7\66\2\2\u019d\u019c\3\2\2\2\u019d"+
"\u019e\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a5\7>\2\2\u01a0\u01a2\7\66"+
"\2\2\u01a1\u01a0\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3"+
"\u01a5\7@\2\2\u01a4\u0181\3\2\2\2\u01a4\u0185\3\2\2\2\u01a4\u0189\3\2"+
"\2\2\u01a4\u018d\3\2\2\2\u01a4\u0191\3\2\2\2\u01a4\u0195\3\2\2\2\u01a4"+
"\u0199\3\2\2\2\u01a4\u019d\3\2\2\2\u01a4\u01a1\3\2\2\2\u01a5\63\3\2\2"+
"\2\u01a6\u01ab\5\66\34\2\u01a7\u01a8\7\7\2\2\u01a8\u01aa\5\66\34\2\u01a9"+
"\u01a7\3\2\2\2\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2"+
"\2\2\u01ac\65\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ae\u01b2\7A\2\2\u01af\u01b2"+
"\58\35\2\u01b0\u01b2\5<\37\2\u01b1\u01ae\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1"+
"\u01b0\3\2\2\2\u01b2\67\3\2\2\2\u01b3\u01b4\7B\2\2\u01b49\3\2\2\2\u01b5"+
"\u01ba\5\64\33\2\u01b6\u01b7\7\4\2\2\u01b7\u01b9\5\64\33\2\u01b8\u01b6"+
"\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb"+
";\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bd\u01be\t\5\2\2\u01be=\3\2\2\2\u01bf"+
"\u01c0\5\62\32\2\u01c0?\3\2\2\2\u01c1\u01c2\5\62\32\2\u01c2A\3\2\2\2\u01c3"+
"\u01c4\t\6\2\2\u01c4C\3\2\2\2\64OR_t\u009d\u00a8\u00ac\u00b0\u00bc\u00c1"+
"\u00c5\u00d1\u00d6\u00dc\u00df\u00e5\u00e8\u00eb\u00fb\u0109\u010b\u0113"+
"\u0119\u0120\u012a\u0133\u0138\u013c\u0140\u014a\u014f\u0153\u0158\u015f"+
"\u0164\u016d\u0179\u0181\u0185\u0189\u018d\u0191\u0195\u0199\u019d\u01a1"+
"\u01a4\u01ab\u01b1\u01ba";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}