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-spark3-extensions Show documentation
Show all versions of iceberg-spark3-extensions Show documentation
A table format for huge analytic datasets
// Generated from org.apache.spark.sql.catalyst.parser.extensions/IcebergSqlExtensions.g4 by ANTLR 4.7.1
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.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, ADD=6, ALTER=7, AS=8, ASC=9, BY=10,
CALL=11, DESC=12, DISTRIBUTED=13, DROP=14, FIELD=15, FIELDS=16, FIRST=17,
LAST=18, LOCALLY=19, NULLS=20, ORDERED=21, PARTITION=22, REPLACE=23, IDENTIFIER_KW=24,
SET=25, TABLE=26, UNORDERED=27, WITH=28, WRITE=29, TRUE=30, FALSE=31,
MAP=32, PLUS=33, MINUS=34, STRING=35, BIGINT_LITERAL=36, SMALLINT_LITERAL=37,
TINYINT_LITERAL=38, INTEGER_VALUE=39, EXPONENT_VALUE=40, DECIMAL_VALUE=41,
FLOAT_LITERAL=42, DOUBLE_LITERAL=43, BIGDECIMAL_LITERAL=44, IDENTIFIER=45,
BACKQUOTED_IDENTIFIER=46, SIMPLE_COMMENT=47, BRACKETED_COMMENT=48, WS=49,
UNRECOGNIZED=50;
public static final int
RULE_singleStatement = 0, RULE_statement = 1, RULE_writeSpec = 2, RULE_writeDistributionSpec = 3,
RULE_writeOrderingSpec = 4, RULE_callArgument = 5, RULE_order = 6, RULE_orderField = 7,
RULE_transform = 8, RULE_transformArgument = 9, RULE_expression = 10,
RULE_constant = 11, RULE_stringMap = 12, RULE_booleanValue = 13, RULE_number = 14,
RULE_multipartIdentifier = 15, RULE_identifier = 16, RULE_quotedIdentifier = 17,
RULE_fieldList = 18, RULE_nonReserved = 19;
public static final String[] ruleNames = {
"singleStatement", "statement", "writeSpec", "writeDistributionSpec",
"writeOrderingSpec", "callArgument", "order", "orderField", "transform",
"transformArgument", "expression", "constant", "stringMap", "booleanValue",
"number", "multipartIdentifier", "identifier", "quotedIdentifier", "fieldList",
"nonReserved"
};
private static final String[] _LITERAL_NAMES = {
null, "'('", "','", "')'", "'=>'", "'.'", "'ADD'", "'ALTER'", "'AS'",
"'ASC'", "'BY'", "'CALL'", "'DESC'", "'DISTRIBUTED'", "'DROP'", "'FIELD'",
"'FIELDS'", "'FIRST'", "'LAST'", "'LOCALLY'", "'NULLS'", "'ORDERED'",
"'PARTITION'", "'REPLACE'", "'IDENTIFIER'", "'SET'", "'TABLE'", "'UNORDERED'",
"'WITH'", "'WRITE'", "'TRUE'", "'FALSE'", "'MAP'", "'+'", "'-'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, "ADD", "ALTER", "AS", "ASC", "BY",
"CALL", "DESC", "DISTRIBUTED", "DROP", "FIELD", "FIELDS", "FIRST", "LAST",
"LOCALLY", "NULLS", "ORDERED", "PARTITION", "REPLACE", "IDENTIFIER_KW",
"SET", "TABLE", "UNORDERED", "WITH", "WRITE", "TRUE", "FALSE", "MAP",
"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"
};
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(40);
statement();
setState(41);
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 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 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(112);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
_localctx = new CallContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(43);
match(CALL);
setState(44);
multipartIdentifier();
setState(45);
match(T__0);
setState(54);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALTER) | (1L << AS) | (1L << ASC) | (1L << BY) | (1L << CALL) | (1L << DESC) | (1L << DISTRIBUTED) | (1L << DROP) | (1L << FIELD) | (1L << FIELDS) | (1L << FIRST) | (1L << LAST) | (1L << LOCALLY) | (1L << NULLS) | (1L << ORDERED) | (1L << PARTITION) | (1L << REPLACE) | (1L << IDENTIFIER_KW) | (1L << SET) | (1L << TABLE) | (1L << UNORDERED) | (1L << WITH) | (1L << WRITE) | (1L << TRUE) | (1L << FALSE) | (1L << MAP) | (1L << MINUS) | (1L << STRING) | (1L << BIGINT_LITERAL) | (1L << SMALLINT_LITERAL) | (1L << TINYINT_LITERAL) | (1L << INTEGER_VALUE) | (1L << EXPONENT_VALUE) | (1L << DECIMAL_VALUE) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIGDECIMAL_LITERAL) | (1L << IDENTIFIER) | (1L << BACKQUOTED_IDENTIFIER))) != 0)) {
{
setState(46);
callArgument();
setState(51);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(47);
match(T__1);
setState(48);
callArgument();
}
}
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(56);
match(T__2);
}
break;
case 2:
_localctx = new AddPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(58);
match(ALTER);
setState(59);
match(TABLE);
setState(60);
multipartIdentifier();
setState(61);
match(ADD);
setState(62);
match(PARTITION);
setState(63);
match(FIELD);
setState(64);
transform();
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(65);
match(AS);
setState(66);
((AddPartitionFieldContext)_localctx).name = identifier();
}
}
}
break;
case 3:
_localctx = new DropPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(69);
match(ALTER);
setState(70);
match(TABLE);
setState(71);
multipartIdentifier();
setState(72);
match(DROP);
setState(73);
match(PARTITION);
setState(74);
match(FIELD);
setState(75);
transform();
}
break;
case 4:
_localctx = new ReplacePartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(77);
match(ALTER);
setState(78);
match(TABLE);
setState(79);
multipartIdentifier();
setState(80);
match(REPLACE);
setState(81);
match(PARTITION);
setState(82);
match(FIELD);
setState(83);
transform();
setState(84);
match(WITH);
setState(85);
transform();
setState(88);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(86);
match(AS);
setState(87);
((ReplacePartitionFieldContext)_localctx).name = identifier();
}
}
}
break;
case 5:
_localctx = new SetWriteDistributionAndOrderingContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(90);
match(ALTER);
setState(91);
match(TABLE);
setState(92);
multipartIdentifier();
setState(93);
match(WRITE);
setState(94);
writeSpec();
}
break;
case 6:
_localctx = new SetIdentifierFieldsContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(96);
match(ALTER);
setState(97);
match(TABLE);
setState(98);
multipartIdentifier();
setState(99);
match(SET);
setState(100);
match(IDENTIFIER_KW);
setState(101);
match(FIELDS);
setState(102);
fieldList();
}
break;
case 7:
_localctx = new DropIdentifierFieldsContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(104);
match(ALTER);
setState(105);
match(TABLE);
setState(106);
multipartIdentifier();
setState(107);
match(DROP);
setState(108);
match(IDENTIFIER_KW);
setState(109);
match(FIELDS);
setState(110);
fieldList();
}
break;
}
}
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, 4, RULE_writeSpec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(118);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DISTRIBUTED) | (1L << LOCALLY) | (1L << ORDERED) | (1L << UNORDERED))) != 0)) {
{
setState(116);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DISTRIBUTED:
{
setState(114);
writeDistributionSpec();
}
break;
case LOCALLY:
case ORDERED:
case UNORDERED:
{
setState(115);
writeOrderingSpec();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(120);
_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, 6, RULE_writeDistributionSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(121);
match(DISTRIBUTED);
setState(122);
match(BY);
setState(123);
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, 8, RULE_writeOrderingSpec);
int _la;
try {
setState(132);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LOCALLY:
case ORDERED:
enterOuterAlt(_localctx, 1);
{
setState(126);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LOCALLY) {
{
setState(125);
match(LOCALLY);
}
}
setState(128);
match(ORDERED);
setState(129);
match(BY);
setState(130);
order();
}
break;
case UNORDERED:
enterOuterAlt(_localctx, 2);
{
setState(131);
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, 10, RULE_callArgument);
try {
setState(139);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
_localctx = new PositionalArgumentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(134);
expression();
}
break;
case 2:
_localctx = new NamedArgumentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(135);
identifier();
setState(136);
match(T__3);
setState(137);
expression();
}
break;
}
}
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, 12, RULE_order);
int _la;
try {
setState(160);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case ALTER:
case AS:
case ASC:
case BY:
case CALL:
case DESC:
case DISTRIBUTED:
case DROP:
case FIELD:
case FIELDS:
case FIRST:
case LAST:
case LOCALLY:
case NULLS:
case ORDERED:
case PARTITION:
case REPLACE:
case IDENTIFIER_KW:
case SET:
case TABLE:
case UNORDERED:
case WITH:
case WRITE:
case TRUE:
case FALSE:
case MAP:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(141);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(146);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(142);
match(T__1);
setState(143);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(148);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(149);
match(T__0);
setState(150);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(151);
match(T__1);
setState(152);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(158);
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, 14, RULE_orderField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(162);
transform();
setState(164);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(163);
((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(168);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(166);
match(NULLS);
setState(167);
((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, 16, RULE_transform);
int _la;
try {
setState(183);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
_localctx = new IdentityTransformContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(170);
multipartIdentifier();
}
break;
case 2:
_localctx = new ApplyTransformContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(171);
((ApplyTransformContext)_localctx).transformName = identifier();
setState(172);
match(T__0);
setState(173);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
setState(178);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(174);
match(T__1);
setState(175);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
}
}
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(181);
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, 18, RULE_transformArgument);
try {
setState(187);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(185);
multipartIdentifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(186);
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 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, 20, RULE_expression);
try {
setState(191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(189);
constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(190);
stringMap();
}
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, 22, RULE_constant);
int _la;
try {
setState(203);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
_localctx = new NumericLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(193);
number();
}
break;
case 2:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(194);
booleanValue();
}
break;
case 3:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(196);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(195);
match(STRING);
}
}
setState(198);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case 4:
_localctx = new TypeConstructorContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(200);
identifier();
setState(201);
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, 24, RULE_stringMap);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(205);
match(MAP);
setState(206);
match(T__0);
setState(207);
constant();
setState(212);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(208);
match(T__1);
setState(209);
constant();
}
}
setState(214);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(215);
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, 26, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(217);
_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, 28, RULE_number);
int _la;
try {
setState(255);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
_localctx = new ExponentLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(220);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(219);
match(MINUS);
}
}
setState(222);
match(EXPONENT_VALUE);
}
break;
case 2:
_localctx = new DecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(224);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(223);
match(MINUS);
}
}
setState(226);
match(DECIMAL_VALUE);
}
break;
case 3:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(228);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(227);
match(MINUS);
}
}
setState(230);
match(INTEGER_VALUE);
}
break;
case 4:
_localctx = new BigIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(232);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(231);
match(MINUS);
}
}
setState(234);
match(BIGINT_LITERAL);
}
break;
case 5:
_localctx = new SmallIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(235);
match(MINUS);
}
}
setState(238);
match(SMALLINT_LITERAL);
}
break;
case 6:
_localctx = new TinyIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(240);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(239);
match(MINUS);
}
}
setState(242);
match(TINYINT_LITERAL);
}
break;
case 7:
_localctx = new DoubleLiteralContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(244);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(243);
match(MINUS);
}
}
setState(246);
match(DOUBLE_LITERAL);
}
break;
case 8:
_localctx = new FloatLiteralContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(248);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(247);
match(MINUS);
}
}
setState(250);
match(FLOAT_LITERAL);
}
break;
case 9:
_localctx = new BigDecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(251);
match(MINUS);
}
}
setState(254);
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, 30, RULE_multipartIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(257);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(258);
match(T__4);
setState(259);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
}
}
setState(264);
_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, 32, RULE_identifier);
try {
setState(268);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(265);
match(IDENTIFIER);
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new QuotedIdentifierAlternativeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(266);
quotedIdentifier();
}
break;
case ADD:
case ALTER:
case AS:
case ASC:
case BY:
case CALL:
case DESC:
case DISTRIBUTED:
case DROP:
case FIELD:
case FIELDS:
case FIRST:
case LAST:
case LOCALLY:
case NULLS:
case ORDERED:
case PARTITION:
case REPLACE:
case IDENTIFIER_KW:
case SET:
case TABLE:
case UNORDERED:
case WITH:
case WRITE:
case TRUE:
case FALSE:
case MAP:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(267);
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, 34, RULE_quotedIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(270);
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, 36, RULE_fieldList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(272);
((FieldListContext)_localctx).multipartIdentifier = multipartIdentifier();
((FieldListContext)_localctx).fields.add(((FieldListContext)_localctx).multipartIdentifier);
setState(277);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(273);
match(T__1);
setState(274);
((FieldListContext)_localctx).multipartIdentifier = multipartIdentifier();
((FieldListContext)_localctx).fields.add(((FieldListContext)_localctx).multipartIdentifier);
}
}
setState(279);
_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 BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public TerminalNode CALL() { return getToken(IcebergSqlExtensionsParser.CALL, 0); }
public TerminalNode DESC() { return getToken(IcebergSqlExtensionsParser.DESC, 0); }
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TerminalNode FIRST() { return getToken(IcebergSqlExtensionsParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(IcebergSqlExtensionsParser.LAST, 0); }
public TerminalNode NULLS() { return getToken(IcebergSqlExtensionsParser.NULLS, 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 UNORDERED() { return getToken(IcebergSqlExtensionsParser.UNORDERED, 0); }
public TerminalNode REPLACE() { return getToken(IcebergSqlExtensionsParser.REPLACE, 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 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, 38, RULE_nonReserved);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(280);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALTER) | (1L << AS) | (1L << ASC) | (1L << BY) | (1L << CALL) | (1L << DESC) | (1L << DISTRIBUTED) | (1L << DROP) | (1L << FIELD) | (1L << FIELDS) | (1L << FIRST) | (1L << LAST) | (1L << LOCALLY) | (1L << NULLS) | (1L << ORDERED) | (1L << PARTITION) | (1L << REPLACE) | (1L << IDENTIFIER_KW) | (1L << SET) | (1L << TABLE) | (1L << UNORDERED) | (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 final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\64\u011d\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\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3"+
"\64\n\3\f\3\16\3\67\13\3\5\39\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\3F\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\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\3\3\3\3\3\3\5\3s\n\3\3\4\3\4"+
"\7\4w\n\4\f\4\16\4z\13\4\3\5\3\5\3\5\3\5\3\6\5\6\u0081\n\6\3\6\3\6\3\6"+
"\3\6\5\6\u0087\n\6\3\7\3\7\3\7\3\7\3\7\5\7\u008e\n\7\3\b\3\b\3\b\7\b\u0093"+
"\n\b\f\b\16\b\u0096\13\b\3\b\3\b\3\b\3\b\7\b\u009c\n\b\f\b\16\b\u009f"+
"\13\b\3\b\3\b\5\b\u00a3\n\b\3\t\3\t\5\t\u00a7\n\t\3\t\3\t\5\t\u00ab\n"+
"\t\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00b3\n\n\f\n\16\n\u00b6\13\n\3\n\3\n\5"+
"\n\u00ba\n\n\3\13\3\13\5\13\u00be\n\13\3\f\3\f\5\f\u00c2\n\f\3\r\3\r\3"+
"\r\6\r\u00c7\n\r\r\r\16\r\u00c8\3\r\3\r\3\r\5\r\u00ce\n\r\3\16\3\16\3"+
"\16\3\16\3\16\7\16\u00d5\n\16\f\16\16\16\u00d8\13\16\3\16\3\16\3\17\3"+
"\17\3\20\5\20\u00df\n\20\3\20\3\20\5\20\u00e3\n\20\3\20\3\20\5\20\u00e7"+
"\n\20\3\20\3\20\5\20\u00eb\n\20\3\20\3\20\5\20\u00ef\n\20\3\20\3\20\5"+
"\20\u00f3\n\20\3\20\3\20\5\20\u00f7\n\20\3\20\3\20\5\20\u00fb\n\20\3\20"+
"\3\20\5\20\u00ff\n\20\3\20\5\20\u0102\n\20\3\21\3\21\3\21\7\21\u0107\n"+
"\21\f\21\16\21\u010a\13\21\3\22\3\22\3\22\5\22\u010f\n\22\3\23\3\23\3"+
"\24\3\24\3\24\7\24\u0116\n\24\f\24\16\24\u0119\13\24\3\25\3\25\3\25\2"+
"\2\26\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(\2\6\4\2\13\13\16\16"+
"\3\2\23\24\3\2 !\3\2\b\"\2\u013a\2*\3\2\2\2\4r\3\2\2\2\6x\3\2\2\2\b{\3"+
"\2\2\2\n\u0086\3\2\2\2\f\u008d\3\2\2\2\16\u00a2\3\2\2\2\20\u00a4\3\2\2"+
"\2\22\u00b9\3\2\2\2\24\u00bd\3\2\2\2\26\u00c1\3\2\2\2\30\u00cd\3\2\2\2"+
"\32\u00cf\3\2\2\2\34\u00db\3\2\2\2\36\u0101\3\2\2\2 \u0103\3\2\2\2\"\u010e"+
"\3\2\2\2$\u0110\3\2\2\2&\u0112\3\2\2\2(\u011a\3\2\2\2*+\5\4\3\2+,\7\2"+
"\2\3,\3\3\2\2\2-.\7\r\2\2./\5 \21\2/8\7\3\2\2\60\65\5\f\7\2\61\62\7\4"+
"\2\2\62\64\5\f\7\2\63\61\3\2\2\2\64\67\3\2\2\2\65\63\3\2\2\2\65\66\3\2"+
"\2\2\669\3\2\2\2\67\65\3\2\2\28\60\3\2\2\289\3\2\2\29:\3\2\2\2:;\7\5\2"+
"\2;s\3\2\2\2<=\7\t\2\2=>\7\34\2\2>?\5 \21\2?@\7\b\2\2@A\7\30\2\2AB\7\21"+
"\2\2BE\5\22\n\2CD\7\n\2\2DF\5\"\22\2EC\3\2\2\2EF\3\2\2\2Fs\3\2\2\2GH\7"+
"\t\2\2HI\7\34\2\2IJ\5 \21\2JK\7\20\2\2KL\7\30\2\2LM\7\21\2\2MN\5\22\n"+
"\2Ns\3\2\2\2OP\7\t\2\2PQ\7\34\2\2QR\5 \21\2RS\7\31\2\2ST\7\30\2\2TU\7"+
"\21\2\2UV\5\22\n\2VW\7\36\2\2WZ\5\22\n\2XY\7\n\2\2Y[\5\"\22\2ZX\3\2\2"+
"\2Z[\3\2\2\2[s\3\2\2\2\\]\7\t\2\2]^\7\34\2\2^_\5 \21\2_`\7\37\2\2`a\5"+
"\6\4\2as\3\2\2\2bc\7\t\2\2cd\7\34\2\2de\5 \21\2ef\7\33\2\2fg\7\32\2\2"+
"gh\7\22\2\2hi\5&\24\2is\3\2\2\2jk\7\t\2\2kl\7\34\2\2lm\5 \21\2mn\7\20"+
"\2\2no\7\32\2\2op\7\22\2\2pq\5&\24\2qs\3\2\2\2r-\3\2\2\2r<\3\2\2\2rG\3"+
"\2\2\2rO\3\2\2\2r\\\3\2\2\2rb\3\2\2\2rj\3\2\2\2s\5\3\2\2\2tw\5\b\5\2u"+
"w\5\n\6\2vt\3\2\2\2vu\3\2\2\2wz\3\2\2\2xv\3\2\2\2xy\3\2\2\2y\7\3\2\2\2"+
"zx\3\2\2\2{|\7\17\2\2|}\7\f\2\2}~\7\30\2\2~\t\3\2\2\2\177\u0081\7\25\2"+
"\2\u0080\177\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083"+
"\7\27\2\2\u0083\u0084\7\f\2\2\u0084\u0087\5\16\b\2\u0085\u0087\7\35\2"+
"\2\u0086\u0080\3\2\2\2\u0086\u0085\3\2\2\2\u0087\13\3\2\2\2\u0088\u008e"+
"\5\26\f\2\u0089\u008a\5\"\22\2\u008a\u008b\7\6\2\2\u008b\u008c\5\26\f"+
"\2\u008c\u008e\3\2\2\2\u008d\u0088\3\2\2\2\u008d\u0089\3\2\2\2\u008e\r"+
"\3\2\2\2\u008f\u0094\5\20\t\2\u0090\u0091\7\4\2\2\u0091\u0093\5\20\t\2"+
"\u0092\u0090\3\2\2\2\u0093\u0096\3\2\2\2\u0094\u0092\3\2\2\2\u0094\u0095"+
"\3\2\2\2\u0095\u00a3\3\2\2\2\u0096\u0094\3\2\2\2\u0097\u0098\7\3\2\2\u0098"+
"\u009d\5\20\t\2\u0099\u009a\7\4\2\2\u009a\u009c\5\20\t\2\u009b\u0099\3"+
"\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e"+
"\u00a0\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a1\7\5\2\2\u00a1\u00a3\3\2"+
"\2\2\u00a2\u008f\3\2\2\2\u00a2\u0097\3\2\2\2\u00a3\17\3\2\2\2\u00a4\u00a6"+
"\5\22\n\2\u00a5\u00a7\t\2\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7\3\2\2\2"+
"\u00a7\u00aa\3\2\2\2\u00a8\u00a9\7\26\2\2\u00a9\u00ab\t\3\2\2\u00aa\u00a8"+
"\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\21\3\2\2\2\u00ac\u00ba\5 \21\2\u00ad"+
"\u00ae\5\"\22\2\u00ae\u00af\7\3\2\2\u00af\u00b4\5\24\13\2\u00b0\u00b1"+
"\7\4\2\2\u00b1\u00b3\5\24\13\2\u00b2\u00b0\3\2\2\2\u00b3\u00b6\3\2\2\2"+
"\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7\3\2\2\2\u00b6\u00b4"+
"\3\2\2\2\u00b7\u00b8\7\5\2\2\u00b8\u00ba\3\2\2\2\u00b9\u00ac\3\2\2\2\u00b9"+
"\u00ad\3\2\2\2\u00ba\23\3\2\2\2\u00bb\u00be\5 \21\2\u00bc\u00be\5\30\r"+
"\2\u00bd\u00bb\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be\25\3\2\2\2\u00bf\u00c2"+
"\5\30\r\2\u00c0\u00c2\5\32\16\2\u00c1\u00bf\3\2\2\2\u00c1\u00c0\3\2\2"+
"\2\u00c2\27\3\2\2\2\u00c3\u00ce\5\36\20\2\u00c4\u00ce\5\34\17\2\u00c5"+
"\u00c7\7%\2\2\u00c6\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00c6\3\2"+
"\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ce\3\2\2\2\u00ca\u00cb\5\"\22\2\u00cb"+
"\u00cc\7%\2\2\u00cc\u00ce\3\2\2\2\u00cd\u00c3\3\2\2\2\u00cd\u00c4\3\2"+
"\2\2\u00cd\u00c6\3\2\2\2\u00cd\u00ca\3\2\2\2\u00ce\31\3\2\2\2\u00cf\u00d0"+
"\7\"\2\2\u00d0\u00d1\7\3\2\2\u00d1\u00d6\5\30\r\2\u00d2\u00d3\7\4\2\2"+
"\u00d3\u00d5\5\30\r\2\u00d4\u00d2\3\2\2\2\u00d5\u00d8\3\2\2\2\u00d6\u00d4"+
"\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d9\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d9"+
"\u00da\7\5\2\2\u00da\33\3\2\2\2\u00db\u00dc\t\4\2\2\u00dc\35\3\2\2\2\u00dd"+
"\u00df\7$\2\2\u00de\u00dd\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\3\2"+
"\2\2\u00e0\u0102\7*\2\2\u00e1\u00e3\7$\2\2\u00e2\u00e1\3\2\2\2\u00e2\u00e3"+
"\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u0102\7+\2\2\u00e5\u00e7\7$\2\2\u00e6"+
"\u00e5\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u0102\7)"+
"\2\2\u00e9\u00eb\7$\2\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb"+
"\u00ec\3\2\2\2\u00ec\u0102\7&\2\2\u00ed\u00ef\7$\2\2\u00ee\u00ed\3\2\2"+
"\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u0102\7\'\2\2\u00f1\u00f3"+
"\7$\2\2\u00f2\u00f1\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4"+
"\u0102\7(\2\2\u00f5\u00f7\7$\2\2\u00f6\u00f5\3\2\2\2\u00f6\u00f7\3\2\2"+
"\2\u00f7\u00f8\3\2\2\2\u00f8\u0102\7-\2\2\u00f9\u00fb\7$\2\2\u00fa\u00f9"+
"\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u0102\7,\2\2\u00fd"+
"\u00ff\7$\2\2\u00fe\u00fd\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0100\3\2"+
"\2\2\u0100\u0102\7.\2\2\u0101\u00de\3\2\2\2\u0101\u00e2\3\2\2\2\u0101"+
"\u00e6\3\2\2\2\u0101\u00ea\3\2\2\2\u0101\u00ee\3\2\2\2\u0101\u00f2\3\2"+
"\2\2\u0101\u00f6\3\2\2\2\u0101\u00fa\3\2\2\2\u0101\u00fe\3\2\2\2\u0102"+
"\37\3\2\2\2\u0103\u0108\5\"\22\2\u0104\u0105\7\7\2\2\u0105\u0107\5\"\22"+
"\2\u0106\u0104\3\2\2\2\u0107\u010a\3\2\2\2\u0108\u0106\3\2\2\2\u0108\u0109"+
"\3\2\2\2\u0109!\3\2\2\2\u010a\u0108\3\2\2\2\u010b\u010f\7/\2\2\u010c\u010f"+
"\5$\23\2\u010d\u010f\5(\25\2\u010e\u010b\3\2\2\2\u010e\u010c\3\2\2\2\u010e"+
"\u010d\3\2\2\2\u010f#\3\2\2\2\u0110\u0111\7\60\2\2\u0111%\3\2\2\2\u0112"+
"\u0117\5 \21\2\u0113\u0114\7\4\2\2\u0114\u0116\5 \21\2\u0115\u0113\3\2"+
"\2\2\u0116\u0119\3\2\2\2\u0117\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118"+
"\'\3\2\2\2\u0119\u0117\3\2\2\2\u011a\u011b\t\5\2\2\u011b)\3\2\2\2%\65"+
"8EZrvx\u0080\u0086\u008d\u0094\u009d\u00a2\u00a6\u00aa\u00b4\u00b9\u00bd"+
"\u00c1\u00c8\u00cd\u00d6\u00de\u00e2\u00e6\u00ea\u00ee\u00f2\u00f6\u00fa"+
"\u00fe\u0101\u0108\u010e\u0117";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy