org.meridor.perspective.sql.SQLParser Maven / Gradle / Ivy
The newest version!
// Generated from org/meridor/perspective/sql/SQLParser.g4 by ANTLR 4.5.1
package org.meridor.perspective.sql;
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 SQLParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
EXPLAIN=1, SELECT=2, FROM=3, AS=4, WHERE=5, AND=6, OR=7, XOR=8, IS=9,
LIKE=10, IN=11, EXISTS=12, BETWEEN=13, ALL=14, ANY=15, NOT=16, EQ=17,
LT=18, GT=19, NOT_EQ=20, LTE=21, GTE=22, MULTIPLY=23, DIVIDE=24, MOD=25,
PLUS=26, MINUS=27, REGEXP=28, BIT_NOT=29, BIT_OR=30, BIT_AND=31, BIT_XOR=32,
SHIFT_LEFT=33, SHIFT_RIGHT=34, BINARY=35, ESCAPE=36, USE=37, IGNORE=38,
RPAREN=39, LPAREN=40, SEMICOLON=41, COMMA=42, DOT=43, INNER=44, OUTER=45,
JOIN=46, CROSS=47, USING=48, ORDER=49, ASC=50, DESC=51, GROUP=52, HAVING=53,
LIMIT=54, OFFSET=55, BY=56, STRAIGHT_JOIN=57, NATURAL=58, LEFT=59, RIGHT=60,
ON=61, NULL=62, TRUE=63, FALSE=64, INT=65, FLOAT=66, STRING=67, ID=68,
NEWLINE=69, WS=70;
public static final int
RULE_query = 0, RULE_table_name = 1, RULE_alias = 2, RULE_column_name = 3,
RULE_explain_query = 4, RULE_select_query = 5, RULE_select_clause = 6,
RULE_from_clause = 7, RULE_where_clause = 8, RULE_group_clause = 9, RULE_having_clause = 10,
RULE_order_clause = 11, RULE_offset = 12, RULE_row_count = 13, RULE_limit_clause = 14,
RULE_alias_clause = 15, RULE_aliased_expression = 16, RULE_select_expression = 17,
RULE_columns_list = 18, RULE_complex_boolean_expression = 19, RULE_expressions = 20,
RULE_order_expressions = 21, RULE_order_expression = 22, RULE_function_call = 23,
RULE_literal = 24, RULE_expression = 25, RULE_relational_operator = 26,
RULE_binary_arithmetic_operator = 27, RULE_unary_arithmetic_operator = 28,
RULE_binary_boolean_operator = 29, RULE_unary_boolean_operator = 30, RULE_simple_boolean_expression = 31,
RULE_table_references = 32, RULE_table_reference = 33, RULE_table_join = 34,
RULE_inner_join_clause = 35, RULE_outer_join_clause = 36, RULE_natural_join_clause = 37,
RULE_join_clause = 38, RULE_table_atom = 39, RULE_join_condition = 40;
public static final String[] ruleNames = {
"query", "table_name", "alias", "column_name", "explain_query", "select_query",
"select_clause", "from_clause", "where_clause", "group_clause", "having_clause",
"order_clause", "offset", "row_count", "limit_clause", "alias_clause",
"aliased_expression", "select_expression", "columns_list", "complex_boolean_expression",
"expressions", "order_expressions", "order_expression", "function_call",
"literal", "expression", "relational_operator", "binary_arithmetic_operator",
"unary_arithmetic_operator", "binary_boolean_operator", "unary_boolean_operator",
"simple_boolean_expression", "table_references", "table_reference", "table_join",
"inner_join_clause", "outer_join_clause", "natural_join_clause", "join_clause",
"table_atom", "join_condition"
};
private static final String[] _LITERAL_NAMES = {
null, "'explain'", "'select'", "'from'", "'as'", "'where'", null, null,
"'xor'", "'is'", "'like'", "'in'", "'exists'", "'between'", "'all'", "'any'",
null, "'='", "'<'", "'>'", "'!='", "'<='", "'>='", "'*'", null, null,
"'+'", "'-'", "'regexp'", "'~'", "'|'", "'&'", "'^'", "'<<'", "'>>'",
"'binary'", "'escape'", "'use'", "'ignore'", "')'", "'('", "';'", "','",
"'.'", "'inner'", "'outer'", "'join'", "'cross'", "'using'", "'order'",
"'asc'", "'desc'", "'group'", "'having'", "'limit'", "'offset'", "'by'",
"'straight_join'", "'natural'", "'left'", "'right'", "'on'", "'null'",
"'true'", "'false'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "EXPLAIN", "SELECT", "FROM", "AS", "WHERE", "AND", "OR", "XOR",
"IS", "LIKE", "IN", "EXISTS", "BETWEEN", "ALL", "ANY", "NOT", "EQ", "LT",
"GT", "NOT_EQ", "LTE", "GTE", "MULTIPLY", "DIVIDE", "MOD", "PLUS", "MINUS",
"REGEXP", "BIT_NOT", "BIT_OR", "BIT_AND", "BIT_XOR", "SHIFT_LEFT", "SHIFT_RIGHT",
"BINARY", "ESCAPE", "USE", "IGNORE", "RPAREN", "LPAREN", "SEMICOLON",
"COMMA", "DOT", "INNER", "OUTER", "JOIN", "CROSS", "USING", "ORDER", "ASC",
"DESC", "GROUP", "HAVING", "LIMIT", "OFFSET", "BY", "STRAIGHT_JOIN", "NATURAL",
"LEFT", "RIGHT", "ON", "NULL", "TRUE", "FALSE", "INT", "FLOAT", "STRING",
"ID", "NEWLINE", "WS"
};
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 "SQLParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SQLParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class QueryContext extends ParserRuleContext {
public Select_queryContext select_query() {
return getRuleContext(Select_queryContext.class,0);
}
public Explain_queryContext explain_query() {
return getRuleContext(Explain_queryContext.class,0);
}
public QueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitQuery(this);
}
}
public final QueryContext query() throws RecognitionException {
QueryContext _localctx = new QueryContext(_ctx, getState());
enterRule(_localctx, 0, RULE_query);
try {
setState(84);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(82);
select_query();
}
break;
case EXPLAIN:
enterOuterAlt(_localctx, 2);
{
setState(83);
explain_query();
}
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 Table_nameContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public Table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_name(this);
}
}
public final Table_nameContext table_name() throws RecognitionException {
Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
enterRule(_localctx, 2, RULE_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(86);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AliasContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public AliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAlias(this);
}
}
public final AliasContext alias() throws RecognitionException {
AliasContext _localctx = new AliasContext(_ctx, getState());
enterRule(_localctx, 4, RULE_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(88);
match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_nameContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public TerminalNode MULTIPLY() { return getToken(SQLParser.MULTIPLY, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLParser.DOT, 0); }
public AliasContext alias() {
return getRuleContext(AliasContext.class,0);
}
public Column_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterColumn_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitColumn_name(this);
}
}
public final Column_nameContext column_name() throws RecognitionException {
Column_nameContext _localctx = new Column_nameContext(_ctx, getState());
enterRule(_localctx, 6, RULE_column_name);
int _la;
try {
setState(102);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(93);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(90);
table_name();
setState(91);
match(DOT);
}
break;
}
setState(95);
_la = _input.LA(1);
if ( !(_la==MULTIPLY || _la==ID) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(99);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(96);
alias();
setState(97);
match(DOT);
}
break;
}
setState(101);
_la = _input.LA(1);
if ( !(_la==MULTIPLY || _la==ID) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Explain_queryContext extends ParserRuleContext {
public TerminalNode EXPLAIN() { return getToken(SQLParser.EXPLAIN, 0); }
public Select_queryContext select_query() {
return getRuleContext(Select_queryContext.class,0);
}
public Explain_queryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explain_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterExplain_query(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitExplain_query(this);
}
}
public final Explain_queryContext explain_query() throws RecognitionException {
Explain_queryContext _localctx = new Explain_queryContext(_ctx, getState());
enterRule(_localctx, 8, RULE_explain_query);
try {
enterOuterAlt(_localctx, 1);
{
setState(104);
match(EXPLAIN);
setState(105);
select_query();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_queryContext extends ParserRuleContext {
public Select_clauseContext select_clause() {
return getRuleContext(Select_clauseContext.class,0);
}
public From_clauseContext from_clause() {
return getRuleContext(From_clauseContext.class,0);
}
public Where_clauseContext where_clause() {
return getRuleContext(Where_clauseContext.class,0);
}
public Group_clauseContext group_clause() {
return getRuleContext(Group_clauseContext.class,0);
}
public Having_clauseContext having_clause() {
return getRuleContext(Having_clauseContext.class,0);
}
public Order_clauseContext order_clause() {
return getRuleContext(Order_clauseContext.class,0);
}
public Limit_clauseContext limit_clause() {
return getRuleContext(Limit_clauseContext.class,0);
}
public TerminalNode SEMICOLON() { return getToken(SQLParser.SEMICOLON, 0); }
public Select_queryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_query; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_query(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_query(this);
}
}
public final Select_queryContext select_query() throws RecognitionException {
Select_queryContext _localctx = new Select_queryContext(_ctx, getState());
enterRule(_localctx, 10, RULE_select_query);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
select_clause();
setState(109);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(108);
from_clause();
}
}
setState(112);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(111);
where_clause();
}
}
setState(115);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(114);
group_clause();
}
}
setState(118);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(117);
having_clause();
}
}
setState(121);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(120);
order_clause();
}
}
setState(124);
_la = _input.LA(1);
if (_la==LIMIT) {
{
setState(123);
limit_clause();
}
}
setState(127);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(126);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_clauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(SQLParser.SELECT, 0); }
public Select_expressionContext select_expression() {
return getRuleContext(Select_expressionContext.class,0);
}
public Select_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_clause(this);
}
}
public final Select_clauseContext select_clause() throws RecognitionException {
Select_clauseContext _localctx = new Select_clauseContext(_ctx, getState());
enterRule(_localctx, 12, RULE_select_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(129);
match(SELECT);
setState(130);
select_expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class From_clauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(SQLParser.FROM, 0); }
public Table_referencesContext table_references() {
return getRuleContext(Table_referencesContext.class,0);
}
public From_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_from_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterFrom_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitFrom_clause(this);
}
}
public final From_clauseContext from_clause() throws RecognitionException {
From_clauseContext _localctx = new From_clauseContext(_ctx, getState());
enterRule(_localctx, 14, RULE_from_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(132);
match(FROM);
setState(133);
table_references();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Where_clauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(SQLParser.WHERE, 0); }
public Complex_boolean_expressionContext complex_boolean_expression() {
return getRuleContext(Complex_boolean_expressionContext.class,0);
}
public Where_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_where_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterWhere_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitWhere_clause(this);
}
}
public final Where_clauseContext where_clause() throws RecognitionException {
Where_clauseContext _localctx = new Where_clauseContext(_ctx, getState());
enterRule(_localctx, 16, RULE_where_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
match(WHERE);
setState(136);
complex_boolean_expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Group_clauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(SQLParser.GROUP, 0); }
public TerminalNode BY() { return getToken(SQLParser.BY, 0); }
public ExpressionsContext expressions() {
return getRuleContext(ExpressionsContext.class,0);
}
public Group_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_group_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterGroup_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitGroup_clause(this);
}
}
public final Group_clauseContext group_clause() throws RecognitionException {
Group_clauseContext _localctx = new Group_clauseContext(_ctx, getState());
enterRule(_localctx, 18, RULE_group_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(138);
match(GROUP);
setState(139);
match(BY);
setState(140);
expressions();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Having_clauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(SQLParser.HAVING, 0); }
public Complex_boolean_expressionContext complex_boolean_expression() {
return getRuleContext(Complex_boolean_expressionContext.class,0);
}
public Having_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_having_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterHaving_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitHaving_clause(this);
}
}
public final Having_clauseContext having_clause() throws RecognitionException {
Having_clauseContext _localctx = new Having_clauseContext(_ctx, getState());
enterRule(_localctx, 20, RULE_having_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(142);
match(HAVING);
setState(143);
complex_boolean_expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Order_clauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(SQLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(SQLParser.BY, 0); }
public Order_expressionsContext order_expressions() {
return getRuleContext(Order_expressionsContext.class,0);
}
public Order_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOrder_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOrder_clause(this);
}
}
public final Order_clauseContext order_clause() throws RecognitionException {
Order_clauseContext _localctx = new Order_clauseContext(_ctx, getState());
enterRule(_localctx, 22, RULE_order_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(145);
match(ORDER);
setState(146);
match(BY);
setState(147);
order_expressions();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OffsetContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(SQLParser.INT, 0); }
public OffsetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offset; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOffset(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOffset(this);
}
}
public final OffsetContext offset() throws RecognitionException {
OffsetContext _localctx = new OffsetContext(_ctx, getState());
enterRule(_localctx, 24, RULE_offset);
try {
enterOuterAlt(_localctx, 1);
{
setState(149);
match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Row_countContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(SQLParser.INT, 0); }
public Row_countContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_row_count; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterRow_count(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitRow_count(this);
}
}
public final Row_countContext row_count() throws RecognitionException {
Row_countContext _localctx = new Row_countContext(_ctx, getState());
enterRule(_localctx, 26, RULE_row_count);
try {
enterOuterAlt(_localctx, 1);
{
setState(151);
match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Limit_clauseContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(SQLParser.LIMIT, 0); }
public Row_countContext row_count() {
return getRuleContext(Row_countContext.class,0);
}
public TerminalNode OFFSET() { return getToken(SQLParser.OFFSET, 0); }
public OffsetContext offset() {
return getRuleContext(OffsetContext.class,0);
}
public TerminalNode COMMA() { return getToken(SQLParser.COMMA, 0); }
public Limit_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limit_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterLimit_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitLimit_clause(this);
}
}
public final Limit_clauseContext limit_clause() throws RecognitionException {
Limit_clauseContext _localctx = new Limit_clauseContext(_ctx, getState());
enterRule(_localctx, 28, RULE_limit_clause);
try {
enterOuterAlt(_localctx, 1);
{
setState(153);
match(LIMIT);
setState(164);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(157);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(154);
offset();
setState(155);
match(COMMA);
}
break;
}
setState(159);
row_count();
}
break;
case 2:
{
setState(160);
row_count();
setState(161);
match(OFFSET);
setState(162);
offset();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Alias_clauseContext extends ParserRuleContext {
public AliasContext alias() {
return getRuleContext(AliasContext.class,0);
}
public TerminalNode AS() { return getToken(SQLParser.AS, 0); }
public Alias_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alias_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAlias_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAlias_clause(this);
}
}
public final Alias_clauseContext alias_clause() throws RecognitionException {
Alias_clauseContext _localctx = new Alias_clauseContext(_ctx, getState());
enterRule(_localctx, 30, RULE_alias_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(167);
_la = _input.LA(1);
if (_la==AS) {
{
setState(166);
match(AS);
}
}
setState(169);
alias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Aliased_expressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public Alias_clauseContext alias_clause() {
return getRuleContext(Alias_clauseContext.class,0);
}
public Aliased_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliased_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAliased_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAliased_expression(this);
}
}
public final Aliased_expressionContext aliased_expression() throws RecognitionException {
Aliased_expressionContext _localctx = new Aliased_expressionContext(_ctx, getState());
enterRule(_localctx, 32, RULE_aliased_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(171);
expression(0);
setState(173);
_la = _input.LA(1);
if (_la==AS || _la==ID) {
{
setState(172);
alias_clause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_expressionContext extends ParserRuleContext {
public List aliased_expression() {
return getRuleContexts(Aliased_expressionContext.class);
}
public Aliased_expressionContext aliased_expression(int i) {
return getRuleContext(Aliased_expressionContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Select_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_expression(this);
}
}
public final Select_expressionContext select_expression() throws RecognitionException {
Select_expressionContext _localctx = new Select_expressionContext(_ctx, getState());
enterRule(_localctx, 34, RULE_select_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(175);
aliased_expression();
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(176);
match(COMMA);
setState(177);
aliased_expression();
}
}
setState(182);
_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 Columns_listContext extends ParserRuleContext {
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Columns_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_columns_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterColumns_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitColumns_list(this);
}
}
public final Columns_listContext columns_list() throws RecognitionException {
Columns_listContext _localctx = new Columns_listContext(_ctx, getState());
enterRule(_localctx, 36, RULE_columns_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
column_name();
setState(188);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(184);
match(COMMA);
setState(185);
column_name();
}
}
setState(190);
_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 Complex_boolean_expressionContext extends ParserRuleContext {
public Unary_boolean_operatorContext unary_boolean_operator() {
return getRuleContext(Unary_boolean_operatorContext.class,0);
}
public List complex_boolean_expression() {
return getRuleContexts(Complex_boolean_expressionContext.class);
}
public Complex_boolean_expressionContext complex_boolean_expression(int i) {
return getRuleContext(Complex_boolean_expressionContext.class,i);
}
public Simple_boolean_expressionContext simple_boolean_expression() {
return getRuleContext(Simple_boolean_expressionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(SQLParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(SQLParser.RPAREN, 0); }
public List binary_boolean_operator() {
return getRuleContexts(Binary_boolean_operatorContext.class);
}
public Binary_boolean_operatorContext binary_boolean_operator(int i) {
return getRuleContext(Binary_boolean_operatorContext.class,i);
}
public Complex_boolean_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_complex_boolean_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterComplex_boolean_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitComplex_boolean_expression(this);
}
}
public final Complex_boolean_expressionContext complex_boolean_expression() throws RecognitionException {
return complex_boolean_expression(0);
}
private Complex_boolean_expressionContext complex_boolean_expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
Complex_boolean_expressionContext _localctx = new Complex_boolean_expressionContext(_ctx, _parentState);
Complex_boolean_expressionContext _prevctx = _localctx;
int _startState = 38;
enterRecursionRule(_localctx, 38, RULE_complex_boolean_expression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(200);
switch (_input.LA(1)) {
case NOT:
{
setState(192);
unary_boolean_operator();
setState(193);
complex_boolean_expression(3);
}
break;
case MULTIPLY:
case PLUS:
case MINUS:
case BIT_NOT:
case NULL:
case TRUE:
case FALSE:
case INT:
case FLOAT:
case STRING:
case ID:
{
setState(195);
simple_boolean_expression();
}
break;
case LPAREN:
{
setState(196);
match(LPAREN);
setState(197);
complex_boolean_expression(0);
setState(198);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(212);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new Complex_boolean_expressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_complex_boolean_expression);
setState(202);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(206);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(203);
binary_boolean_operator();
setState(204);
complex_boolean_expression(0);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(208);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
}
setState(214);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExpressionsContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public ExpressionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterExpressions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitExpressions(this);
}
}
public final ExpressionsContext expressions() throws RecognitionException {
ExpressionsContext _localctx = new ExpressionsContext(_ctx, getState());
enterRule(_localctx, 40, RULE_expressions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(215);
expression(0);
setState(220);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(216);
match(COMMA);
setState(217);
expression(0);
}
}
setState(222);
_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 Order_expressionsContext extends ParserRuleContext {
public List order_expression() {
return getRuleContexts(Order_expressionContext.class);
}
public Order_expressionContext order_expression(int i) {
return getRuleContext(Order_expressionContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Order_expressionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_expressions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOrder_expressions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOrder_expressions(this);
}
}
public final Order_expressionsContext order_expressions() throws RecognitionException {
Order_expressionsContext _localctx = new Order_expressionsContext(_ctx, getState());
enterRule(_localctx, 42, RULE_order_expressions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(223);
order_expression();
setState(228);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(224);
match(COMMA);
setState(225);
order_expression();
}
}
setState(230);
_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 Order_expressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode ASC() { return getToken(SQLParser.ASC, 0); }
public TerminalNode DESC() { return getToken(SQLParser.DESC, 0); }
public Order_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOrder_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOrder_expression(this);
}
}
public final Order_expressionContext order_expression() throws RecognitionException {
Order_expressionContext _localctx = new Order_expressionContext(_ctx, getState());
enterRule(_localctx, 44, RULE_order_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
expression(0);
setState(233);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(232);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_callContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public TerminalNode LPAREN() { return getToken(SQLParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(SQLParser.RPAREN, 0); }
public ExpressionsContext expressions() {
return getRuleContext(ExpressionsContext.class,0);
}
public Function_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_call; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterFunction_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitFunction_call(this);
}
}
public final Function_callContext function_call() throws RecognitionException {
Function_callContext _localctx = new Function_callContext(_ctx, getState());
enterRule(_localctx, 46, RULE_function_call);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(235);
match(ID);
setState(236);
match(LPAREN);
setState(238);
_la = _input.LA(1);
if (((((_la - 23)) & ~0x3f) == 0 && ((1L << (_la - 23)) & ((1L << (MULTIPLY - 23)) | (1L << (PLUS - 23)) | (1L << (MINUS - 23)) | (1L << (BIT_NOT - 23)) | (1L << (NULL - 23)) | (1L << (TRUE - 23)) | (1L << (FALSE - 23)) | (1L << (INT - 23)) | (1L << (FLOAT - 23)) | (1L << (STRING - 23)) | (1L << (ID - 23)))) != 0)) {
{
setState(237);
expressions();
}
}
setState(240);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(SQLParser.STRING, 0); }
public TerminalNode INT() { return getToken(SQLParser.INT, 0); }
public TerminalNode FLOAT() { return getToken(SQLParser.FLOAT, 0); }
public TerminalNode TRUE() { return getToken(SQLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SQLParser.FALSE, 0); }
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 48, RULE_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(242);
_la = _input.LA(1);
if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (NULL - 62)) | (1L << (TRUE - 62)) | (1L << (FALSE - 62)) | (1L << (INT - 62)) | (1L << (FLOAT - 62)) | (1L << (STRING - 62)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
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 Unary_arithmetic_operatorContext unary_arithmetic_operator() {
return getRuleContext(Unary_arithmetic_operatorContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public Function_callContext function_call() {
return getRuleContext(Function_callContext.class,0);
}
public Binary_arithmetic_operatorContext binary_arithmetic_operator() {
return getRuleContext(Binary_arithmetic_operatorContext.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 SQLParserListener ) ((SQLParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 50;
enterRecursionRule(_localctx, 50, RULE_expression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(251);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(245);
unary_arithmetic_operator();
setState(246);
expression(1);
}
break;
case 2:
{
setState(248);
literal();
}
break;
case 3:
{
setState(249);
column_name();
}
break;
case 4:
{
setState(250);
function_call();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(259);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(253);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(254);
binary_arithmetic_operator();
setState(255);
expression(3);
}
}
}
setState(261);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Relational_operatorContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(SQLParser.EQ, 0); }
public TerminalNode LT() { return getToken(SQLParser.LT, 0); }
public TerminalNode GT() { return getToken(SQLParser.GT, 0); }
public TerminalNode NOT_EQ() { return getToken(SQLParser.NOT_EQ, 0); }
public TerminalNode LTE() { return getToken(SQLParser.LTE, 0); }
public TerminalNode GTE() { return getToken(SQLParser.GTE, 0); }
public Relational_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relational_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterRelational_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitRelational_operator(this);
}
}
public final Relational_operatorContext relational_operator() throws RecognitionException {
Relational_operatorContext _localctx = new Relational_operatorContext(_ctx, getState());
enterRule(_localctx, 52, RULE_relational_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(262);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << LT) | (1L << GT) | (1L << NOT_EQ) | (1L << LTE) | (1L << GTE))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Binary_arithmetic_operatorContext extends ParserRuleContext {
public TerminalNode PLUS() { return getToken(SQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLParser.MINUS, 0); }
public TerminalNode MULTIPLY() { return getToken(SQLParser.MULTIPLY, 0); }
public TerminalNode DIVIDE() { return getToken(SQLParser.DIVIDE, 0); }
public TerminalNode MOD() { return getToken(SQLParser.MOD, 0); }
public TerminalNode BIT_AND() { return getToken(SQLParser.BIT_AND, 0); }
public TerminalNode BIT_OR() { return getToken(SQLParser.BIT_OR, 0); }
public TerminalNode BIT_XOR() { return getToken(SQLParser.BIT_XOR, 0); }
public TerminalNode SHIFT_LEFT() { return getToken(SQLParser.SHIFT_LEFT, 0); }
public TerminalNode SHIFT_RIGHT() { return getToken(SQLParser.SHIFT_RIGHT, 0); }
public Binary_arithmetic_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binary_arithmetic_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterBinary_arithmetic_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitBinary_arithmetic_operator(this);
}
}
public final Binary_arithmetic_operatorContext binary_arithmetic_operator() throws RecognitionException {
Binary_arithmetic_operatorContext _localctx = new Binary_arithmetic_operatorContext(_ctx, getState());
enterRule(_localctx, 54, RULE_binary_arithmetic_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(264);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MULTIPLY) | (1L << DIVIDE) | (1L << MOD) | (1L << PLUS) | (1L << MINUS) | (1L << BIT_OR) | (1L << BIT_AND) | (1L << BIT_XOR) | (1L << SHIFT_LEFT) | (1L << SHIFT_RIGHT))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_arithmetic_operatorContext extends ParserRuleContext {
public TerminalNode PLUS() { return getToken(SQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLParser.MINUS, 0); }
public TerminalNode BIT_NOT() { return getToken(SQLParser.BIT_NOT, 0); }
public Unary_arithmetic_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_arithmetic_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterUnary_arithmetic_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitUnary_arithmetic_operator(this);
}
}
public final Unary_arithmetic_operatorContext unary_arithmetic_operator() throws RecognitionException {
Unary_arithmetic_operatorContext _localctx = new Unary_arithmetic_operatorContext(_ctx, getState());
enterRule(_localctx, 56, RULE_unary_arithmetic_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(266);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << BIT_NOT))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Binary_boolean_operatorContext extends ParserRuleContext {
public TerminalNode AND() { return getToken(SQLParser.AND, 0); }
public TerminalNode XOR() { return getToken(SQLParser.XOR, 0); }
public TerminalNode OR() { return getToken(SQLParser.OR, 0); }
public Binary_boolean_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binary_boolean_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterBinary_boolean_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitBinary_boolean_operator(this);
}
}
public final Binary_boolean_operatorContext binary_boolean_operator() throws RecognitionException {
Binary_boolean_operatorContext _localctx = new Binary_boolean_operatorContext(_ctx, getState());
enterRule(_localctx, 58, RULE_binary_boolean_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(268);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AND) | (1L << OR) | (1L << XOR))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_boolean_operatorContext extends ParserRuleContext {
public TerminalNode NOT() { return getToken(SQLParser.NOT, 0); }
public Unary_boolean_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_boolean_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterUnary_boolean_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitUnary_boolean_operator(this);
}
}
public final Unary_boolean_operatorContext unary_boolean_operator() throws RecognitionException {
Unary_boolean_operatorContext _localctx = new Unary_boolean_operatorContext(_ctx, getState());
enterRule(_localctx, 60, RULE_unary_boolean_operator);
try {
enterOuterAlt(_localctx, 1);
{
setState(270);
match(NOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Simple_boolean_expressionContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public Relational_operatorContext relational_operator() {
return getRuleContext(Relational_operatorContext.class,0);
}
public TerminalNode BETWEEN() { return getToken(SQLParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(SQLParser.AND, 0); }
public TerminalNode NOT() { return getToken(SQLParser.NOT, 0); }
public TerminalNode IS() { return getToken(SQLParser.IS, 0); }
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public TerminalNode LIKE() { return getToken(SQLParser.LIKE, 0); }
public TerminalNode REGEXP() { return getToken(SQLParser.REGEXP, 0); }
public TerminalNode IN() { return getToken(SQLParser.IN, 0); }
public TerminalNode LPAREN() { return getToken(SQLParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(SQLParser.RPAREN, 0); }
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public TerminalNode TRUE() { return getToken(SQLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SQLParser.FALSE, 0); }
public Simple_boolean_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_boolean_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSimple_boolean_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSimple_boolean_expression(this);
}
}
public final Simple_boolean_expressionContext simple_boolean_expression() throws RecognitionException {
Simple_boolean_expressionContext _localctx = new Simple_boolean_expressionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_simple_boolean_expression);
int _la;
try {
setState(324);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(272);
expression(0);
setState(273);
relational_operator();
setState(274);
expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(276);
expression(0);
setState(278);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(277);
match(NOT);
}
}
setState(280);
match(BETWEEN);
setState(281);
expression(0);
setState(282);
match(AND);
setState(283);
expression(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(285);
expression(0);
setState(286);
match(IS);
setState(288);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(287);
match(NOT);
}
}
setState(290);
match(NULL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(292);
expression(0);
setState(294);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(293);
match(NOT);
}
}
setState(296);
match(LIKE);
setState(297);
expression(0);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(299);
expression(0);
setState(301);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(300);
match(NOT);
}
}
setState(303);
match(REGEXP);
setState(304);
expression(0);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(306);
expression(0);
setState(308);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(307);
match(NOT);
}
}
setState(310);
match(IN);
setState(311);
match(LPAREN);
setState(312);
expression(0);
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(313);
match(COMMA);
setState(314);
expression(0);
}
}
setState(319);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(320);
match(RPAREN);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(322);
match(TRUE);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(323);
match(FALSE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_referencesContext extends ParserRuleContext {
public List table_reference() {
return getRuleContexts(Table_referenceContext.class);
}
public Table_referenceContext table_reference(int i) {
return getRuleContext(Table_referenceContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Table_referencesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_references; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_references(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_references(this);
}
}
public final Table_referencesContext table_references() throws RecognitionException {
Table_referencesContext _localctx = new Table_referencesContext(_ctx, getState());
enterRule(_localctx, 64, RULE_table_references);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
table_reference();
setState(331);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(327);
match(COMMA);
setState(328);
table_reference();
}
}
setState(333);
_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 Table_referenceContext extends ParserRuleContext {
public Table_atomContext table_atom() {
return getRuleContext(Table_atomContext.class,0);
}
public Table_joinContext table_join() {
return getRuleContext(Table_joinContext.class,0);
}
public Table_referenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_reference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_reference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_reference(this);
}
}
public final Table_referenceContext table_reference() throws RecognitionException {
Table_referenceContext _localctx = new Table_referenceContext(_ctx, getState());
enterRule(_localctx, 66, RULE_table_reference);
try {
setState(336);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(334);
table_atom();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(335);
table_join();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_joinContext extends ParserRuleContext {
public Table_atomContext table_atom() {
return getRuleContext(Table_atomContext.class,0);
}
public List join_clause() {
return getRuleContexts(Join_clauseContext.class);
}
public Join_clauseContext join_clause(int i) {
return getRuleContext(Join_clauseContext.class,i);
}
public Table_joinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_join; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_join(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_join(this);
}
}
public final Table_joinContext table_join() throws RecognitionException {
Table_joinContext _localctx = new Table_joinContext(_ctx, getState());
enterRule(_localctx, 68, RULE_table_join);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(338);
table_atom();
setState(340);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(339);
join_clause();
}
}
setState(342);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INNER) | (1L << JOIN) | (1L << CROSS) | (1L << NATURAL) | (1L << LEFT) | (1L << RIGHT))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Inner_join_clauseContext extends ParserRuleContext {
public TerminalNode JOIN() { return getToken(SQLParser.JOIN, 0); }
public Table_atomContext table_atom() {
return getRuleContext(Table_atomContext.class,0);
}
public Join_conditionContext join_condition() {
return getRuleContext(Join_conditionContext.class,0);
}
public TerminalNode INNER() { return getToken(SQLParser.INNER, 0); }
public TerminalNode CROSS() { return getToken(SQLParser.CROSS, 0); }
public Inner_join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inner_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterInner_join_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitInner_join_clause(this);
}
}
public final Inner_join_clauseContext inner_join_clause() throws RecognitionException {
Inner_join_clauseContext _localctx = new Inner_join_clauseContext(_ctx, getState());
enterRule(_localctx, 70, RULE_inner_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(345);
_la = _input.LA(1);
if (_la==INNER || _la==CROSS) {
{
setState(344);
_la = _input.LA(1);
if ( !(_la==INNER || _la==CROSS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(347);
match(JOIN);
setState(348);
table_atom();
setState(350);
_la = _input.LA(1);
if (_la==USING || _la==ON) {
{
setState(349);
join_condition();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Outer_join_clauseContext extends ParserRuleContext {
public TerminalNode JOIN() { return getToken(SQLParser.JOIN, 0); }
public Table_atomContext table_atom() {
return getRuleContext(Table_atomContext.class,0);
}
public Join_conditionContext join_condition() {
return getRuleContext(Join_conditionContext.class,0);
}
public TerminalNode LEFT() { return getToken(SQLParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(SQLParser.RIGHT, 0); }
public TerminalNode OUTER() { return getToken(SQLParser.OUTER, 0); }
public Outer_join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outer_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOuter_join_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOuter_join_clause(this);
}
}
public final Outer_join_clauseContext outer_join_clause() throws RecognitionException {
Outer_join_clauseContext _localctx = new Outer_join_clauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_outer_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(352);
_la = _input.LA(1);
if ( !(_la==LEFT || _la==RIGHT) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(354);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(353);
match(OUTER);
}
}
setState(356);
match(JOIN);
setState(357);
table_atom();
setState(358);
join_condition();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Natural_join_clauseContext extends ParserRuleContext {
public TerminalNode NATURAL() { return getToken(SQLParser.NATURAL, 0); }
public TerminalNode JOIN() { return getToken(SQLParser.JOIN, 0); }
public Table_atomContext table_atom() {
return getRuleContext(Table_atomContext.class,0);
}
public TerminalNode OUTER() { return getToken(SQLParser.OUTER, 0); }
public TerminalNode LEFT() { return getToken(SQLParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(SQLParser.RIGHT, 0); }
public Natural_join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_natural_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterNatural_join_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitNatural_join_clause(this);
}
}
public final Natural_join_clauseContext natural_join_clause() throws RecognitionException {
Natural_join_clauseContext _localctx = new Natural_join_clauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_natural_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
match(NATURAL);
setState(362);
_la = _input.LA(1);
if (_la==LEFT || _la==RIGHT) {
{
setState(361);
_la = _input.LA(1);
if ( !(_la==LEFT || _la==RIGHT) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(365);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(364);
match(OUTER);
}
}
setState(367);
match(JOIN);
setState(368);
table_atom();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_clauseContext extends ParserRuleContext {
public Inner_join_clauseContext inner_join_clause() {
return getRuleContext(Inner_join_clauseContext.class,0);
}
public Outer_join_clauseContext outer_join_clause() {
return getRuleContext(Outer_join_clauseContext.class,0);
}
public Natural_join_clauseContext natural_join_clause() {
return getRuleContext(Natural_join_clauseContext.class,0);
}
public Join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterJoin_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitJoin_clause(this);
}
}
public final Join_clauseContext join_clause() throws RecognitionException {
Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState());
enterRule(_localctx, 76, RULE_join_clause);
try {
setState(373);
switch (_input.LA(1)) {
case INNER:
case JOIN:
case CROSS:
enterOuterAlt(_localctx, 1);
{
setState(370);
inner_join_clause();
}
break;
case LEFT:
case RIGHT:
enterOuterAlt(_localctx, 2);
{
setState(371);
outer_join_clause();
}
break;
case NATURAL:
enterOuterAlt(_localctx, 3);
{
setState(372);
natural_join_clause();
}
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 Table_atomContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Alias_clauseContext alias_clause() {
return getRuleContext(Alias_clauseContext.class,0);
}
public TerminalNode LPAREN() { return getToken(SQLParser.LPAREN, 0); }
public Table_referencesContext table_references() {
return getRuleContext(Table_referencesContext.class,0);
}
public TerminalNode RPAREN() { return getToken(SQLParser.RPAREN, 0); }
public Table_atomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_atom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_atom(this);
}
}
public final Table_atomContext table_atom() throws RecognitionException {
Table_atomContext _localctx = new Table_atomContext(_ctx, getState());
enterRule(_localctx, 78, RULE_table_atom);
int _la;
try {
setState(383);
switch (_input.LA(1)) {
case ID:
enterOuterAlt(_localctx, 1);
{
setState(375);
table_name();
setState(377);
_la = _input.LA(1);
if (_la==AS || _la==ID) {
{
setState(376);
alias_clause();
}
}
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(379);
match(LPAREN);
setState(380);
table_references();
setState(381);
match(RPAREN);
}
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 Join_conditionContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(SQLParser.ON, 0); }
public Complex_boolean_expressionContext complex_boolean_expression() {
return getRuleContext(Complex_boolean_expressionContext.class,0);
}
public TerminalNode USING() { return getToken(SQLParser.USING, 0); }
public TerminalNode LPAREN() { return getToken(SQLParser.LPAREN, 0); }
public Columns_listContext columns_list() {
return getRuleContext(Columns_listContext.class,0);
}
public TerminalNode RPAREN() { return getToken(SQLParser.RPAREN, 0); }
public Join_conditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_condition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterJoin_condition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitJoin_condition(this);
}
}
public final Join_conditionContext join_condition() throws RecognitionException {
Join_conditionContext _localctx = new Join_conditionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_join_condition);
try {
setState(392);
switch (_input.LA(1)) {
case ON:
enterOuterAlt(_localctx, 1);
{
setState(385);
match(ON);
setState(386);
complex_boolean_expression(0);
}
break;
case USING:
enterOuterAlt(_localctx, 2);
{
setState(387);
match(USING);
setState(388);
match(LPAREN);
setState(389);
columns_list();
setState(390);
match(RPAREN);
}
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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 19:
return complex_boolean_expression_sempred((Complex_boolean_expressionContext)_localctx, predIndex);
case 25:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean complex_boolean_expression_sempred(Complex_boolean_expressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 2);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3H\u018d\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\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\3\2\3\2"+
"\5\2W\n\2\3\3\3\3\3\4\3\4\3\5\3\5\3\5\5\5`\n\5\3\5\3\5\3\5\3\5\5\5f\n"+
"\5\3\5\5\5i\n\5\3\6\3\6\3\6\3\7\3\7\5\7p\n\7\3\7\5\7s\n\7\3\7\5\7v\n\7"+
"\3\7\5\7y\n\7\3\7\5\7|\n\7\3\7\5\7\177\n\7\3\7\5\7\u0082\n\7\3\b\3\b\3"+
"\b\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r"+
"\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u00a0\n\20\3\20\3\20"+
"\3\20\3\20\3\20\5\20\u00a7\n\20\3\21\5\21\u00aa\n\21\3\21\3\21\3\22\3"+
"\22\5\22\u00b0\n\22\3\23\3\23\3\23\7\23\u00b5\n\23\f\23\16\23\u00b8\13"+
"\23\3\24\3\24\3\24\7\24\u00bd\n\24\f\24\16\24\u00c0\13\24\3\25\3\25\3"+
"\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u00cb\n\25\3\25\3\25\3\25\3\25"+
"\6\25\u00d1\n\25\r\25\16\25\u00d2\7\25\u00d5\n\25\f\25\16\25\u00d8\13"+
"\25\3\26\3\26\3\26\7\26\u00dd\n\26\f\26\16\26\u00e0\13\26\3\27\3\27\3"+
"\27\7\27\u00e5\n\27\f\27\16\27\u00e8\13\27\3\30\3\30\5\30\u00ec\n\30\3"+
"\31\3\31\3\31\5\31\u00f1\n\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33"+
"\3\33\3\33\3\33\5\33\u00fe\n\33\3\33\3\33\3\33\3\33\7\33\u0104\n\33\f"+
"\33\16\33\u0107\13\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3 \3 \3"+
"!\3!\3!\3!\3!\3!\5!\u0119\n!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0123\n!\3!\3"+
"!\3!\3!\5!\u0129\n!\3!\3!\3!\3!\3!\5!\u0130\n!\3!\3!\3!\3!\3!\5!\u0137"+
"\n!\3!\3!\3!\3!\3!\7!\u013e\n!\f!\16!\u0141\13!\3!\3!\3!\3!\5!\u0147\n"+
"!\3\"\3\"\3\"\7\"\u014c\n\"\f\"\16\"\u014f\13\"\3#\3#\5#\u0153\n#\3$\3"+
"$\6$\u0157\n$\r$\16$\u0158\3%\5%\u015c\n%\3%\3%\3%\5%\u0161\n%\3&\3&\5"+
"&\u0165\n&\3&\3&\3&\3&\3\'\3\'\5\'\u016d\n\'\3\'\5\'\u0170\n\'\3\'\3\'"+
"\3\'\3(\3(\3(\5(\u0178\n(\3)\3)\5)\u017c\n)\3)\3)\3)\3)\5)\u0182\n)\3"+
"*\3*\3*\3*\3*\3*\3*\5*\u018b\n*\3*\2\4(\64+\2\4\6\b\n\f\16\20\22\24\26"+
"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPR\2\13\4\2\31\31FF\3\2\64"+
"\65\3\2@E\3\2\23\30\4\2\31\35 $\4\2\34\35\37\37\3\2\b\n\4\2..\61\61\3"+
"\2=>\u019a\2V\3\2\2\2\4X\3\2\2\2\6Z\3\2\2\2\bh\3\2\2\2\nj\3\2\2\2\fm\3"+
"\2\2\2\16\u0083\3\2\2\2\20\u0086\3\2\2\2\22\u0089\3\2\2\2\24\u008c\3\2"+
"\2\2\26\u0090\3\2\2\2\30\u0093\3\2\2\2\32\u0097\3\2\2\2\34\u0099\3\2\2"+
"\2\36\u009b\3\2\2\2 \u00a9\3\2\2\2\"\u00ad\3\2\2\2$\u00b1\3\2\2\2&\u00b9"+
"\3\2\2\2(\u00ca\3\2\2\2*\u00d9\3\2\2\2,\u00e1\3\2\2\2.\u00e9\3\2\2\2\60"+
"\u00ed\3\2\2\2\62\u00f4\3\2\2\2\64\u00fd\3\2\2\2\66\u0108\3\2\2\28\u010a"+
"\3\2\2\2:\u010c\3\2\2\2<\u010e\3\2\2\2>\u0110\3\2\2\2@\u0146\3\2\2\2B"+
"\u0148\3\2\2\2D\u0152\3\2\2\2F\u0154\3\2\2\2H\u015b\3\2\2\2J\u0162\3\2"+
"\2\2L\u016a\3\2\2\2N\u0177\3\2\2\2P\u0181\3\2\2\2R\u018a\3\2\2\2TW\5\f"+
"\7\2UW\5\n\6\2VT\3\2\2\2VU\3\2\2\2W\3\3\2\2\2XY\7F\2\2Y\5\3\2\2\2Z[\7"+
"F\2\2[\7\3\2\2\2\\]\5\4\3\2]^\7-\2\2^`\3\2\2\2_\\\3\2\2\2_`\3\2\2\2`a"+
"\3\2\2\2ai\t\2\2\2bc\5\6\4\2cd\7-\2\2df\3\2\2\2eb\3\2\2\2ef\3\2\2\2fg"+
"\3\2\2\2gi\t\2\2\2h_\3\2\2\2he\3\2\2\2i\t\3\2\2\2jk\7\3\2\2kl\5\f\7\2"+
"l\13\3\2\2\2mo\5\16\b\2np\5\20\t\2on\3\2\2\2op\3\2\2\2pr\3\2\2\2qs\5\22"+
"\n\2rq\3\2\2\2rs\3\2\2\2su\3\2\2\2tv\5\24\13\2ut\3\2\2\2uv\3\2\2\2vx\3"+
"\2\2\2wy\5\26\f\2xw\3\2\2\2xy\3\2\2\2y{\3\2\2\2z|\5\30\r\2{z\3\2\2\2{"+
"|\3\2\2\2|~\3\2\2\2}\177\5\36\20\2~}\3\2\2\2~\177\3\2\2\2\177\u0081\3"+
"\2\2\2\u0080\u0082\7+\2\2\u0081\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082"+
"\r\3\2\2\2\u0083\u0084\7\4\2\2\u0084\u0085\5$\23\2\u0085\17\3\2\2\2\u0086"+
"\u0087\7\5\2\2\u0087\u0088\5B\"\2\u0088\21\3\2\2\2\u0089\u008a\7\7\2\2"+
"\u008a\u008b\5(\25\2\u008b\23\3\2\2\2\u008c\u008d\7\66\2\2\u008d\u008e"+
"\7:\2\2\u008e\u008f\5*\26\2\u008f\25\3\2\2\2\u0090\u0091\7\67\2\2\u0091"+
"\u0092\5(\25\2\u0092\27\3\2\2\2\u0093\u0094\7\63\2\2\u0094\u0095\7:\2"+
"\2\u0095\u0096\5,\27\2\u0096\31\3\2\2\2\u0097\u0098\7C\2\2\u0098\33\3"+
"\2\2\2\u0099\u009a\7C\2\2\u009a\35\3\2\2\2\u009b\u00a6\78\2\2\u009c\u009d"+
"\5\32\16\2\u009d\u009e\7,\2\2\u009e\u00a0\3\2\2\2\u009f\u009c\3\2\2\2"+
"\u009f\u00a0\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a7\5\34\17\2\u00a2\u00a3"+
"\5\34\17\2\u00a3\u00a4\79\2\2\u00a4\u00a5\5\32\16\2\u00a5\u00a7\3\2\2"+
"\2\u00a6\u009f\3\2\2\2\u00a6\u00a2\3\2\2\2\u00a7\37\3\2\2\2\u00a8\u00aa"+
"\7\6\2\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab"+
"\u00ac\5\6\4\2\u00ac!\3\2\2\2\u00ad\u00af\5\64\33\2\u00ae\u00b0\5 \21"+
"\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0#\3\2\2\2\u00b1\u00b6"+
"\5\"\22\2\u00b2\u00b3\7,\2\2\u00b3\u00b5\5\"\22\2\u00b4\u00b2\3\2\2\2"+
"\u00b5\u00b8\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7%\3"+
"\2\2\2\u00b8\u00b6\3\2\2\2\u00b9\u00be\5\b\5\2\u00ba\u00bb\7,\2\2\u00bb"+
"\u00bd\5\b\5\2\u00bc\u00ba\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2"+
"\2\2\u00be\u00bf\3\2\2\2\u00bf\'\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c2"+
"\b\25\1\2\u00c2\u00c3\5> \2\u00c3\u00c4\5(\25\5\u00c4\u00cb\3\2\2\2\u00c5"+
"\u00cb\5@!\2\u00c6\u00c7\7*\2\2\u00c7\u00c8\5(\25\2\u00c8\u00c9\7)\2\2"+
"\u00c9\u00cb\3\2\2\2\u00ca\u00c1\3\2\2\2\u00ca\u00c5\3\2\2\2\u00ca\u00c6"+
"\3\2\2\2\u00cb\u00d6\3\2\2\2\u00cc\u00d0\f\4\2\2\u00cd\u00ce\5<\37\2\u00ce"+
"\u00cf\5(\25\2\u00cf\u00d1\3\2\2\2\u00d0\u00cd\3\2\2\2\u00d1\u00d2\3\2"+
"\2\2\u00d2\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2\2\2\u00d4"+
"\u00cc\3\2\2\2\u00d5\u00d8\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d6\u00d7\3\2"+
"\2\2\u00d7)\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d9\u00de\5\64\33\2\u00da\u00db"+
"\7,\2\2\u00db\u00dd\5\64\33\2\u00dc\u00da\3\2\2\2\u00dd\u00e0\3\2\2\2"+
"\u00de\u00dc\3\2\2\2\u00de\u00df\3\2\2\2\u00df+\3\2\2\2\u00e0\u00de\3"+
"\2\2\2\u00e1\u00e6\5.\30\2\u00e2\u00e3\7,\2\2\u00e3\u00e5\5.\30\2\u00e4"+
"\u00e2\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e7\3\2"+
"\2\2\u00e7-\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u00eb\5\64\33\2\u00ea\u00ec"+
"\t\3\2\2\u00eb\u00ea\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec/\3\2\2\2\u00ed"+
"\u00ee\7F\2\2\u00ee\u00f0\7*\2\2\u00ef\u00f1\5*\26\2\u00f0\u00ef\3\2\2"+
"\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\7)\2\2\u00f3\61"+
"\3\2\2\2\u00f4\u00f5\t\4\2\2\u00f5\63\3\2\2\2\u00f6\u00f7\b\33\1\2\u00f7"+
"\u00f8\5:\36\2\u00f8\u00f9\5\64\33\3\u00f9\u00fe\3\2\2\2\u00fa\u00fe\5"+
"\62\32\2\u00fb\u00fe\5\b\5\2\u00fc\u00fe\5\60\31\2\u00fd\u00f6\3\2\2\2"+
"\u00fd\u00fa\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0105"+
"\3\2\2\2\u00ff\u0100\f\4\2\2\u0100\u0101\58\35\2\u0101\u0102\5\64\33\5"+
"\u0102\u0104\3\2\2\2\u0103\u00ff\3\2\2\2\u0104\u0107\3\2\2\2\u0105\u0103"+
"\3\2\2\2\u0105\u0106\3\2\2\2\u0106\65\3\2\2\2\u0107\u0105\3\2\2\2\u0108"+
"\u0109\t\5\2\2\u0109\67\3\2\2\2\u010a\u010b\t\6\2\2\u010b9\3\2\2\2\u010c"+
"\u010d\t\7\2\2\u010d;\3\2\2\2\u010e\u010f\t\b\2\2\u010f=\3\2\2\2\u0110"+
"\u0111\7\22\2\2\u0111?\3\2\2\2\u0112\u0113\5\64\33\2\u0113\u0114\5\66"+
"\34\2\u0114\u0115\5\64\33\2\u0115\u0147\3\2\2\2\u0116\u0118\5\64\33\2"+
"\u0117\u0119\7\22\2\2\u0118\u0117\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011a"+
"\3\2\2\2\u011a\u011b\7\17\2\2\u011b\u011c\5\64\33\2\u011c\u011d\7\b\2"+
"\2\u011d\u011e\5\64\33\2\u011e\u0147\3\2\2\2\u011f\u0120\5\64\33\2\u0120"+
"\u0122\7\13\2\2\u0121\u0123\7\22\2\2\u0122\u0121\3\2\2\2\u0122\u0123\3"+
"\2\2\2\u0123\u0124\3\2\2\2\u0124\u0125\7@\2\2\u0125\u0147\3\2\2\2\u0126"+
"\u0128\5\64\33\2\u0127\u0129\7\22\2\2\u0128\u0127\3\2\2\2\u0128\u0129"+
"\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012b\7\f\2\2\u012b\u012c\5\64\33\2"+
"\u012c\u0147\3\2\2\2\u012d\u012f\5\64\33\2\u012e\u0130\7\22\2\2\u012f"+
"\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\7\36"+
"\2\2\u0132\u0133\5\64\33\2\u0133\u0147\3\2\2\2\u0134\u0136\5\64\33\2\u0135"+
"\u0137\7\22\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138\3"+
"\2\2\2\u0138\u0139\7\r\2\2\u0139\u013a\7*\2\2\u013a\u013f\5\64\33\2\u013b"+
"\u013c\7,\2\2\u013c\u013e\5\64\33\2\u013d\u013b\3\2\2\2\u013e\u0141\3"+
"\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0142\3\2\2\2\u0141"+
"\u013f\3\2\2\2\u0142\u0143\7)\2\2\u0143\u0147\3\2\2\2\u0144\u0147\7A\2"+
"\2\u0145\u0147\7B\2\2\u0146\u0112\3\2\2\2\u0146\u0116\3\2\2\2\u0146\u011f"+
"\3\2\2\2\u0146\u0126\3\2\2\2\u0146\u012d\3\2\2\2\u0146\u0134\3\2\2\2\u0146"+
"\u0144\3\2\2\2\u0146\u0145\3\2\2\2\u0147A\3\2\2\2\u0148\u014d\5D#\2\u0149"+
"\u014a\7,\2\2\u014a\u014c\5D#\2\u014b\u0149\3\2\2\2\u014c\u014f\3\2\2"+
"\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014eC\3\2\2\2\u014f\u014d"+
"\3\2\2\2\u0150\u0153\5P)\2\u0151\u0153\5F$\2\u0152\u0150\3\2\2\2\u0152"+
"\u0151\3\2\2\2\u0153E\3\2\2\2\u0154\u0156\5P)\2\u0155\u0157\5N(\2\u0156"+
"\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0159\3\2"+
"\2\2\u0159G\3\2\2\2\u015a\u015c\t\t\2\2\u015b\u015a\3\2\2\2\u015b\u015c"+
"\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\7\60\2\2\u015e\u0160\5P)\2\u015f"+
"\u0161\5R*\2\u0160\u015f\3\2\2\2\u0160\u0161\3\2\2\2\u0161I\3\2\2\2\u0162"+
"\u0164\t\n\2\2\u0163\u0165\7/\2\2\u0164\u0163\3\2\2\2\u0164\u0165\3\2"+
"\2\2\u0165\u0166\3\2\2\2\u0166\u0167\7\60\2\2\u0167\u0168\5P)\2\u0168"+
"\u0169\5R*\2\u0169K\3\2\2\2\u016a\u016c\7<\2\2\u016b\u016d\t\n\2\2\u016c"+
"\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016f\3\2\2\2\u016e\u0170\7/"+
"\2\2\u016f\u016e\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0171\3\2\2\2\u0171"+
"\u0172\7\60\2\2\u0172\u0173\5P)\2\u0173M\3\2\2\2\u0174\u0178\5H%\2\u0175"+
"\u0178\5J&\2\u0176\u0178\5L\'\2\u0177\u0174\3\2\2\2\u0177\u0175\3\2\2"+
"\2\u0177\u0176\3\2\2\2\u0178O\3\2\2\2\u0179\u017b\5\4\3\2\u017a\u017c"+
"\5 \21\2\u017b\u017a\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u0182\3\2\2\2\u017d"+
"\u017e\7*\2\2\u017e\u017f\5B\"\2\u017f\u0180\7)\2\2\u0180\u0182\3\2\2"+
"\2\u0181\u0179\3\2\2\2\u0181\u017d\3\2\2\2\u0182Q\3\2\2\2\u0183\u0184"+
"\7?\2\2\u0184\u018b\5(\25\2\u0185\u0186\7\62\2\2\u0186\u0187\7*\2\2\u0187"+
"\u0188\5&\24\2\u0188\u0189\7)\2\2\u0189\u018b\3\2\2\2\u018a\u0183\3\2"+
"\2\2\u018a\u0185\3\2\2\2\u018bS\3\2\2\2/V_ehorux{~\u0081\u009f\u00a6\u00a9"+
"\u00af\u00b6\u00be\u00ca\u00d2\u00d6\u00de\u00e6\u00eb\u00f0\u00fd\u0105"+
"\u0118\u0122\u0128\u012f\u0136\u013f\u0146\u014d\u0152\u0158\u015b\u0160"+
"\u0164\u016c\u016f\u0177\u017b\u0181\u018a";
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