com.blazebit.persistence.parser.SQLParser Maven / Gradle / Ivy
The newest version!
// Generated from com\blazebit\persistence\parser\SQLParser.g4 by ANTLR 4.7.2
package com.blazebit.persistence.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SQLParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
ALL=1, AND=2, ANY=3, AS=4, ASC=5, BETWEEN=6, BY=7, CASE=8, COLLATE=9,
CONVERT=10, CROSS=11, CURRENT=12, CURRENT_DATE=13, CURRENT_TIME=14, CURRENT_TIMESTAMP=15,
CURRENT_USER=16, DESC=17, DISTINCT=18, DOUBLE=19, ELSE=20, END=21, ESCAPE=22,
EXCEPT=23, EXISTS=24, FETCH=25, FROM=26, FULL=27, GROUP=28, HAVING=29,
IDENTITY=30, IIF=31, IN=32, INNER=33, INTERSECT=34, IS=35, JOIN=36, LEFT=37,
LIKE=38, NOT=39, NULL=40, ON=41, OR=42, ORDER=43, OUTER=44, OVER=45, PERCENT=46,
PRECISION=47, RIGHT=48, SELECT=49, SESSION_USER=50, SET=51, SOME=52, SYSTEM_USER=53,
THEN=54, TOP=55, UNION=56, VALUES=57, WHEN=58, WHERE=59, WITH=60, WITHIN=61,
APPLY=62, CAST=63, COUNT=64, COUNT_BIG=65, DATEADD=66, DATEDIFF=67, DATENAME=68,
DATEPART=69, FIRST=70, FOLLOWING=71, MAX=72, MIN_ACTIVE_ROWVERSION=73,
NEXT=74, OFFSET=75, ONLY=76, PARTITION=77, PRECEDING=78, RANGE=79, ROW=80,
ROWGUID=81, ROWS=82, TIES=83, UNBOUNDED=84, SPACE=85, COMMENT=86, LINE_COMMENT=87,
DOUBLE_QUOTE_ID=88, SINGLE_QUOTE=89, SQUARE_BRACKET_ID=90, DECIMAL=91,
ID=92, STRING=93, BINARY=94, FLOAT=95, REAL=96, EQUAL=97, GREATER=98,
LESS=99, EXCLAMATION=100, PLUS_ASSIGN=101, MINUS_ASSIGN=102, MULT_ASSIGN=103,
DIV_ASSIGN=104, MOD_ASSIGN=105, AND_ASSIGN=106, XOR_ASSIGN=107, OR_ASSIGN=108,
DOUBLE_BAR=109, DOT=110, DOLLAR=111, LR_BRACKET=112, RR_BRACKET=113, COMMA=114,
STAR=115, DIVIDE=116, MODULE=117, PLUS=118, MINUS=119, BIT_NOT=120, BIT_OR=121,
BIT_AND=122, BIT_XOR=123, PARAM=124, IPV4_OCTECT=125, LIMIT=126;
public static final int
RULE_parseSelectStatement = 0, RULE_parseFrom = 1, RULE_expression = 2,
RULE_primitive_expression = 3, RULE_case_expression = 4, RULE_unary_operator_expression = 5,
RULE_bracket_expression = 6, RULE_constant_expression = 7, RULE_select_statement = 8,
RULE_subquery = 9, RULE_search_condition = 10, RULE_search_condition_and = 11,
RULE_search_condition_not = 12, RULE_predicate = 13, RULE_query_expression = 14,
RULE_sql_union = 15, RULE_query_specification = 16, RULE_top_clause = 17,
RULE_top_percent = 18, RULE_top_count = 19, RULE_order_by_clause = 20,
RULE_order_by_expression = 21, RULE_group_by_item = 22, RULE_select_list = 23,
RULE_column_elem = 24, RULE_expression_elem = 25, RULE_select_list_elem = 26,
RULE_table_sources = 27, RULE_table_source = 28, RULE_table_source_item_joined = 29,
RULE_table_source_item = 30, RULE_join_part = 31, RULE_derived_table = 32,
RULE_function_call = 33, RULE_switch_section = 34, RULE_switch_search_condition_section = 35,
RULE_as_column_alias = 36, RULE_as_table_alias = 37, RULE_table_alias = 38,
RULE_column_alias_list = 39, RULE_column_alias = 40, RULE_table_value_constructor = 41,
RULE_expression_list = 42, RULE_over_clause = 43, RULE_row_or_range_clause = 44,
RULE_window_frame_extent = 45, RULE_window_frame_bound = 46, RULE_window_frame_preceding = 47,
RULE_window_frame_following = 48, RULE_table_name = 49, RULE_full_column_name = 50,
RULE_null_notnull = 51, RULE_data_type = 52, RULE_constant = 53, RULE_sign = 54,
RULE_id = 55, RULE_simple_id = 56, RULE_comparison_operator = 57, RULE_assignment_operator = 58;
private static String[] makeRuleNames() {
return new String[] {
"parseSelectStatement", "parseFrom", "expression", "primitive_expression",
"case_expression", "unary_operator_expression", "bracket_expression",
"constant_expression", "select_statement", "subquery", "search_condition",
"search_condition_and", "search_condition_not", "predicate", "query_expression",
"sql_union", "query_specification", "top_clause", "top_percent", "top_count",
"order_by_clause", "order_by_expression", "group_by_item", "select_list",
"column_elem", "expression_elem", "select_list_elem", "table_sources",
"table_source", "table_source_item_joined", "table_source_item", "join_part",
"derived_table", "function_call", "switch_section", "switch_search_condition_section",
"as_column_alias", "as_table_alias", "table_alias", "column_alias_list",
"column_alias", "table_value_constructor", "expression_list", "over_clause",
"row_or_range_clause", "window_frame_extent", "window_frame_bound", "window_frame_preceding",
"window_frame_following", "table_name", "full_column_name", "null_notnull",
"data_type", "constant", "sign", "id", "simple_id", "comparison_operator",
"assignment_operator"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, "'''", null, null, null, null, null, null,
null, "'='", "'>'", "'<'", "'!'", "'+='", "'-='", "'*='", "'/='", "'%='",
"'&='", "'^='", "'|='", "'||'", "'.'", "'$'", "'('", "')'", "','", "'*'",
"'/'", "'%'", "'+'", "'-'", "'~'", "'|'", "'&'", "'^'", "'?'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "ALL", "AND", "ANY", "AS", "ASC", "BETWEEN", "BY", "CASE", "COLLATE",
"CONVERT", "CROSS", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
"CURRENT_USER", "DESC", "DISTINCT", "DOUBLE", "ELSE", "END", "ESCAPE",
"EXCEPT", "EXISTS", "FETCH", "FROM", "FULL", "GROUP", "HAVING", "IDENTITY",
"IIF", "IN", "INNER", "INTERSECT", "IS", "JOIN", "LEFT", "LIKE", "NOT",
"NULL", "ON", "OR", "ORDER", "OUTER", "OVER", "PERCENT", "PRECISION",
"RIGHT", "SELECT", "SESSION_USER", "SET", "SOME", "SYSTEM_USER", "THEN",
"TOP", "UNION", "VALUES", "WHEN", "WHERE", "WITH", "WITHIN", "APPLY",
"CAST", "COUNT", "COUNT_BIG", "DATEADD", "DATEDIFF", "DATENAME", "DATEPART",
"FIRST", "FOLLOWING", "MAX", "MIN_ACTIVE_ROWVERSION", "NEXT", "OFFSET",
"ONLY", "PARTITION", "PRECEDING", "RANGE", "ROW", "ROWGUID", "ROWS",
"TIES", "UNBOUNDED", "SPACE", "COMMENT", "LINE_COMMENT", "DOUBLE_QUOTE_ID",
"SINGLE_QUOTE", "SQUARE_BRACKET_ID", "DECIMAL", "ID", "STRING", "BINARY",
"FLOAT", "REAL", "EQUAL", "GREATER", "LESS", "EXCLAMATION", "PLUS_ASSIGN",
"MINUS_ASSIGN", "MULT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN",
"XOR_ASSIGN", "OR_ASSIGN", "DOUBLE_BAR", "DOT", "DOLLAR", "LR_BRACKET",
"RR_BRACKET", "COMMA", "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "BIT_NOT",
"BIT_OR", "BIT_AND", "BIT_XOR", "PARAM", "IPV4_OCTECT", "LIMIT"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "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 ParseSelectStatementContext extends ParserRuleContext {
public Select_statementContext select_statement() {
return getRuleContext(Select_statementContext.class,0);
}
public TerminalNode EOF() { return getToken(SQLParser.EOF, 0); }
public ParseSelectStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseSelectStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterParseSelectStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitParseSelectStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitParseSelectStatement(this);
else return visitor.visitChildren(this);
}
}
public final ParseSelectStatementContext parseSelectStatement() throws RecognitionException {
ParseSelectStatementContext _localctx = new ParseSelectStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parseSelectStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(118);
select_statement();
setState(119);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseFromContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(SQLParser.FROM, 0); }
public Table_sourcesContext table_sources() {
return getRuleContext(Table_sourcesContext.class,0);
}
public TerminalNode EOF() { return getToken(SQLParser.EOF, 0); }
public TerminalNode WHERE() { return getToken(SQLParser.WHERE, 0); }
public Search_conditionContext search_condition() {
return getRuleContext(Search_conditionContext.class,0);
}
public ParseFromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseFrom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterParseFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitParseFrom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitParseFrom(this);
else return visitor.visitChildren(this);
}
}
public final ParseFromContext parseFrom() throws RecognitionException {
ParseFromContext _localctx = new ParseFromContext(_ctx, getState());
enterRule(_localctx, 2, RULE_parseFrom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(121);
match(FROM);
setState(122);
table_sources();
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(123);
match(WHERE);
setState(124);
search_condition();
}
}
setState(127);
match(EOF);
}
}
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 Primitive_expressionContext primitive_expression() {
return getRuleContext(Primitive_expressionContext.class,0);
}
public Function_callContext function_call() {
return getRuleContext(Function_callContext.class,0);
}
public Case_expressionContext case_expression() {
return getRuleContext(Case_expressionContext.class,0);
}
public Full_column_nameContext full_column_name() {
return getRuleContext(Full_column_nameContext.class,0);
}
public Bracket_expressionContext bracket_expression() {
return getRuleContext(Bracket_expressionContext.class,0);
}
public Unary_operator_expressionContext unary_operator_expression() {
return getRuleContext(Unary_operator_expressionContext.class,0);
}
public Over_clauseContext over_clause() {
return getRuleContext(Over_clauseContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode STAR() { return getToken(SQLParser.STAR, 0); }
public TerminalNode DIVIDE() { return getToken(SQLParser.DIVIDE, 0); }
public TerminalNode MODULE() { return getToken(SQLParser.MODULE, 0); }
public TerminalNode PLUS() { return getToken(SQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLParser.MINUS, 0); }
public TerminalNode BIT_AND() { return getToken(SQLParser.BIT_AND, 0); }
public TerminalNode BIT_XOR() { return getToken(SQLParser.BIT_XOR, 0); }
public TerminalNode BIT_OR() { return getToken(SQLParser.BIT_OR, 0); }
public TerminalNode DOUBLE_BAR() { return getToken(SQLParser.DOUBLE_BAR, 0); }
public Comparison_operatorContext comparison_operator() {
return getRuleContext(Comparison_operatorContext.class,0);
}
public Assignment_operatorContext assignment_operator() {
return getRuleContext(Assignment_operatorContext.class,0);
}
public TerminalNode COLLATE() { return getToken(SQLParser.COLLATE, 0); }
public IdContext id() {
return getRuleContext(IdContext.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);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(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 = 4;
enterRecursionRule(_localctx, 4, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(137);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(130);
primitive_expression();
}
break;
case 2:
{
setState(131);
function_call();
}
break;
case 3:
{
setState(132);
case_expression();
}
break;
case 4:
{
setState(133);
full_column_name();
}
break;
case 5:
{
setState(134);
bracket_expression();
}
break;
case 6:
{
setState(135);
unary_operator_expression();
}
break;
case 7:
{
setState(136);
over_clause();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(158);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(156);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(139);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(140);
_la = _input.LA(1);
if ( !(((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & ((1L << (STAR - 115)) | (1L << (DIVIDE - 115)) | (1L << (MODULE - 115)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(141);
expression(6);
}
break;
case 2:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(142);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(143);
_la = _input.LA(1);
if ( !(((((_la - 109)) & ~0x3f) == 0 && ((1L << (_la - 109)) & ((1L << (DOUBLE_BAR - 109)) | (1L << (PLUS - 109)) | (1L << (MINUS - 109)) | (1L << (BIT_OR - 109)) | (1L << (BIT_AND - 109)) | (1L << (BIT_XOR - 109)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(144);
expression(5);
}
break;
case 3:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(145);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(146);
comparison_operator();
setState(147);
expression(4);
}
break;
case 4:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(149);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(150);
assignment_operator();
setState(151);
expression(3);
}
break;
case 5:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(153);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(154);
match(COLLATE);
setState(155);
id();
}
break;
}
}
}
setState(160);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Primitive_expressionContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TerminalNode PARAM() { return getToken(SQLParser.PARAM, 0); }
public Primitive_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitive_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterPrimitive_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitPrimitive_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitPrimitive_expression(this);
else return visitor.visitChildren(this);
}
}
public final Primitive_expressionContext primitive_expression() throws RecognitionException {
Primitive_expressionContext _localctx = new Primitive_expressionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_primitive_expression);
try {
setState(164);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NULL:
enterOuterAlt(_localctx, 1);
{
setState(161);
match(NULL);
}
break;
case DECIMAL:
case STRING:
case BINARY:
case FLOAT:
case REAL:
case DOLLAR:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(162);
constant();
}
break;
case PARAM:
enterOuterAlt(_localctx, 3);
{
setState(163);
match(PARAM);
}
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 Case_expressionContext extends ParserRuleContext {
public TerminalNode CASE() { return getToken(SQLParser.CASE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode END() { return getToken(SQLParser.END, 0); }
public List switch_section() {
return getRuleContexts(Switch_sectionContext.class);
}
public Switch_sectionContext switch_section(int i) {
return getRuleContext(Switch_sectionContext.class,i);
}
public TerminalNode ELSE() { return getToken(SQLParser.ELSE, 0); }
public List switch_search_condition_section() {
return getRuleContexts(Switch_search_condition_sectionContext.class);
}
public Switch_search_condition_sectionContext switch_search_condition_section(int i) {
return getRuleContext(Switch_search_condition_sectionContext.class,i);
}
public Case_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_case_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCase_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCase_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCase_expression(this);
else return visitor.visitChildren(this);
}
}
public final Case_expressionContext case_expression() throws RecognitionException {
Case_expressionContext _localctx = new Case_expressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_case_expression);
int _la;
try {
setState(191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(166);
match(CASE);
setState(167);
expression(0);
setState(169);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(168);
switch_section();
}
}
setState(171);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(175);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(173);
match(ELSE);
setState(174);
expression(0);
}
}
setState(177);
match(END);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(179);
match(CASE);
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(180);
switch_search_condition_section();
}
}
setState(183);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(185);
match(ELSE);
setState(186);
expression(0);
}
}
setState(189);
match(END);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_operator_expressionContext extends ParserRuleContext {
public TerminalNode BIT_NOT() { return getToken(SQLParser.BIT_NOT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode PLUS() { return getToken(SQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLParser.MINUS, 0); }
public Unary_operator_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_operator_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterUnary_operator_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitUnary_operator_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitUnary_operator_expression(this);
else return visitor.visitChildren(this);
}
}
public final Unary_operator_expressionContext unary_operator_expression() throws RecognitionException {
Unary_operator_expressionContext _localctx = new Unary_operator_expressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_unary_operator_expression);
int _la;
try {
setState(197);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BIT_NOT:
enterOuterAlt(_localctx, 1);
{
setState(193);
match(BIT_NOT);
setState(194);
expression(0);
}
break;
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(195);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(196);
expression(0);
}
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 Bracket_expressionContext extends ParserRuleContext {
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public SubqueryContext subquery() {
return getRuleContext(SubqueryContext.class,0);
}
public Bracket_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bracket_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterBracket_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitBracket_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitBracket_expression(this);
else return visitor.visitChildren(this);
}
}
public final Bracket_expressionContext bracket_expression() throws RecognitionException {
Bracket_expressionContext _localctx = new Bracket_expressionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_bracket_expression);
try {
setState(207);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(199);
match(LR_BRACKET);
setState(200);
expression(0);
setState(201);
match(RR_BRACKET);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(203);
match(LR_BRACKET);
setState(204);
subquery();
setState(205);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Constant_expressionContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public Function_callContext function_call() {
return getRuleContext(Function_callContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public Constant_expressionContext constant_expression() {
return getRuleContext(Constant_expressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public Constant_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterConstant_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitConstant_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitConstant_expression(this);
else return visitor.visitChildren(this);
}
}
public final Constant_expressionContext constant_expression() throws RecognitionException {
Constant_expressionContext _localctx = new Constant_expressionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_constant_expression);
try {
setState(216);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NULL:
enterOuterAlt(_localctx, 1);
{
setState(209);
match(NULL);
}
break;
case DECIMAL:
case STRING:
case BINARY:
case FLOAT:
case REAL:
case DOLLAR:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(210);
constant();
}
break;
case CONVERT:
case CURRENT_TIMESTAMP:
case CURRENT_USER:
case IIF:
case SESSION_USER:
case SYSTEM_USER:
case CAST:
case COUNT:
case COUNT_BIG:
case DATEADD:
case DATEDIFF:
case DATENAME:
case DATEPART:
case MIN_ACTIVE_ROWVERSION:
case ID:
enterOuterAlt(_localctx, 3);
{
setState(211);
function_call();
}
break;
case LR_BRACKET:
enterOuterAlt(_localctx, 4);
{
setState(212);
match(LR_BRACKET);
setState(213);
constant_expression();
setState(214);
match(RR_BRACKET);
}
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 Select_statementContext extends ParserRuleContext {
public Query_expressionContext query_expression() {
return getRuleContext(Query_expressionContext.class,0);
}
public Order_by_clauseContext order_by_clause() {
return getRuleContext(Order_by_clauseContext.class,0);
}
public Select_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_statement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSelect_statement(this);
else return visitor.visitChildren(this);
}
}
public final Select_statementContext select_statement() throws RecognitionException {
Select_statementContext _localctx = new Select_statementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_select_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
query_expression();
setState(220);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(219);
order_by_clause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubqueryContext extends ParserRuleContext {
public Select_statementContext select_statement() {
return getRuleContext(Select_statementContext.class,0);
}
public SubqueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subquery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSubquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSubquery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSubquery(this);
else return visitor.visitChildren(this);
}
}
public final SubqueryContext subquery() throws RecognitionException {
SubqueryContext _localctx = new SubqueryContext(_ctx, getState());
enterRule(_localctx, 18, RULE_subquery);
try {
enterOuterAlt(_localctx, 1);
{
setState(222);
select_statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Search_conditionContext extends ParserRuleContext {
public List search_condition_and() {
return getRuleContexts(Search_condition_andContext.class);
}
public Search_condition_andContext search_condition_and(int i) {
return getRuleContext(Search_condition_andContext.class,i);
}
public List OR() { return getTokens(SQLParser.OR); }
public TerminalNode OR(int i) {
return getToken(SQLParser.OR, i);
}
public Search_conditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_search_condition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSearch_condition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSearch_condition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSearch_condition(this);
else return visitor.visitChildren(this);
}
}
public final Search_conditionContext search_condition() throws RecognitionException {
Search_conditionContext _localctx = new Search_conditionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_search_condition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(224);
search_condition_and();
setState(229);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(225);
match(OR);
setState(226);
search_condition_and();
}
}
setState(231);
_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 Search_condition_andContext extends ParserRuleContext {
public List search_condition_not() {
return getRuleContexts(Search_condition_notContext.class);
}
public Search_condition_notContext search_condition_not(int i) {
return getRuleContext(Search_condition_notContext.class,i);
}
public List AND() { return getTokens(SQLParser.AND); }
public TerminalNode AND(int i) {
return getToken(SQLParser.AND, i);
}
public Search_condition_andContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_search_condition_and; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSearch_condition_and(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSearch_condition_and(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSearch_condition_and(this);
else return visitor.visitChildren(this);
}
}
public final Search_condition_andContext search_condition_and() throws RecognitionException {
Search_condition_andContext _localctx = new Search_condition_andContext(_ctx, getState());
enterRule(_localctx, 22, RULE_search_condition_and);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(232);
search_condition_not();
setState(237);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(233);
match(AND);
setState(234);
search_condition_not();
}
}
setState(239);
_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 Search_condition_notContext extends ParserRuleContext {
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode NOT() { return getToken(SQLParser.NOT, 0); }
public Search_condition_notContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_search_condition_not; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSearch_condition_not(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSearch_condition_not(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSearch_condition_not(this);
else return visitor.visitChildren(this);
}
}
public final Search_condition_notContext search_condition_not() throws RecognitionException {
Search_condition_notContext _localctx = new Search_condition_notContext(_ctx, getState());
enterRule(_localctx, 24, RULE_search_condition_not);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(241);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(240);
match(NOT);
}
}
setState(243);
predicate();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PredicateContext extends ParserRuleContext {
public TerminalNode EXISTS() { return getToken(SQLParser.EXISTS, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public SubqueryContext subquery() {
return getRuleContext(SubqueryContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public Comparison_operatorContext comparison_operator() {
return getRuleContext(Comparison_operatorContext.class,0);
}
public TerminalNode ALL() { return getToken(SQLParser.ALL, 0); }
public TerminalNode SOME() { return getToken(SQLParser.SOME, 0); }
public TerminalNode ANY() { return getToken(SQLParser.ANY, 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 IN() { return getToken(SQLParser.IN, 0); }
public Expression_listContext expression_list() {
return getRuleContext(Expression_listContext.class,0);
}
public TerminalNode LIKE() { return getToken(SQLParser.LIKE, 0); }
public TerminalNode ESCAPE() { return getToken(SQLParser.ESCAPE, 0); }
public TerminalNode IS() { return getToken(SQLParser.IS, 0); }
public Null_notnullContext null_notnull() {
return getRuleContext(Null_notnullContext.class,0);
}
public Search_conditionContext search_condition() {
return getRuleContext(Search_conditionContext.class,0);
}
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitPredicate(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState());
enterRule(_localctx, 26, RULE_predicate);
int _la;
try {
setState(300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(245);
match(EXISTS);
setState(246);
match(LR_BRACKET);
setState(247);
subquery();
setState(248);
match(RR_BRACKET);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(250);
expression(0);
setState(251);
comparison_operator();
setState(252);
expression(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(254);
expression(0);
setState(255);
comparison_operator();
setState(256);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ALL) | (1L << ANY) | (1L << SOME))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(257);
match(LR_BRACKET);
setState(258);
subquery();
setState(259);
match(RR_BRACKET);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(261);
expression(0);
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(262);
match(NOT);
}
}
setState(265);
match(BETWEEN);
setState(266);
expression(0);
setState(267);
match(AND);
setState(268);
expression(0);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(270);
expression(0);
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(271);
match(NOT);
}
}
setState(274);
match(IN);
setState(275);
match(LR_BRACKET);
setState(278);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(276);
subquery();
}
break;
case 2:
{
setState(277);
expression_list();
}
break;
}
setState(280);
match(RR_BRACKET);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(282);
expression(0);
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(283);
match(NOT);
}
}
setState(286);
match(LIKE);
setState(287);
expression(0);
setState(290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ESCAPE) {
{
setState(288);
match(ESCAPE);
setState(289);
expression(0);
}
}
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(292);
expression(0);
setState(293);
match(IS);
setState(294);
null_notnull();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(296);
match(LR_BRACKET);
setState(297);
search_condition();
setState(298);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Query_expressionContext extends ParserRuleContext {
public Query_specificationContext query_specification() {
return getRuleContext(Query_specificationContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public Query_expressionContext query_expression() {
return getRuleContext(Query_expressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public List sql_union() {
return getRuleContexts(Sql_unionContext.class);
}
public Sql_unionContext sql_union(int i) {
return getRuleContext(Sql_unionContext.class,i);
}
public Query_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterQuery_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitQuery_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitQuery_expression(this);
else return visitor.visitChildren(this);
}
}
public final Query_expressionContext query_expression() throws RecognitionException {
Query_expressionContext _localctx = new Query_expressionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_query_expression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(307);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(302);
query_specification();
}
break;
case LR_BRACKET:
{
setState(303);
match(LR_BRACKET);
setState(304);
query_expression();
setState(305);
match(RR_BRACKET);
}
break;
default:
throw new NoViableAltException(this);
}
setState(312);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(309);
sql_union();
}
}
}
setState(314);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sql_unionContext extends ParserRuleContext {
public TerminalNode UNION() { return getToken(SQLParser.UNION, 0); }
public TerminalNode EXCEPT() { return getToken(SQLParser.EXCEPT, 0); }
public TerminalNode INTERSECT() { return getToken(SQLParser.INTERSECT, 0); }
public Query_specificationContext query_specification() {
return getRuleContext(Query_specificationContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public Query_expressionContext query_expression() {
return getRuleContext(Query_expressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public TerminalNode ALL() { return getToken(SQLParser.ALL, 0); }
public Sql_unionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_union; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSql_union(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSql_union(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSql_union(this);
else return visitor.visitChildren(this);
}
}
public final Sql_unionContext sql_union() throws RecognitionException {
Sql_unionContext _localctx = new Sql_unionContext(_ctx, getState());
enterRule(_localctx, 30, RULE_sql_union);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(321);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNION:
{
setState(315);
match(UNION);
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(316);
match(ALL);
}
}
}
break;
case EXCEPT:
{
setState(319);
match(EXCEPT);
}
break;
case INTERSECT:
{
setState(320);
match(INTERSECT);
}
break;
default:
throw new NoViableAltException(this);
}
setState(328);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
{
setState(323);
query_specification();
}
break;
case LR_BRACKET:
{
{
setState(324);
match(LR_BRACKET);
setState(325);
query_expression();
setState(326);
match(RR_BRACKET);
}
}
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 Query_specificationContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(SQLParser.SELECT, 0); }
public Select_listContext select_list() {
return getRuleContext(Select_listContext.class,0);
}
public Top_clauseContext top_clause() {
return getRuleContext(Top_clauseContext.class,0);
}
public TerminalNode FROM() { return getToken(SQLParser.FROM, 0); }
public Table_sourcesContext table_sources() {
return getRuleContext(Table_sourcesContext.class,0);
}
public TerminalNode WHERE() { return getToken(SQLParser.WHERE, 0); }
public List search_condition() {
return getRuleContexts(Search_conditionContext.class);
}
public Search_conditionContext search_condition(int i) {
return getRuleContext(Search_conditionContext.class,i);
}
public TerminalNode GROUP() { return getToken(SQLParser.GROUP, 0); }
public TerminalNode BY() { return getToken(SQLParser.BY, 0); }
public List group_by_item() {
return getRuleContexts(Group_by_itemContext.class);
}
public Group_by_itemContext group_by_item(int i) {
return getRuleContext(Group_by_itemContext.class,i);
}
public TerminalNode HAVING() { return getToken(SQLParser.HAVING, 0); }
public List ALL() { return getTokens(SQLParser.ALL); }
public TerminalNode ALL(int i) {
return getToken(SQLParser.ALL, i);
}
public TerminalNode DISTINCT() { return getToken(SQLParser.DISTINCT, 0); }
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Query_specificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_query_specification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterQuery_specification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitQuery_specification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitQuery_specification(this);
else return visitor.visitChildren(this);
}
}
public final Query_specificationContext query_specification() throws RecognitionException {
Query_specificationContext _localctx = new Query_specificationContext(_ctx, getState());
enterRule(_localctx, 32, RULE_query_specification);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(330);
match(SELECT);
setState(332);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(331);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==TOP) {
{
setState(334);
top_clause();
}
}
setState(337);
select_list();
setState(340);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(338);
match(FROM);
setState(339);
table_sources();
}
}
setState(344);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(342);
match(WHERE);
setState(343);
search_condition();
}
break;
}
setState(359);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(346);
match(GROUP);
setState(347);
match(BY);
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL) {
{
setState(348);
match(ALL);
}
}
setState(351);
group_by_item();
setState(356);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(352);
match(COMMA);
setState(353);
group_by_item();
}
}
}
setState(358);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
}
break;
}
setState(363);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
{
setState(361);
match(HAVING);
setState(362);
search_condition();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Top_clauseContext extends ParserRuleContext {
public TerminalNode TOP() { return getToken(SQLParser.TOP, 0); }
public Top_percentContext top_percent() {
return getRuleContext(Top_percentContext.class,0);
}
public Top_countContext top_count() {
return getRuleContext(Top_countContext.class,0);
}
public TerminalNode WITH() { return getToken(SQLParser.WITH, 0); }
public TerminalNode TIES() { return getToken(SQLParser.TIES, 0); }
public Top_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_top_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTop_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTop_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTop_clause(this);
else return visitor.visitChildren(this);
}
}
public final Top_clauseContext top_clause() throws RecognitionException {
Top_clauseContext _localctx = new Top_clauseContext(_ctx, getState());
enterRule(_localctx, 34, RULE_top_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(365);
match(TOP);
setState(368);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(366);
top_percent();
}
break;
case 2:
{
setState(367);
top_count();
}
break;
}
setState(372);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(370);
match(WITH);
setState(371);
match(TIES);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Top_percentContext extends ParserRuleContext {
public TerminalNode PERCENT() { return getToken(SQLParser.PERCENT, 0); }
public TerminalNode REAL() { return getToken(SQLParser.REAL, 0); }
public TerminalNode FLOAT() { return getToken(SQLParser.FLOAT, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public Top_percentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_top_percent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTop_percent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTop_percent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTop_percent(this);
else return visitor.visitChildren(this);
}
}
public final Top_percentContext top_percent() throws RecognitionException {
Top_percentContext _localctx = new Top_percentContext(_ctx, getState());
enterRule(_localctx, 36, RULE_top_percent);
int _la;
try {
setState(381);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FLOAT:
case REAL:
enterOuterAlt(_localctx, 1);
{
setState(374);
_la = _input.LA(1);
if ( !(_la==FLOAT || _la==REAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(375);
match(PERCENT);
}
break;
case LR_BRACKET:
enterOuterAlt(_localctx, 2);
{
setState(376);
match(LR_BRACKET);
setState(377);
expression(0);
setState(378);
match(RR_BRACKET);
setState(379);
match(PERCENT);
}
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 Top_countContext extends ParserRuleContext {
public TerminalNode DECIMAL() { return getToken(SQLParser.DECIMAL, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public Top_countContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_top_count; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTop_count(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTop_count(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTop_count(this);
else return visitor.visitChildren(this);
}
}
public final Top_countContext top_count() throws RecognitionException {
Top_countContext _localctx = new Top_countContext(_ctx, getState());
enterRule(_localctx, 38, RULE_top_count);
try {
setState(388);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DECIMAL:
enterOuterAlt(_localctx, 1);
{
setState(383);
match(DECIMAL);
}
break;
case LR_BRACKET:
enterOuterAlt(_localctx, 2);
{
setState(384);
match(LR_BRACKET);
setState(385);
expression(0);
setState(386);
match(RR_BRACKET);
}
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 Order_by_clauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(SQLParser.ORDER, 0); }
public TerminalNode BY() { return getToken(SQLParser.BY, 0); }
public List order_by_expression() {
return getRuleContexts(Order_by_expressionContext.class);
}
public Order_by_expressionContext order_by_expression(int i) {
return getRuleContext(Order_by_expressionContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public TerminalNode OFFSET() { return getToken(SQLParser.OFFSET, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode LIMIT() { return getToken(SQLParser.LIMIT, 0); }
public List ROW() { return getTokens(SQLParser.ROW); }
public TerminalNode ROW(int i) {
return getToken(SQLParser.ROW, i);
}
public List ROWS() { return getTokens(SQLParser.ROWS); }
public TerminalNode ROWS(int i) {
return getToken(SQLParser.ROWS, i);
}
public TerminalNode FETCH() { return getToken(SQLParser.FETCH, 0); }
public TerminalNode ONLY() { return getToken(SQLParser.ONLY, 0); }
public TerminalNode FIRST() { return getToken(SQLParser.FIRST, 0); }
public TerminalNode NEXT() { return getToken(SQLParser.NEXT, 0); }
public Order_by_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOrder_by_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOrder_by_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitOrder_by_clause(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_clauseContext order_by_clause() throws RecognitionException {
Order_by_clauseContext _localctx = new Order_by_clauseContext(_ctx, getState());
enterRule(_localctx, 40, RULE_order_by_clause);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(390);
match(ORDER);
setState(391);
match(BY);
setState(392);
order_by_expression();
setState(397);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(393);
match(COMMA);
setState(394);
order_by_expression();
}
}
}
setState(399);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
}
setState(416);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
{
setState(400);
match(OFFSET);
setState(401);
expression(0);
setState(402);
_la = _input.LA(1);
if ( !(_la==ROW || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FETCH) {
{
setState(403);
match(FETCH);
setState(404);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==NEXT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(405);
expression(0);
setState(406);
_la = _input.LA(1);
if ( !(_la==ROW || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(407);
match(ONLY);
}
}
}
}
break;
case 2:
{
{
setState(411);
match(LIMIT);
setState(412);
expression(0);
{
setState(413);
match(OFFSET);
setState(414);
expression(0);
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Order_by_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_by_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order_by_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOrder_by_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOrder_by_expression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitOrder_by_expression(this);
else return visitor.visitChildren(this);
}
}
public final Order_by_expressionContext order_by_expression() throws RecognitionException {
Order_by_expressionContext _localctx = new Order_by_expressionContext(_ctx, getState());
enterRule(_localctx, 42, RULE_order_by_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(418);
expression(0);
setState(420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(419);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_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 Group_by_itemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public Group_by_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_group_by_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterGroup_by_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitGroup_by_item(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitGroup_by_item(this);
else return visitor.visitChildren(this);
}
}
public final Group_by_itemContext group_by_item() throws RecognitionException {
Group_by_itemContext _localctx = new Group_by_itemContext(_ctx, getState());
enterRule(_localctx, 44, RULE_group_by_item);
try {
enterOuterAlt(_localctx, 1);
{
setState(422);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_listContext extends ParserRuleContext {
public List select_list_elem() {
return getRuleContexts(Select_list_elemContext.class);
}
public Select_list_elemContext select_list_elem(int i) {
return getRuleContext(Select_list_elemContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Select_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSelect_list(this);
else return visitor.visitChildren(this);
}
}
public final Select_listContext select_list() throws RecognitionException {
Select_listContext _localctx = new Select_listContext(_ctx, getState());
enterRule(_localctx, 46, RULE_select_list);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(424);
select_list_elem();
setState(429);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(425);
match(COMMA);
setState(426);
select_list_elem();
}
}
}
setState(431);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_elemContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public As_column_aliasContext as_column_alias() {
return getRuleContext(As_column_aliasContext.class,0);
}
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TerminalNode DOLLAR() { return getToken(SQLParser.DOLLAR, 0); }
public TerminalNode IDENTITY() { return getToken(SQLParser.IDENTITY, 0); }
public TerminalNode ROWGUID() { return getToken(SQLParser.ROWGUID, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLParser.DOT, 0); }
public Column_elemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_elem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterColumn_elem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitColumn_elem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitColumn_elem(this);
else return visitor.visitChildren(this);
}
}
public final Column_elemContext column_elem() throws RecognitionException {
Column_elemContext _localctx = new Column_elemContext(_ctx, getState());
enterRule(_localctx, 48, RULE_column_elem);
try {
enterOuterAlt(_localctx, 1);
{
setState(445);
_errHandler.sync(this);
switch (_input.LA(1)) {
case APPLY:
case CAST:
case COUNT:
case COUNT_BIG:
case DATEADD:
case DATEDIFF:
case DATENAME:
case DATEPART:
case FIRST:
case FOLLOWING:
case MIN_ACTIVE_ROWVERSION:
case NEXT:
case OFFSET:
case ONLY:
case PARTITION:
case PRECEDING:
case RANGE:
case ROW:
case ROWGUID:
case ROWS:
case TIES:
case UNBOUNDED:
case DOUBLE_QUOTE_ID:
case SQUARE_BRACKET_ID:
case ID:
case DOLLAR:
{
setState(435);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(432);
table_name();
setState(433);
match(DOT);
}
break;
}
setState(442);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(437);
id();
}
break;
case 2:
{
setState(438);
match(DOLLAR);
setState(439);
match(IDENTITY);
}
break;
case 3:
{
setState(440);
match(DOLLAR);
setState(441);
match(ROWGUID);
}
break;
}
}
break;
case NULL:
{
setState(444);
match(NULL);
}
break;
default:
throw new NoViableAltException(this);
}
setState(448);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(447);
as_column_alias();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Expression_elemContext extends ParserRuleContext {
public Column_aliasContext column_alias() {
return getRuleContext(Column_aliasContext.class,0);
}
public TerminalNode EQUAL() { return getToken(SQLParser.EQUAL, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public As_column_aliasContext as_column_alias() {
return getRuleContext(As_column_aliasContext.class,0);
}
public Expression_elemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression_elem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterExpression_elem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitExpression_elem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitExpression_elem(this);
else return visitor.visitChildren(this);
}
}
public final Expression_elemContext expression_elem() throws RecognitionException {
Expression_elemContext _localctx = new Expression_elemContext(_ctx, getState());
enterRule(_localctx, 50, RULE_expression_elem);
try {
setState(458);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(450);
column_alias();
setState(451);
match(EQUAL);
setState(452);
expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(454);
expression(0);
setState(456);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(455);
as_column_alias();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_list_elemContext extends ParserRuleContext {
public Column_elemContext column_elem() {
return getRuleContext(Column_elemContext.class,0);
}
public Expression_elemContext expression_elem() {
return getRuleContext(Expression_elemContext.class,0);
}
public TerminalNode STAR() { return getToken(SQLParser.STAR, 0); }
public Select_list_elemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_list_elem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSelect_list_elem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSelect_list_elem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSelect_list_elem(this);
else return visitor.visitChildren(this);
}
}
public final Select_list_elemContext select_list_elem() throws RecognitionException {
Select_list_elemContext _localctx = new Select_list_elemContext(_ctx, getState());
enterRule(_localctx, 52, RULE_select_list_elem);
try {
setState(463);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(460);
column_elem();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(461);
expression_elem();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(462);
match(STAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_sourcesContext extends ParserRuleContext {
public List table_source() {
return getRuleContexts(Table_sourceContext.class);
}
public Table_sourceContext table_source(int i) {
return getRuleContext(Table_sourceContext.class,i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Table_sourcesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_sources; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_sources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_sources(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_sources(this);
else return visitor.visitChildren(this);
}
}
public final Table_sourcesContext table_sources() throws RecognitionException {
Table_sourcesContext _localctx = new Table_sourcesContext(_ctx, getState());
enterRule(_localctx, 54, RULE_table_sources);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(465);
table_source();
setState(470);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(466);
match(COMMA);
setState(467);
table_source();
}
}
}
setState(472);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_sourceContext extends ParserRuleContext {
public Table_source_item_joinedContext table_source_item_joined() {
return getRuleContext(Table_source_item_joinedContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public Table_sourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_source; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_source(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_source(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_source(this);
else return visitor.visitChildren(this);
}
}
public final Table_sourceContext table_source() throws RecognitionException {
Table_sourceContext _localctx = new Table_sourceContext(_ctx, getState());
enterRule(_localctx, 56, RULE_table_source);
try {
setState(478);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(473);
table_source_item_joined();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(474);
match(LR_BRACKET);
setState(475);
table_source_item_joined();
setState(476);
match(RR_BRACKET);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_source_item_joinedContext extends ParserRuleContext {
public Table_source_itemContext table_source_item() {
return getRuleContext(Table_source_itemContext.class,0);
}
public List join_part() {
return getRuleContexts(Join_partContext.class);
}
public Join_partContext join_part(int i) {
return getRuleContext(Join_partContext.class,i);
}
public Table_source_item_joinedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_source_item_joined; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_source_item_joined(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_source_item_joined(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_source_item_joined(this);
else return visitor.visitChildren(this);
}
}
public final Table_source_item_joinedContext table_source_item_joined() throws RecognitionException {
Table_source_item_joinedContext _localctx = new Table_source_item_joinedContext(_ctx, getState());
enterRule(_localctx, 58, RULE_table_source_item_joined);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(480);
table_source_item();
setState(484);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(481);
join_part();
}
}
}
setState(486);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_source_itemContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public As_table_aliasContext as_table_alias() {
return getRuleContext(As_table_aliasContext.class,0);
}
public Derived_tableContext derived_table() {
return getRuleContext(Derived_tableContext.class,0);
}
public Column_alias_listContext column_alias_list() {
return getRuleContext(Column_alias_listContext.class,0);
}
public Function_callContext function_call() {
return getRuleContext(Function_callContext.class,0);
}
public Table_source_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_source_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_source_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_source_item(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_source_item(this);
else return visitor.visitChildren(this);
}
}
public final Table_source_itemContext table_source_item() throws RecognitionException {
Table_source_itemContext _localctx = new Table_source_itemContext(_ctx, getState());
enterRule(_localctx, 60, RULE_table_source_item);
int _la;
try {
setState(505);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(487);
table_name();
setState(489);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
setState(488);
as_table_alias();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(491);
derived_table();
setState(496);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
{
setState(492);
as_table_alias();
setState(494);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(493);
column_alias_list();
}
}
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(498);
function_call();
setState(503);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
setState(499);
as_table_alias();
setState(501);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(500);
column_alias_list();
}
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_partContext extends ParserRuleContext {
public TerminalNode JOIN() { return getToken(SQLParser.JOIN, 0); }
public Table_sourceContext table_source() {
return getRuleContext(Table_sourceContext.class,0);
}
public TerminalNode ON() { return getToken(SQLParser.ON, 0); }
public Search_conditionContext search_condition() {
return getRuleContext(Search_conditionContext.class,0);
}
public TerminalNode LEFT() { return getToken(SQLParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(SQLParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(SQLParser.FULL, 0); }
public TerminalNode INNER() { return getToken(SQLParser.INNER, 0); }
public TerminalNode OUTER() { return getToken(SQLParser.OUTER, 0); }
public TerminalNode CROSS() { return getToken(SQLParser.CROSS, 0); }
public TerminalNode APPLY() { return getToken(SQLParser.APPLY, 0); }
public Join_partContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_part; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterJoin_part(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitJoin_part(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitJoin_part(this);
else return visitor.visitChildren(this);
}
}
public final Join_partContext join_part() throws RecognitionException {
Join_partContext _localctx = new Join_partContext(_ctx, getState());
enterRule(_localctx, 62, RULE_join_part);
int _la;
try {
setState(530);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(514);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INNER:
case JOIN:
{
setState(508);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(507);
match(INNER);
}
}
}
break;
case FULL:
case LEFT:
case RIGHT:
{
setState(510);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FULL) | (1L << LEFT) | (1L << RIGHT))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(512);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(511);
match(OUTER);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(516);
match(JOIN);
setState(517);
table_source();
setState(518);
match(ON);
setState(519);
search_condition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(521);
match(CROSS);
setState(522);
match(JOIN);
setState(523);
table_source();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(524);
match(CROSS);
setState(525);
match(APPLY);
setState(526);
table_source();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(527);
match(OUTER);
setState(528);
match(APPLY);
setState(529);
table_source();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Derived_tableContext extends ParserRuleContext {
public SubqueryContext subquery() {
return getRuleContext(SubqueryContext.class,0);
}
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public Table_value_constructorContext table_value_constructor() {
return getRuleContext(Table_value_constructorContext.class,0);
}
public Derived_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_derived_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterDerived_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitDerived_table(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitDerived_table(this);
else return visitor.visitChildren(this);
}
}
public final Derived_tableContext derived_table() throws RecognitionException {
Derived_tableContext _localctx = new Derived_tableContext(_ctx, getState());
enterRule(_localctx, 64, RULE_derived_table);
try {
setState(542);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(532);
subquery();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(533);
match(LR_BRACKET);
setState(534);
subquery();
setState(535);
match(RR_BRACKET);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(537);
table_value_constructor();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(538);
match(LR_BRACKET);
setState(539);
table_value_constructor();
setState(540);
match(RR_BRACKET);
}
break;
}
}
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 Function_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_call; }
public Function_callContext() { }
public void copyFrom(Function_callContext ctx) {
super.copyFrom(ctx);
}
}
public static class CASTContext extends Function_callContext {
public TerminalNode CAST() { return getToken(SQLParser.CAST, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(SQLParser.AS, 0); }
public Data_typeContext data_type() {
return getRuleContext(Data_typeContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public CASTContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCAST(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCAST(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCAST(this);
else return visitor.visitChildren(this);
}
}
public static class CURRENT_USERContext extends Function_callContext {
public TerminalNode CURRENT_USER() { return getToken(SQLParser.CURRENT_USER, 0); }
public CURRENT_USERContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCURRENT_USER(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCURRENT_USER(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCURRENT_USER(this);
else return visitor.visitChildren(this);
}
}
public static class DATEADDContext extends Function_callContext {
public TerminalNode DATEADD() { return getToken(SQLParser.DATEADD, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public DATEADDContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterDATEADD(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitDATEADD(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitDATEADD(this);
else return visitor.visitChildren(this);
}
}
public static class CURRENT_TIMESTAMPContext extends Function_callContext {
public TerminalNode CURRENT_TIMESTAMP() { return getToken(SQLParser.CURRENT_TIMESTAMP, 0); }
public CURRENT_TIMESTAMPContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCURRENT_TIMESTAMP(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCURRENT_TIMESTAMP(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCURRENT_TIMESTAMP(this);
else return visitor.visitChildren(this);
}
}
public static class MIN_ACTIVE_ROWVERSIONContext extends Function_callContext {
public TerminalNode MIN_ACTIVE_ROWVERSION() { return getToken(SQLParser.MIN_ACTIVE_ROWVERSION, 0); }
public MIN_ACTIVE_ROWVERSIONContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterMIN_ACTIVE_ROWVERSION(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitMIN_ACTIVE_ROWVERSION(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitMIN_ACTIVE_ROWVERSION(this);
else return visitor.visitChildren(this);
}
}
public static class IFFContext extends Function_callContext {
public TerminalNode IIF() { return getToken(SQLParser.IIF, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public Search_conditionContext search_condition() {
return getRuleContext(Search_conditionContext.class,0);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public IFFContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterIFF(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitIFF(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitIFF(this);
else return visitor.visitChildren(this);
}
}
public static class DATEPARTContext extends Function_callContext {
public TerminalNode DATEPART() { return getToken(SQLParser.DATEPART, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public TerminalNode COMMA() { return getToken(SQLParser.COMMA, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public DATEPARTContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterDATEPART(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitDATEPART(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitDATEPART(this);
else return visitor.visitChildren(this);
}
}
public static class SYSTEM_USERContext extends Function_callContext {
public TerminalNode SYSTEM_USER() { return getToken(SQLParser.SYSTEM_USER, 0); }
public SYSTEM_USERContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSYSTEM_USER(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSYSTEM_USER(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSYSTEM_USER(this);
else return visitor.visitChildren(this);
}
}
public static class SESSION_USERContext extends Function_callContext {
public TerminalNode SESSION_USER() { return getToken(SQLParser.SESSION_USER, 0); }
public SESSION_USERContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSESSION_USER(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSESSION_USER(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSESSION_USER(this);
else return visitor.visitChildren(this);
}
}
public static class CONVERTContext extends Function_callContext {
public TerminalNode CONVERT() { return getToken(SQLParser.CONVERT, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public Data_typeContext data_type() {
return getRuleContext(Data_typeContext.class,0);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public CONVERTContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCONVERT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCONVERT(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCONVERT(this);
else return visitor.visitChildren(this);
}
}
public static class DATENAMEContext extends Function_callContext {
public TerminalNode DATENAME() { return getToken(SQLParser.DATENAME, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public TerminalNode COMMA() { return getToken(SQLParser.COMMA, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public DATENAMEContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterDATENAME(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitDATENAME(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitDATENAME(this);
else return visitor.visitChildren(this);
}
}
public static class COUNTContext extends Function_callContext {
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode STAR() { return getToken(SQLParser.STAR, 0); }
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public TerminalNode COUNT() { return getToken(SQLParser.COUNT, 0); }
public TerminalNode COUNT_BIG() { return getToken(SQLParser.COUNT_BIG, 0); }
public Over_clauseContext over_clause() {
return getRuleContext(Over_clauseContext.class,0);
}
public COUNTContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterCOUNT(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitCOUNT(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitCOUNT(this);
else return visitor.visitChildren(this);
}
}
public static class ANY_FUNCContext extends Function_callContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public List LR_BRACKET() { return getTokens(SQLParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(SQLParser.LR_BRACKET, i);
}
public List RR_BRACKET() { return getTokens(SQLParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(SQLParser.RR_BRACKET, i);
}
public Expression_listContext expression_list() {
return getRuleContext(Expression_listContext.class,0);
}
public Over_clauseContext over_clause() {
return getRuleContext(Over_clauseContext.class,0);
}
public TerminalNode ALL() { return getToken(SQLParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(SQLParser.DISTINCT, 0); }
public TerminalNode WITHIN() { return getToken(SQLParser.WITHIN, 0); }
public TerminalNode GROUP() { return getToken(SQLParser.GROUP, 0); }
public Order_by_clauseContext order_by_clause() {
return getRuleContext(Order_by_clauseContext.class,0);
}
public ANY_FUNCContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterANY_FUNC(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitANY_FUNC(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitANY_FUNC(this);
else return visitor.visitChildren(this);
}
}
public static class DATEDIFFContext extends Function_callContext {
public TerminalNode DATEDIFF() { return getToken(SQLParser.DATEDIFF, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public DATEDIFFContext(Function_callContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterDATEDIFF(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitDATEDIFF(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitDATEDIFF(this);
else return visitor.visitChildren(this);
}
}
public final Function_callContext function_call() throws RecognitionException {
Function_callContext _localctx = new Function_callContext(_ctx, getState());
enterRule(_localctx, 66, RULE_function_call);
int _la;
try {
setState(633);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CAST:
_localctx = new CASTContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(544);
match(CAST);
setState(545);
match(LR_BRACKET);
setState(546);
expression(0);
setState(547);
match(AS);
setState(548);
data_type();
setState(549);
match(RR_BRACKET);
}
break;
case CONVERT:
_localctx = new CONVERTContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(551);
match(CONVERT);
setState(552);
match(LR_BRACKET);
setState(553);
data_type();
setState(554);
match(COMMA);
setState(555);
expression(0);
setState(558);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(556);
match(COMMA);
setState(557);
expression(0);
}
}
setState(560);
match(RR_BRACKET);
}
break;
case CURRENT_TIMESTAMP:
_localctx = new CURRENT_TIMESTAMPContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(562);
match(CURRENT_TIMESTAMP);
}
break;
case CURRENT_USER:
_localctx = new CURRENT_USERContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(563);
match(CURRENT_USER);
}
break;
case DATEADD:
_localctx = new DATEADDContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(564);
match(DATEADD);
setState(565);
match(LR_BRACKET);
setState(566);
match(ID);
setState(567);
match(COMMA);
setState(568);
expression(0);
setState(569);
match(COMMA);
setState(570);
expression(0);
setState(571);
match(RR_BRACKET);
}
break;
case DATEDIFF:
_localctx = new DATEDIFFContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(573);
match(DATEDIFF);
setState(574);
match(LR_BRACKET);
setState(575);
match(ID);
setState(576);
match(COMMA);
setState(577);
expression(0);
setState(578);
match(COMMA);
setState(579);
expression(0);
setState(580);
match(RR_BRACKET);
}
break;
case DATENAME:
_localctx = new DATENAMEContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(582);
match(DATENAME);
setState(583);
match(LR_BRACKET);
setState(584);
match(ID);
setState(585);
match(COMMA);
setState(586);
expression(0);
setState(587);
match(RR_BRACKET);
}
break;
case DATEPART:
_localctx = new DATEPARTContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(589);
match(DATEPART);
setState(590);
match(LR_BRACKET);
setState(591);
match(ID);
setState(592);
match(COMMA);
setState(593);
expression(0);
setState(594);
match(RR_BRACKET);
}
break;
case MIN_ACTIVE_ROWVERSION:
_localctx = new MIN_ACTIVE_ROWVERSIONContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(596);
match(MIN_ACTIVE_ROWVERSION);
}
break;
case SESSION_USER:
_localctx = new SESSION_USERContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(597);
match(SESSION_USER);
}
break;
case SYSTEM_USER:
_localctx = new SYSTEM_USERContext(_localctx);
enterOuterAlt(_localctx, 11);
{
setState(598);
match(SYSTEM_USER);
}
break;
case IIF:
_localctx = new IFFContext(_localctx);
enterOuterAlt(_localctx, 12);
{
setState(599);
match(IIF);
setState(600);
match(LR_BRACKET);
setState(601);
search_condition();
setState(602);
match(COMMA);
setState(603);
expression(0);
setState(604);
match(COMMA);
setState(605);
expression(0);
setState(606);
match(RR_BRACKET);
}
break;
case COUNT:
case COUNT_BIG:
_localctx = new COUNTContext(_localctx);
enterOuterAlt(_localctx, 13);
{
setState(608);
_la = _input.LA(1);
if ( !(_la==COUNT || _la==COUNT_BIG) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(609);
match(LR_BRACKET);
setState(610);
match(STAR);
setState(611);
match(RR_BRACKET);
setState(613);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(612);
over_clause();
}
break;
}
}
break;
case ID:
_localctx = new ANY_FUNCContext(_localctx);
enterOuterAlt(_localctx, 14);
{
setState(615);
match(ID);
setState(616);
match(LR_BRACKET);
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(617);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(621);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CASE) | (1L << CONVERT) | (1L << CURRENT_TIMESTAMP) | (1L << CURRENT_USER) | (1L << IIF) | (1L << NULL) | (1L << OVER) | (1L << SESSION_USER) | (1L << SYSTEM_USER) | (1L << APPLY) | (1L << CAST))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (COUNT - 64)) | (1L << (COUNT_BIG - 64)) | (1L << (DATEADD - 64)) | (1L << (DATEDIFF - 64)) | (1L << (DATENAME - 64)) | (1L << (DATEPART - 64)) | (1L << (FIRST - 64)) | (1L << (FOLLOWING - 64)) | (1L << (MIN_ACTIVE_ROWVERSION - 64)) | (1L << (NEXT - 64)) | (1L << (OFFSET - 64)) | (1L << (ONLY - 64)) | (1L << (PARTITION - 64)) | (1L << (PRECEDING - 64)) | (1L << (RANGE - 64)) | (1L << (ROW - 64)) | (1L << (ROWGUID - 64)) | (1L << (ROWS - 64)) | (1L << (TIES - 64)) | (1L << (UNBOUNDED - 64)) | (1L << (DOUBLE_QUOTE_ID - 64)) | (1L << (SQUARE_BRACKET_ID - 64)) | (1L << (DECIMAL - 64)) | (1L << (ID - 64)) | (1L << (STRING - 64)) | (1L << (BINARY - 64)) | (1L << (FLOAT - 64)) | (1L << (REAL - 64)) | (1L << (DOLLAR - 64)) | (1L << (LR_BRACKET - 64)) | (1L << (PLUS - 64)) | (1L << (MINUS - 64)) | (1L << (BIT_NOT - 64)) | (1L << (PARAM - 64)))) != 0)) {
{
setState(620);
expression_list();
}
}
setState(623);
match(RR_BRACKET);
setState(631);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
{
setState(624);
match(WITHIN);
setState(625);
match(GROUP);
setState(626);
match(LR_BRACKET);
setState(627);
order_by_clause();
setState(628);
match(RR_BRACKET);
}
}
break;
case 2:
{
setState(630);
over_clause();
}
break;
}
}
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 Switch_sectionContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(SQLParser.WHEN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode THEN() { return getToken(SQLParser.THEN, 0); }
public Switch_sectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switch_section; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSwitch_section(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSwitch_section(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSwitch_section(this);
else return visitor.visitChildren(this);
}
}
public final Switch_sectionContext switch_section() throws RecognitionException {
Switch_sectionContext _localctx = new Switch_sectionContext(_ctx, getState());
enterRule(_localctx, 68, RULE_switch_section);
try {
enterOuterAlt(_localctx, 1);
{
setState(635);
match(WHEN);
setState(636);
expression(0);
setState(637);
match(THEN);
setState(638);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Switch_search_condition_sectionContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(SQLParser.WHEN, 0); }
public Search_conditionContext search_condition() {
return getRuleContext(Search_conditionContext.class,0);
}
public TerminalNode THEN() { return getToken(SQLParser.THEN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public Switch_search_condition_sectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switch_search_condition_section; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSwitch_search_condition_section(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSwitch_search_condition_section(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSwitch_search_condition_section(this);
else return visitor.visitChildren(this);
}
}
public final Switch_search_condition_sectionContext switch_search_condition_section() throws RecognitionException {
Switch_search_condition_sectionContext _localctx = new Switch_search_condition_sectionContext(_ctx, getState());
enterRule(_localctx, 70, RULE_switch_search_condition_section);
try {
enterOuterAlt(_localctx, 1);
{
setState(640);
match(WHEN);
setState(641);
search_condition();
setState(642);
match(THEN);
setState(643);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class As_column_aliasContext extends ParserRuleContext {
public Column_aliasContext column_alias() {
return getRuleContext(Column_aliasContext.class,0);
}
public TerminalNode AS() { return getToken(SQLParser.AS, 0); }
public As_column_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_as_column_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAs_column_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAs_column_alias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitAs_column_alias(this);
else return visitor.visitChildren(this);
}
}
public final As_column_aliasContext as_column_alias() throws RecognitionException {
As_column_aliasContext _localctx = new As_column_aliasContext(_ctx, getState());
enterRule(_localctx, 72, RULE_as_column_alias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(645);
match(AS);
}
}
setState(648);
column_alias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class As_table_aliasContext extends ParserRuleContext {
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode AS() { return getToken(SQLParser.AS, 0); }
public As_table_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_as_table_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAs_table_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAs_table_alias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitAs_table_alias(this);
else return visitor.visitChildren(this);
}
}
public final As_table_aliasContext as_table_alias() throws RecognitionException {
As_table_aliasContext _localctx = new As_table_aliasContext(_ctx, getState());
enterRule(_localctx, 74, RULE_as_table_alias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(651);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(650);
match(AS);
}
}
setState(653);
table_alias();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_aliasContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public Table_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_alias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_alias(this);
else return visitor.visitChildren(this);
}
}
public final Table_aliasContext table_alias() throws RecognitionException {
Table_aliasContext _localctx = new Table_aliasContext(_ctx, getState());
enterRule(_localctx, 76, RULE_table_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(655);
id();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_alias_listContext extends ParserRuleContext {
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public List column_alias() {
return getRuleContexts(Column_aliasContext.class);
}
public Column_aliasContext column_alias(int i) {
return getRuleContext(Column_aliasContext.class,i);
}
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Column_alias_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_alias_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterColumn_alias_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitColumn_alias_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitColumn_alias_list(this);
else return visitor.visitChildren(this);
}
}
public final Column_alias_listContext column_alias_list() throws RecognitionException {
Column_alias_listContext _localctx = new Column_alias_listContext(_ctx, getState());
enterRule(_localctx, 78, RULE_column_alias_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(657);
match(LR_BRACKET);
setState(658);
column_alias();
setState(663);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(659);
match(COMMA);
setState(660);
column_alias();
}
}
setState(665);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(666);
match(RR_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_aliasContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TerminalNode STRING() { return getToken(SQLParser.STRING, 0); }
public Column_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterColumn_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitColumn_alias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitColumn_alias(this);
else return visitor.visitChildren(this);
}
}
public final Column_aliasContext column_alias() throws RecognitionException {
Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState());
enterRule(_localctx, 80, RULE_column_alias);
try {
setState(670);
_errHandler.sync(this);
switch (_input.LA(1)) {
case APPLY:
case CAST:
case COUNT:
case COUNT_BIG:
case DATEADD:
case DATEDIFF:
case DATENAME:
case DATEPART:
case FIRST:
case FOLLOWING:
case MIN_ACTIVE_ROWVERSION:
case NEXT:
case OFFSET:
case ONLY:
case PARTITION:
case PRECEDING:
case RANGE:
case ROW:
case ROWGUID:
case ROWS:
case TIES:
case UNBOUNDED:
case DOUBLE_QUOTE_ID:
case SQUARE_BRACKET_ID:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(668);
id();
}
break;
case STRING:
enterOuterAlt(_localctx, 2);
{
setState(669);
match(STRING);
}
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_value_constructorContext extends ParserRuleContext {
public TerminalNode VALUES() { return getToken(SQLParser.VALUES, 0); }
public List LR_BRACKET() { return getTokens(SQLParser.LR_BRACKET); }
public TerminalNode LR_BRACKET(int i) {
return getToken(SQLParser.LR_BRACKET, i);
}
public List expression_list() {
return getRuleContexts(Expression_listContext.class);
}
public Expression_listContext expression_list(int i) {
return getRuleContext(Expression_listContext.class,i);
}
public List RR_BRACKET() { return getTokens(SQLParser.RR_BRACKET); }
public TerminalNode RR_BRACKET(int i) {
return getToken(SQLParser.RR_BRACKET, i);
}
public List COMMA() { return getTokens(SQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(SQLParser.COMMA, i);
}
public Table_value_constructorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_value_constructor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterTable_value_constructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitTable_value_constructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_value_constructor(this);
else return visitor.visitChildren(this);
}
}
public final Table_value_constructorContext table_value_constructor() throws RecognitionException {
Table_value_constructorContext _localctx = new Table_value_constructorContext(_ctx, getState());
enterRule(_localctx, 82, RULE_table_value_constructor);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(672);
match(VALUES);
setState(673);
match(LR_BRACKET);
setState(674);
expression_list();
setState(675);
match(RR_BRACKET);
setState(683);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(676);
match(COMMA);
setState(677);
match(LR_BRACKET);
setState(678);
expression_list();
setState(679);
match(RR_BRACKET);
}
}
}
setState(685);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,76,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Expression_listContext 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 Expression_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterExpression_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitExpression_list(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitExpression_list(this);
else return visitor.visitChildren(this);
}
}
public final Expression_listContext expression_list() throws RecognitionException {
Expression_listContext _localctx = new Expression_listContext(_ctx, getState());
enterRule(_localctx, 84, RULE_expression_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(686);
expression(0);
setState(691);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(687);
match(COMMA);
setState(688);
expression(0);
}
}
setState(693);
_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 Over_clauseContext extends ParserRuleContext {
public TerminalNode OVER() { return getToken(SQLParser.OVER, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public TerminalNode PARTITION() { return getToken(SQLParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(SQLParser.BY, 0); }
public Expression_listContext expression_list() {
return getRuleContext(Expression_listContext.class,0);
}
public Order_by_clauseContext order_by_clause() {
return getRuleContext(Order_by_clauseContext.class,0);
}
public Row_or_range_clauseContext row_or_range_clause() {
return getRuleContext(Row_or_range_clauseContext.class,0);
}
public Over_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_over_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterOver_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitOver_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitOver_clause(this);
else return visitor.visitChildren(this);
}
}
public final Over_clauseContext over_clause() throws RecognitionException {
Over_clauseContext _localctx = new Over_clauseContext(_ctx, getState());
enterRule(_localctx, 86, RULE_over_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(694);
match(OVER);
setState(695);
match(LR_BRACKET);
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(696);
match(PARTITION);
setState(697);
match(BY);
setState(698);
expression_list();
}
}
setState(702);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(701);
order_by_clause();
}
}
setState(705);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RANGE || _la==ROWS) {
{
setState(704);
row_or_range_clause();
}
}
setState(707);
match(RR_BRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Row_or_range_clauseContext extends ParserRuleContext {
public Window_frame_extentContext window_frame_extent() {
return getRuleContext(Window_frame_extentContext.class,0);
}
public TerminalNode ROWS() { return getToken(SQLParser.ROWS, 0); }
public TerminalNode RANGE() { return getToken(SQLParser.RANGE, 0); }
public Row_or_range_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_row_or_range_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterRow_or_range_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitRow_or_range_clause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitRow_or_range_clause(this);
else return visitor.visitChildren(this);
}
}
public final Row_or_range_clauseContext row_or_range_clause() throws RecognitionException {
Row_or_range_clauseContext _localctx = new Row_or_range_clauseContext(_ctx, getState());
enterRule(_localctx, 88, RULE_row_or_range_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(709);
_la = _input.LA(1);
if ( !(_la==RANGE || _la==ROWS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(710);
window_frame_extent();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Window_frame_extentContext extends ParserRuleContext {
public Window_frame_precedingContext window_frame_preceding() {
return getRuleContext(Window_frame_precedingContext.class,0);
}
public TerminalNode BETWEEN() { return getToken(SQLParser.BETWEEN, 0); }
public List window_frame_bound() {
return getRuleContexts(Window_frame_boundContext.class);
}
public Window_frame_boundContext window_frame_bound(int i) {
return getRuleContext(Window_frame_boundContext.class,i);
}
public TerminalNode AND() { return getToken(SQLParser.AND, 0); }
public Window_frame_extentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_frame_extent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterWindow_frame_extent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitWindow_frame_extent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitWindow_frame_extent(this);
else return visitor.visitChildren(this);
}
}
public final Window_frame_extentContext window_frame_extent() throws RecognitionException {
Window_frame_extentContext _localctx = new Window_frame_extentContext(_ctx, getState());
enterRule(_localctx, 90, RULE_window_frame_extent);
try {
setState(718);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CURRENT:
case UNBOUNDED:
case DECIMAL:
enterOuterAlt(_localctx, 1);
{
setState(712);
window_frame_preceding();
}
break;
case BETWEEN:
enterOuterAlt(_localctx, 2);
{
setState(713);
match(BETWEEN);
setState(714);
window_frame_bound();
setState(715);
match(AND);
setState(716);
window_frame_bound();
}
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 Window_frame_boundContext extends ParserRuleContext {
public Window_frame_precedingContext window_frame_preceding() {
return getRuleContext(Window_frame_precedingContext.class,0);
}
public Window_frame_followingContext window_frame_following() {
return getRuleContext(Window_frame_followingContext.class,0);
}
public Window_frame_boundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_frame_bound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterWindow_frame_bound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitWindow_frame_bound(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitWindow_frame_bound(this);
else return visitor.visitChildren(this);
}
}
public final Window_frame_boundContext window_frame_bound() throws RecognitionException {
Window_frame_boundContext _localctx = new Window_frame_boundContext(_ctx, getState());
enterRule(_localctx, 92, RULE_window_frame_bound);
try {
setState(722);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(720);
window_frame_preceding();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(721);
window_frame_following();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Window_frame_precedingContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(SQLParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(SQLParser.PRECEDING, 0); }
public TerminalNode DECIMAL() { return getToken(SQLParser.DECIMAL, 0); }
public TerminalNode CURRENT() { return getToken(SQLParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(SQLParser.ROW, 0); }
public Window_frame_precedingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_frame_preceding; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterWindow_frame_preceding(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitWindow_frame_preceding(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitWindow_frame_preceding(this);
else return visitor.visitChildren(this);
}
}
public final Window_frame_precedingContext window_frame_preceding() throws RecognitionException {
Window_frame_precedingContext _localctx = new Window_frame_precedingContext(_ctx, getState());
enterRule(_localctx, 94, RULE_window_frame_preceding);
try {
setState(730);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNBOUNDED:
enterOuterAlt(_localctx, 1);
{
setState(724);
match(UNBOUNDED);
setState(725);
match(PRECEDING);
}
break;
case DECIMAL:
enterOuterAlt(_localctx, 2);
{
setState(726);
match(DECIMAL);
setState(727);
match(PRECEDING);
}
break;
case CURRENT:
enterOuterAlt(_localctx, 3);
{
setState(728);
match(CURRENT);
setState(729);
match(ROW);
}
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 Window_frame_followingContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(SQLParser.UNBOUNDED, 0); }
public TerminalNode FOLLOWING() { return getToken(SQLParser.FOLLOWING, 0); }
public TerminalNode DECIMAL() { return getToken(SQLParser.DECIMAL, 0); }
public Window_frame_followingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_window_frame_following; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterWindow_frame_following(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitWindow_frame_following(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitWindow_frame_following(this);
else return visitor.visitChildren(this);
}
}
public final Window_frame_followingContext window_frame_following() throws RecognitionException {
Window_frame_followingContext _localctx = new Window_frame_followingContext(_ctx, getState());
enterRule(_localctx, 96, RULE_window_frame_following);
try {
setState(736);
_errHandler.sync(this);
switch (_input.LA(1)) {
case UNBOUNDED:
enterOuterAlt(_localctx, 1);
{
setState(732);
match(UNBOUNDED);
setState(733);
match(FOLLOWING);
}
break;
case DECIMAL:
enterOuterAlt(_localctx, 2);
{
setState(734);
match(DECIMAL);
setState(735);
match(FOLLOWING);
}
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 List id() {
return getRuleContexts(IdContext.class);
}
public IdContext id(int i) {
return getRuleContext(IdContext.class,i);
}
public List DOT() { return getTokens(SQLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(SQLParser.DOT, i);
}
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);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitTable_name(this);
else return visitor.visitChildren(this);
}
}
public final Table_nameContext table_name() throws RecognitionException {
Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
enterRule(_localctx, 98, RULE_table_name);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(738);
id();
setState(743);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(739);
match(DOT);
setState(740);
id();
}
}
}
setState(745);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Full_column_nameContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode DOT() { return getToken(SQLParser.DOT, 0); }
public Full_column_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_full_column_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterFull_column_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitFull_column_name(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitFull_column_name(this);
else return visitor.visitChildren(this);
}
}
public final Full_column_nameContext full_column_name() throws RecognitionException {
Full_column_nameContext _localctx = new Full_column_nameContext(_ctx, getState());
enterRule(_localctx, 100, RULE_full_column_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(749);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(746);
table_name();
setState(747);
match(DOT);
}
break;
}
setState(751);
id();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Null_notnullContext extends ParserRuleContext {
public TerminalNode NULL() { return getToken(SQLParser.NULL, 0); }
public TerminalNode NOT() { return getToken(SQLParser.NOT, 0); }
public Null_notnullContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_null_notnull; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterNull_notnull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitNull_notnull(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitNull_notnull(this);
else return visitor.visitChildren(this);
}
}
public final Null_notnullContext null_notnull() throws RecognitionException {
Null_notnullContext _localctx = new Null_notnullContext(_ctx, getState());
enterRule(_localctx, 102, RULE_null_notnull);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(754);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(753);
match(NOT);
}
}
setState(756);
match(NULL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Data_typeContext extends ParserRuleContext {
public IdContext id() {
return getRuleContext(IdContext.class,0);
}
public TerminalNode IDENTITY() { return getToken(SQLParser.IDENTITY, 0); }
public TerminalNode LR_BRACKET() { return getToken(SQLParser.LR_BRACKET, 0); }
public TerminalNode RR_BRACKET() { return getToken(SQLParser.RR_BRACKET, 0); }
public List DECIMAL() { return getTokens(SQLParser.DECIMAL); }
public TerminalNode DECIMAL(int i) {
return getToken(SQLParser.DECIMAL, i);
}
public TerminalNode MAX() { return getToken(SQLParser.MAX, 0); }
public TerminalNode COMMA() { return getToken(SQLParser.COMMA, 0); }
public TerminalNode DOUBLE() { return getToken(SQLParser.DOUBLE, 0); }
public TerminalNode PRECISION() { return getToken(SQLParser.PRECISION, 0); }
public Data_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_data_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterData_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitData_type(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitData_type(this);
else return visitor.visitChildren(this);
}
}
public final Data_typeContext data_type() throws RecognitionException {
Data_typeContext _localctx = new Data_typeContext(_ctx, getState());
enterRule(_localctx, 104, RULE_data_type);
int _la;
try {
setState(775);
_errHandler.sync(this);
switch (_input.LA(1)) {
case APPLY:
case CAST:
case COUNT:
case COUNT_BIG:
case DATEADD:
case DATEDIFF:
case DATENAME:
case DATEPART:
case FIRST:
case FOLLOWING:
case MIN_ACTIVE_ROWVERSION:
case NEXT:
case OFFSET:
case ONLY:
case PARTITION:
case PRECEDING:
case RANGE:
case ROW:
case ROWGUID:
case ROWS:
case TIES:
case UNBOUNDED:
case DOUBLE_QUOTE_ID:
case SQUARE_BRACKET_ID:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(758);
id();
setState(760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTITY) {
{
setState(759);
match(IDENTITY);
}
}
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LR_BRACKET) {
{
setState(762);
match(LR_BRACKET);
setState(763);
_la = _input.LA(1);
if ( !(_la==MAX || _la==DECIMAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(766);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(764);
match(COMMA);
setState(765);
match(DECIMAL);
}
}
setState(768);
match(RR_BRACKET);
}
}
}
break;
case DOUBLE:
enterOuterAlt(_localctx, 2);
{
setState(771);
match(DOUBLE);
setState(773);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRECISION) {
{
setState(772);
match(PRECISION);
}
}
}
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 ConstantContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(SQLParser.STRING, 0); }
public TerminalNode BINARY() { return getToken(SQLParser.BINARY, 0); }
public TerminalNode DECIMAL() { return getToken(SQLParser.DECIMAL, 0); }
public SignContext sign() {
return getRuleContext(SignContext.class,0);
}
public TerminalNode REAL() { return getToken(SQLParser.REAL, 0); }
public TerminalNode FLOAT() { return getToken(SQLParser.FLOAT, 0); }
public TerminalNode DOLLAR() { return getToken(SQLParser.DOLLAR, 0); }
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitConstant(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 106, RULE_constant);
int _la;
try {
setState(792);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(777);
match(STRING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(778);
match(BINARY);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(780);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(779);
sign();
}
}
setState(782);
match(DECIMAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(783);
sign();
}
}
setState(786);
_la = _input.LA(1);
if ( !(_la==FLOAT || _la==REAL) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(788);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(787);
sign();
}
}
setState(790);
match(DOLLAR);
setState(791);
_la = _input.LA(1);
if ( !(_la==DECIMAL || _la==FLOAT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SignContext extends ParserRuleContext {
public TerminalNode PLUS() { return getToken(SQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SQLParser.MINUS, 0); }
public SignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSign(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSign(this);
else return visitor.visitChildren(this);
}
}
public final SignContext sign() throws RecognitionException {
SignContext _localctx = new SignContext(_ctx, getState());
enterRule(_localctx, 108, RULE_sign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(794);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_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 IdContext extends ParserRuleContext {
public Simple_idContext simple_id() {
return getRuleContext(Simple_idContext.class,0);
}
public TerminalNode DOUBLE_QUOTE_ID() { return getToken(SQLParser.DOUBLE_QUOTE_ID, 0); }
public TerminalNode SQUARE_BRACKET_ID() { return getToken(SQLParser.SQUARE_BRACKET_ID, 0); }
public IdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_id; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitId(this);
else return visitor.visitChildren(this);
}
}
public final IdContext id() throws RecognitionException {
IdContext _localctx = new IdContext(_ctx, getState());
enterRule(_localctx, 110, RULE_id);
try {
setState(799);
_errHandler.sync(this);
switch (_input.LA(1)) {
case APPLY:
case CAST:
case COUNT:
case COUNT_BIG:
case DATEADD:
case DATEDIFF:
case DATENAME:
case DATEPART:
case FIRST:
case FOLLOWING:
case MIN_ACTIVE_ROWVERSION:
case NEXT:
case OFFSET:
case ONLY:
case PARTITION:
case PRECEDING:
case RANGE:
case ROW:
case ROWGUID:
case ROWS:
case TIES:
case UNBOUNDED:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(796);
simple_id();
}
break;
case DOUBLE_QUOTE_ID:
enterOuterAlt(_localctx, 2);
{
setState(797);
match(DOUBLE_QUOTE_ID);
}
break;
case SQUARE_BRACKET_ID:
enterOuterAlt(_localctx, 3);
{
setState(798);
match(SQUARE_BRACKET_ID);
}
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 Simple_idContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(SQLParser.ID, 0); }
public TerminalNode APPLY() { return getToken(SQLParser.APPLY, 0); }
public TerminalNode CAST() { return getToken(SQLParser.CAST, 0); }
public TerminalNode COUNT() { return getToken(SQLParser.COUNT, 0); }
public TerminalNode COUNT_BIG() { return getToken(SQLParser.COUNT_BIG, 0); }
public TerminalNode DATEADD() { return getToken(SQLParser.DATEADD, 0); }
public TerminalNode DATEDIFF() { return getToken(SQLParser.DATEDIFF, 0); }
public TerminalNode DATENAME() { return getToken(SQLParser.DATENAME, 0); }
public TerminalNode DATEPART() { return getToken(SQLParser.DATEPART, 0); }
public TerminalNode FIRST() { return getToken(SQLParser.FIRST, 0); }
public TerminalNode FOLLOWING() { return getToken(SQLParser.FOLLOWING, 0); }
public TerminalNode MIN_ACTIVE_ROWVERSION() { return getToken(SQLParser.MIN_ACTIVE_ROWVERSION, 0); }
public TerminalNode NEXT() { return getToken(SQLParser.NEXT, 0); }
public TerminalNode OFFSET() { return getToken(SQLParser.OFFSET, 0); }
public TerminalNode ONLY() { return getToken(SQLParser.ONLY, 0); }
public TerminalNode PARTITION() { return getToken(SQLParser.PARTITION, 0); }
public TerminalNode PRECEDING() { return getToken(SQLParser.PRECEDING, 0); }
public TerminalNode RANGE() { return getToken(SQLParser.RANGE, 0); }
public TerminalNode ROW() { return getToken(SQLParser.ROW, 0); }
public TerminalNode ROWGUID() { return getToken(SQLParser.ROWGUID, 0); }
public TerminalNode ROWS() { return getToken(SQLParser.ROWS, 0); }
public TerminalNode TIES() { return getToken(SQLParser.TIES, 0); }
public TerminalNode UNBOUNDED() { return getToken(SQLParser.UNBOUNDED, 0); }
public Simple_idContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_id; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterSimple_id(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitSimple_id(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitSimple_id(this);
else return visitor.visitChildren(this);
}
}
public final Simple_idContext simple_id() throws RecognitionException {
Simple_idContext _localctx = new Simple_idContext(_ctx, getState());
enterRule(_localctx, 112, RULE_simple_id);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(801);
_la = _input.LA(1);
if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (APPLY - 62)) | (1L << (CAST - 62)) | (1L << (COUNT - 62)) | (1L << (COUNT_BIG - 62)) | (1L << (DATEADD - 62)) | (1L << (DATEDIFF - 62)) | (1L << (DATENAME - 62)) | (1L << (DATEPART - 62)) | (1L << (FIRST - 62)) | (1L << (FOLLOWING - 62)) | (1L << (MIN_ACTIVE_ROWVERSION - 62)) | (1L << (NEXT - 62)) | (1L << (OFFSET - 62)) | (1L << (ONLY - 62)) | (1L << (PARTITION - 62)) | (1L << (PRECEDING - 62)) | (1L << (RANGE - 62)) | (1L << (ROW - 62)) | (1L << (ROWGUID - 62)) | (1L << (ROWS - 62)) | (1L << (TIES - 62)) | (1L << (UNBOUNDED - 62)) | (1L << (ID - 62)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Comparison_operatorContext extends ParserRuleContext {
public TerminalNode EQUAL() { return getToken(SQLParser.EQUAL, 0); }
public TerminalNode GREATER() { return getToken(SQLParser.GREATER, 0); }
public TerminalNode LESS() { return getToken(SQLParser.LESS, 0); }
public TerminalNode EXCLAMATION() { return getToken(SQLParser.EXCLAMATION, 0); }
public Comparison_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparison_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterComparison_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitComparison_operator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitComparison_operator(this);
else return visitor.visitChildren(this);
}
}
public final Comparison_operatorContext comparison_operator() throws RecognitionException {
Comparison_operatorContext _localctx = new Comparison_operatorContext(_ctx, getState());
enterRule(_localctx, 114, RULE_comparison_operator);
try {
setState(818);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(803);
match(EQUAL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(804);
match(GREATER);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(805);
match(LESS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(806);
match(LESS);
setState(807);
match(EQUAL);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(808);
match(GREATER);
setState(809);
match(EQUAL);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(810);
match(LESS);
setState(811);
match(GREATER);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(812);
match(EXCLAMATION);
setState(813);
match(EQUAL);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(814);
match(EXCLAMATION);
setState(815);
match(GREATER);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(816);
match(EXCLAMATION);
setState(817);
match(LESS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Assignment_operatorContext extends ParserRuleContext {
public TerminalNode PLUS_ASSIGN() { return getToken(SQLParser.PLUS_ASSIGN, 0); }
public TerminalNode MINUS_ASSIGN() { return getToken(SQLParser.MINUS_ASSIGN, 0); }
public TerminalNode MULT_ASSIGN() { return getToken(SQLParser.MULT_ASSIGN, 0); }
public TerminalNode DIV_ASSIGN() { return getToken(SQLParser.DIV_ASSIGN, 0); }
public TerminalNode MOD_ASSIGN() { return getToken(SQLParser.MOD_ASSIGN, 0); }
public TerminalNode AND_ASSIGN() { return getToken(SQLParser.AND_ASSIGN, 0); }
public TerminalNode XOR_ASSIGN() { return getToken(SQLParser.XOR_ASSIGN, 0); }
public TerminalNode OR_ASSIGN() { return getToken(SQLParser.OR_ASSIGN, 0); }
public Assignment_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).enterAssignment_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SQLParserListener ) ((SQLParserListener)listener).exitAssignment_operator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SQLParserVisitor ) return ((SQLParserVisitor)visitor).visitAssignment_operator(this);
else return visitor.visitChildren(this);
}
}
public final Assignment_operatorContext assignment_operator() throws RecognitionException {
Assignment_operatorContext _localctx = new Assignment_operatorContext(_ctx, getState());
enterRule(_localctx, 116, RULE_assignment_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(820);
_la = _input.LA(1);
if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (PLUS_ASSIGN - 101)) | (1L << (MINUS_ASSIGN - 101)) | (1L << (MULT_ASSIGN - 101)) | (1L << (DIV_ASSIGN - 101)) | (1L << (MOD_ASSIGN - 101)) | (1L << (AND_ASSIGN - 101)) | (1L << (XOR_ASSIGN - 101)) | (1L << (OR_ASSIGN - 101)))) != 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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 2:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 5);
case 1:
return precpred(_ctx, 4);
case 2:
return precpred(_ctx, 3);
case 3:
return precpred(_ctx, 2);
case 4:
return precpred(_ctx, 10);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0080\u0339\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*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\3\2\3"+
"\2\3\2\3\3\3\3\3\3\3\3\5\3\u0080\n\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\3\4\5\4\u008c\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\3\4\3\4\3\4\3\4\7\4\u009f\n\4\f\4\16\4\u00a2\13\4\3\5\3\5\3\5\5\5\u00a7"+
"\n\5\3\6\3\6\3\6\6\6\u00ac\n\6\r\6\16\6\u00ad\3\6\3\6\5\6\u00b2\n\6\3"+
"\6\3\6\3\6\3\6\6\6\u00b8\n\6\r\6\16\6\u00b9\3\6\3\6\5\6\u00be\n\6\3\6"+
"\3\6\5\6\u00c2\n\6\3\7\3\7\3\7\3\7\5\7\u00c8\n\7\3\b\3\b\3\b\3\b\3\b\3"+
"\b\3\b\3\b\5\b\u00d2\n\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00db\n\t\3\n"+
"\3\n\5\n\u00df\n\n\3\13\3\13\3\f\3\f\3\f\7\f\u00e6\n\f\f\f\16\f\u00e9"+
"\13\f\3\r\3\r\3\r\7\r\u00ee\n\r\f\r\16\r\u00f1\13\r\3\16\5\16\u00f4\n"+
"\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3"+
"\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u010a\n\17\3\17\3\17\3\17\3\17"+
"\3\17\3\17\3\17\5\17\u0113\n\17\3\17\3\17\3\17\3\17\5\17\u0119\n\17\3"+
"\17\3\17\3\17\3\17\5\17\u011f\n\17\3\17\3\17\3\17\3\17\5\17\u0125\n\17"+
"\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u012f\n\17\3\20\3\20\3\20"+
"\3\20\3\20\5\20\u0136\n\20\3\20\7\20\u0139\n\20\f\20\16\20\u013c\13\20"+
"\3\21\3\21\5\21\u0140\n\21\3\21\3\21\5\21\u0144\n\21\3\21\3\21\3\21\3"+
"\21\3\21\5\21\u014b\n\21\3\22\3\22\5\22\u014f\n\22\3\22\5\22\u0152\n\22"+
"\3\22\3\22\3\22\5\22\u0157\n\22\3\22\3\22\5\22\u015b\n\22\3\22\3\22\3"+
"\22\5\22\u0160\n\22\3\22\3\22\3\22\7\22\u0165\n\22\f\22\16\22\u0168\13"+
"\22\5\22\u016a\n\22\3\22\3\22\5\22\u016e\n\22\3\23\3\23\3\23\5\23\u0173"+
"\n\23\3\23\3\23\5\23\u0177\n\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\5\24"+
"\u0180\n\24\3\25\3\25\3\25\3\25\3\25\5\25\u0187\n\25\3\26\3\26\3\26\3"+
"\26\3\26\7\26\u018e\n\26\f\26\16\26\u0191\13\26\3\26\3\26\3\26\3\26\3"+
"\26\3\26\3\26\3\26\3\26\5\26\u019c\n\26\3\26\3\26\3\26\3\26\3\26\5\26"+
"\u01a3\n\26\3\27\3\27\5\27\u01a7\n\27\3\30\3\30\3\31\3\31\3\31\7\31\u01ae"+
"\n\31\f\31\16\31\u01b1\13\31\3\32\3\32\3\32\5\32\u01b6\n\32\3\32\3\32"+
"\3\32\3\32\3\32\5\32\u01bd\n\32\3\32\5\32\u01c0\n\32\3\32\5\32\u01c3\n"+
"\32\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u01cb\n\33\5\33\u01cd\n\33\3\34"+
"\3\34\3\34\5\34\u01d2\n\34\3\35\3\35\3\35\7\35\u01d7\n\35\f\35\16\35\u01da"+
"\13\35\3\36\3\36\3\36\3\36\3\36\5\36\u01e1\n\36\3\37\3\37\7\37\u01e5\n"+
"\37\f\37\16\37\u01e8\13\37\3 \3 \5 \u01ec\n \3 \3 \3 \5 \u01f1\n \5 \u01f3"+
"\n \3 \3 \3 \5 \u01f8\n \5 \u01fa\n \5 \u01fc\n \3!\5!\u01ff\n!\3!\3!"+
"\5!\u0203\n!\5!\u0205\n!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!"+
"\u0215\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0221\n\"\3#\3#"+
"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0231\n#\3#\3#\3#\3#\3#\3#\3#"+
"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#"+
"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#"+
"\5#\u0268\n#\3#\3#\3#\5#\u026d\n#\3#\5#\u0270\n#\3#\3#\3#\3#\3#\3#\3#"+
"\3#\5#\u027a\n#\5#\u027c\n#\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3&\5&\u0289"+
"\n&\3&\3&\3\'\5\'\u028e\n\'\3\'\3\'\3(\3(\3)\3)\3)\3)\7)\u0298\n)\f)\16"+
")\u029b\13)\3)\3)\3*\3*\5*\u02a1\n*\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u02ac"+
"\n+\f+\16+\u02af\13+\3,\3,\3,\7,\u02b4\n,\f,\16,\u02b7\13,\3-\3-\3-\3"+
"-\3-\5-\u02be\n-\3-\5-\u02c1\n-\3-\5-\u02c4\n-\3-\3-\3.\3.\3.\3/\3/\3"+
"/\3/\3/\3/\5/\u02d1\n/\3\60\3\60\5\60\u02d5\n\60\3\61\3\61\3\61\3\61\3"+
"\61\3\61\5\61\u02dd\n\61\3\62\3\62\3\62\3\62\5\62\u02e3\n\62\3\63\3\63"+
"\3\63\7\63\u02e8\n\63\f\63\16\63\u02eb\13\63\3\64\3\64\3\64\5\64\u02f0"+
"\n\64\3\64\3\64\3\65\5\65\u02f5\n\65\3\65\3\65\3\66\3\66\5\66\u02fb\n"+
"\66\3\66\3\66\3\66\3\66\5\66\u0301\n\66\3\66\5\66\u0304\n\66\3\66\3\66"+
"\5\66\u0308\n\66\5\66\u030a\n\66\3\67\3\67\3\67\5\67\u030f\n\67\3\67\3"+
"\67\5\67\u0313\n\67\3\67\3\67\5\67\u0317\n\67\3\67\3\67\5\67\u031b\n\67"+
"\38\38\39\39\39\59\u0322\n9\3:\3:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;"+
"\3;\3;\3;\5;\u0335\n;\3<\3<\3<\2\3\6=\2\4\6\b\n\f\16\20\22\24\26\30\32"+
"\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtv\2\22\3\2"+
"uw\5\2ooxy{}\3\2xy\5\2\3\3\5\5\66\66\4\2\3\3\24\24\3\2ab\4\2RRTT\4\2H"+
"HLL\4\2\7\7\23\23\5\2\35\35\'\'\62\62\3\2BC\4\2QQTT\4\2JJ]]\4\2]]aa\5"+
"\2@IKV^^\3\2gn\2\u0393\2x\3\2\2\2\4{\3\2\2\2\6\u008b\3\2\2\2\b\u00a6\3"+
"\2\2\2\n\u00c1\3\2\2\2\f\u00c7\3\2\2\2\16\u00d1\3\2\2\2\20\u00da\3\2\2"+
"\2\22\u00dc\3\2\2\2\24\u00e0\3\2\2\2\26\u00e2\3\2\2\2\30\u00ea\3\2\2\2"+
"\32\u00f3\3\2\2\2\34\u012e\3\2\2\2\36\u0135\3\2\2\2 \u0143\3\2\2\2\"\u014c"+
"\3\2\2\2$\u016f\3\2\2\2&\u017f\3\2\2\2(\u0186\3\2\2\2*\u0188\3\2\2\2,"+
"\u01a4\3\2\2\2.\u01a8\3\2\2\2\60\u01aa\3\2\2\2\62\u01bf\3\2\2\2\64\u01cc"+
"\3\2\2\2\66\u01d1\3\2\2\28\u01d3\3\2\2\2:\u01e0\3\2\2\2<\u01e2\3\2\2\2"+
">\u01fb\3\2\2\2@\u0214\3\2\2\2B\u0220\3\2\2\2D\u027b\3\2\2\2F\u027d\3"+
"\2\2\2H\u0282\3\2\2\2J\u0288\3\2\2\2L\u028d\3\2\2\2N\u0291\3\2\2\2P\u0293"+
"\3\2\2\2R\u02a0\3\2\2\2T\u02a2\3\2\2\2V\u02b0\3\2\2\2X\u02b8\3\2\2\2Z"+
"\u02c7\3\2\2\2\\\u02d0\3\2\2\2^\u02d4\3\2\2\2`\u02dc\3\2\2\2b\u02e2\3"+
"\2\2\2d\u02e4\3\2\2\2f\u02ef\3\2\2\2h\u02f4\3\2\2\2j\u0309\3\2\2\2l\u031a"+
"\3\2\2\2n\u031c\3\2\2\2p\u0321\3\2\2\2r\u0323\3\2\2\2t\u0334\3\2\2\2v"+
"\u0336\3\2\2\2xy\5\22\n\2yz\7\2\2\3z\3\3\2\2\2{|\7\34\2\2|\177\58\35\2"+
"}~\7=\2\2~\u0080\5\26\f\2\177}\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\3"+
"\2\2\2\u0081\u0082\7\2\2\3\u0082\5\3\2\2\2\u0083\u0084\b\4\1\2\u0084\u008c"+
"\5\b\5\2\u0085\u008c\5D#\2\u0086\u008c\5\n\6\2\u0087\u008c\5f\64\2\u0088"+
"\u008c\5\16\b\2\u0089\u008c\5\f\7\2\u008a\u008c\5X-\2\u008b\u0083\3\2"+
"\2\2\u008b\u0085\3\2\2\2\u008b\u0086\3\2\2\2\u008b\u0087\3\2\2\2\u008b"+
"\u0088\3\2\2\2\u008b\u0089\3\2\2\2\u008b\u008a\3\2\2\2\u008c\u00a0\3\2"+
"\2\2\u008d\u008e\f\7\2\2\u008e\u008f\t\2\2\2\u008f\u009f\5\6\4\b\u0090"+
"\u0091\f\6\2\2\u0091\u0092\t\3\2\2\u0092\u009f\5\6\4\7\u0093\u0094\f\5"+
"\2\2\u0094\u0095\5t;\2\u0095\u0096\5\6\4\6\u0096\u009f\3\2\2\2\u0097\u0098"+
"\f\4\2\2\u0098\u0099\5v<\2\u0099\u009a\5\6\4\5\u009a\u009f\3\2\2\2\u009b"+
"\u009c\f\f\2\2\u009c\u009d\7\13\2\2\u009d\u009f\5p9\2\u009e\u008d\3\2"+
"\2\2\u009e\u0090\3\2\2\2\u009e\u0093\3\2\2\2\u009e\u0097\3\2\2\2\u009e"+
"\u009b\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u00a1\3\2"+
"\2\2\u00a1\7\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a7\7*\2\2\u00a4\u00a7"+
"\5l\67\2\u00a5\u00a7\7~\2\2\u00a6\u00a3\3\2\2\2\u00a6\u00a4\3\2\2\2\u00a6"+
"\u00a5\3\2\2\2\u00a7\t\3\2\2\2\u00a8\u00a9\7\n\2\2\u00a9\u00ab\5\6\4\2"+
"\u00aa\u00ac\5F$\2\u00ab\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00ab"+
"\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af\u00b0\7\26\2\2"+
"\u00b0\u00b2\5\6\4\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3"+
"\3\2\2\2\u00b3\u00b4\7\27\2\2\u00b4\u00c2\3\2\2\2\u00b5\u00b7\7\n\2\2"+
"\u00b6\u00b8\5H%\2\u00b7\u00b6\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00b7"+
"\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00bc\7\26\2\2"+
"\u00bc\u00be\5\6\4\2\u00bd\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf"+
"\3\2\2\2\u00bf\u00c0\7\27\2\2\u00c0\u00c2\3\2\2\2\u00c1\u00a8\3\2\2\2"+
"\u00c1\u00b5\3\2\2\2\u00c2\13\3\2\2\2\u00c3\u00c4\7z\2\2\u00c4\u00c8\5"+
"\6\4\2\u00c5\u00c6\t\4\2\2\u00c6\u00c8\5\6\4\2\u00c7\u00c3\3\2\2\2\u00c7"+
"\u00c5\3\2\2\2\u00c8\r\3\2\2\2\u00c9\u00ca\7r\2\2\u00ca\u00cb\5\6\4\2"+
"\u00cb\u00cc\7s\2\2\u00cc\u00d2\3\2\2\2\u00cd\u00ce\7r\2\2\u00ce\u00cf"+
"\5\24\13\2\u00cf\u00d0\7s\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00c9\3\2\2\2"+
"\u00d1\u00cd\3\2\2\2\u00d2\17\3\2\2\2\u00d3\u00db\7*\2\2\u00d4\u00db\5"+
"l\67\2\u00d5\u00db\5D#\2\u00d6\u00d7\7r\2\2\u00d7\u00d8\5\20\t\2\u00d8"+
"\u00d9\7s\2\2\u00d9\u00db\3\2\2\2\u00da\u00d3\3\2\2\2\u00da\u00d4\3\2"+
"\2\2\u00da\u00d5\3\2\2\2\u00da\u00d6\3\2\2\2\u00db\21\3\2\2\2\u00dc\u00de"+
"\5\36\20\2\u00dd\u00df\5*\26\2\u00de\u00dd\3\2\2\2\u00de\u00df\3\2\2\2"+
"\u00df\23\3\2\2\2\u00e0\u00e1\5\22\n\2\u00e1\25\3\2\2\2\u00e2\u00e7\5"+
"\30\r\2\u00e3\u00e4\7,\2\2\u00e4\u00e6\5\30\r\2\u00e5\u00e3\3\2\2\2\u00e6"+
"\u00e9\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\27\3\2\2"+
"\2\u00e9\u00e7\3\2\2\2\u00ea\u00ef\5\32\16\2\u00eb\u00ec\7\4\2\2\u00ec"+
"\u00ee\5\32\16\2\u00ed\u00eb\3\2\2\2\u00ee\u00f1\3\2\2\2\u00ef\u00ed\3"+
"\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\31\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2"+
"\u00f4\7)\2\2\u00f3\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\3\2"+
"\2\2\u00f5\u00f6\5\34\17\2\u00f6\33\3\2\2\2\u00f7\u00f8\7\32\2\2\u00f8"+
"\u00f9\7r\2\2\u00f9\u00fa\5\24\13\2\u00fa\u00fb\7s\2\2\u00fb\u012f\3\2"+
"\2\2\u00fc\u00fd\5\6\4\2\u00fd\u00fe\5t;\2\u00fe\u00ff\5\6\4\2\u00ff\u012f"+
"\3\2\2\2\u0100\u0101\5\6\4\2\u0101\u0102\5t;\2\u0102\u0103\t\5\2\2\u0103"+
"\u0104\7r\2\2\u0104\u0105\5\24\13\2\u0105\u0106\7s\2\2\u0106\u012f\3\2"+
"\2\2\u0107\u0109\5\6\4\2\u0108\u010a\7)\2\2\u0109\u0108\3\2\2\2\u0109"+
"\u010a\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u010c\7\b\2\2\u010c\u010d\5\6"+
"\4\2\u010d\u010e\7\4\2\2\u010e\u010f\5\6\4\2\u010f\u012f\3\2\2\2\u0110"+
"\u0112\5\6\4\2\u0111\u0113\7)\2\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2"+
"\2\2\u0113\u0114\3\2\2\2\u0114\u0115\7\"\2\2\u0115\u0118\7r\2\2\u0116"+
"\u0119\5\24\13\2\u0117\u0119\5V,\2\u0118\u0116\3\2\2\2\u0118\u0117\3\2"+
"\2\2\u0119\u011a\3\2\2\2\u011a\u011b\7s\2\2\u011b\u012f\3\2\2\2\u011c"+
"\u011e\5\6\4\2\u011d\u011f\7)\2\2\u011e\u011d\3\2\2\2\u011e\u011f\3\2"+
"\2\2\u011f\u0120\3\2\2\2\u0120\u0121\7(\2\2\u0121\u0124\5\6\4\2\u0122"+
"\u0123\7\30\2\2\u0123\u0125\5\6\4\2\u0124\u0122\3\2\2\2\u0124\u0125\3"+
"\2\2\2\u0125\u012f\3\2\2\2\u0126\u0127\5\6\4\2\u0127\u0128\7%\2\2\u0128"+
"\u0129\5h\65\2\u0129\u012f\3\2\2\2\u012a\u012b\7r\2\2\u012b\u012c\5\26"+
"\f\2\u012c\u012d\7s\2\2\u012d\u012f\3\2\2\2\u012e\u00f7\3\2\2\2\u012e"+
"\u00fc\3\2\2\2\u012e\u0100\3\2\2\2\u012e\u0107\3\2\2\2\u012e\u0110\3\2"+
"\2\2\u012e\u011c\3\2\2\2\u012e\u0126\3\2\2\2\u012e\u012a\3\2\2\2\u012f"+
"\35\3\2\2\2\u0130\u0136\5\"\22\2\u0131\u0132\7r\2\2\u0132\u0133\5\36\20"+
"\2\u0133\u0134\7s\2\2\u0134\u0136\3\2\2\2\u0135\u0130\3\2\2\2\u0135\u0131"+
"\3\2\2\2\u0136\u013a\3\2\2\2\u0137\u0139\5 \21\2\u0138\u0137\3\2\2\2\u0139"+
"\u013c\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b\37\3\2\2"+
"\2\u013c\u013a\3\2\2\2\u013d\u013f\7:\2\2\u013e\u0140\7\3\2\2\u013f\u013e"+
"\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0144\3\2\2\2\u0141\u0144\7\31\2\2"+
"\u0142\u0144\7$\2\2\u0143\u013d\3\2\2\2\u0143\u0141\3\2\2\2\u0143\u0142"+
"\3\2\2\2\u0144\u014a\3\2\2\2\u0145\u014b\5\"\22\2\u0146\u0147\7r\2\2\u0147"+
"\u0148\5\36\20\2\u0148\u0149\7s\2\2\u0149\u014b\3\2\2\2\u014a\u0145\3"+
"\2\2\2\u014a\u0146\3\2\2\2\u014b!\3\2\2\2\u014c\u014e\7\63\2\2\u014d\u014f"+
"\t\6\2\2\u014e\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150"+
"\u0152\5$\23\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0153\3\2"+
"\2\2\u0153\u0156\5\60\31\2\u0154\u0155\7\34\2\2\u0155\u0157\58\35\2\u0156"+
"\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u015a\3\2\2\2\u0158\u0159\7="+
"\2\2\u0159\u015b\5\26\f\2\u015a\u0158\3\2\2\2\u015a\u015b\3\2\2\2\u015b"+
"\u0169\3\2\2\2\u015c\u015d\7\36\2\2\u015d\u015f\7\t\2\2\u015e\u0160\7"+
"\3\2\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0161\3\2\2\2\u0161"+
"\u0166\5.\30\2\u0162\u0163\7t\2\2\u0163\u0165\5.\30\2\u0164\u0162\3\2"+
"\2\2\u0165\u0168\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0167\3\2\2\2\u0167"+
"\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0169\u015c\3\2\2\2\u0169\u016a\3\2"+
"\2\2\u016a\u016d\3\2\2\2\u016b\u016c\7\37\2\2\u016c\u016e\5\26\f\2\u016d"+
"\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e#\3\2\2\2\u016f\u0172\79\2\2\u0170"+
"\u0173\5&\24\2\u0171\u0173\5(\25\2\u0172\u0170\3\2\2\2\u0172\u0171\3\2"+
"\2\2\u0173\u0176\3\2\2\2\u0174\u0175\7>\2\2\u0175\u0177\7U\2\2\u0176\u0174"+
"\3\2\2\2\u0176\u0177\3\2\2\2\u0177%\3\2\2\2\u0178\u0179\t\7\2\2\u0179"+
"\u0180\7\60\2\2\u017a\u017b\7r\2\2\u017b\u017c\5\6\4\2\u017c\u017d\7s"+
"\2\2\u017d\u017e\7\60\2\2\u017e\u0180\3\2\2\2\u017f\u0178\3\2\2\2\u017f"+
"\u017a\3\2\2\2\u0180\'\3\2\2\2\u0181\u0187\7]\2\2\u0182\u0183\7r\2\2\u0183"+
"\u0184\5\6\4\2\u0184\u0185\7s\2\2\u0185\u0187\3\2\2\2\u0186\u0181\3\2"+
"\2\2\u0186\u0182\3\2\2\2\u0187)\3\2\2\2\u0188\u0189\7-\2\2\u0189\u018a"+
"\7\t\2\2\u018a\u018f\5,\27\2\u018b\u018c\7t\2\2\u018c\u018e\5,\27\2\u018d"+
"\u018b\3\2\2\2\u018e\u0191\3\2\2\2\u018f\u018d\3\2\2\2\u018f\u0190\3\2"+
"\2\2\u0190\u01a2\3\2\2\2\u0191\u018f\3\2\2\2\u0192\u0193\7M\2\2\u0193"+
"\u0194\5\6\4\2\u0194\u019b\t\b\2\2\u0195\u0196\7\33\2\2\u0196\u0197\t"+
"\t\2\2\u0197\u0198\5\6\4\2\u0198\u0199\t\b\2\2\u0199\u019a\7N\2\2\u019a"+
"\u019c\3\2\2\2\u019b\u0195\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u01a3\3\2"+
"\2\2\u019d\u019e\7\u0080\2\2\u019e\u019f\5\6\4\2\u019f\u01a0\7M\2\2\u01a0"+
"\u01a1\5\6\4\2\u01a1\u01a3\3\2\2\2\u01a2\u0192\3\2\2\2\u01a2\u019d\3\2"+
"\2\2\u01a2\u01a3\3\2\2\2\u01a3+\3\2\2\2\u01a4\u01a6\5\6\4\2\u01a5\u01a7"+
"\t\n\2\2\u01a6\u01a5\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7-\3\2\2\2\u01a8"+
"\u01a9\5\6\4\2\u01a9/\3\2\2\2\u01aa\u01af\5\66\34\2\u01ab\u01ac\7t\2\2"+
"\u01ac\u01ae\5\66\34\2\u01ad\u01ab\3\2\2\2\u01ae\u01b1\3\2\2\2\u01af\u01ad"+
"\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\61\3\2\2\2\u01b1\u01af\3\2\2\2\u01b2"+
"\u01b3\5d\63\2\u01b3\u01b4\7p\2\2\u01b4\u01b6\3\2\2\2\u01b5\u01b2\3\2"+
"\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01bc\3\2\2\2\u01b7\u01bd\5p9\2\u01b8\u01b9"+
"\7q\2\2\u01b9\u01bd\7 \2\2\u01ba\u01bb\7q\2\2\u01bb\u01bd\7S\2\2\u01bc"+
"\u01b7\3\2\2\2\u01bc\u01b8\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bd\u01c0\3\2"+
"\2\2\u01be\u01c0\7*\2\2\u01bf\u01b5\3\2\2\2\u01bf\u01be\3\2\2\2\u01c0"+
"\u01c2\3\2\2\2\u01c1\u01c3\5J&\2\u01c2\u01c1\3\2\2\2\u01c2\u01c3\3\2\2"+
"\2\u01c3\63\3\2\2\2\u01c4\u01c5\5R*\2\u01c5\u01c6\7c\2\2\u01c6\u01c7\5"+
"\6\4\2\u01c7\u01cd\3\2\2\2\u01c8\u01ca\5\6\4\2\u01c9\u01cb\5J&\2\u01ca"+
"\u01c9\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd\3\2\2\2\u01cc\u01c4\3\2"+
"\2\2\u01cc\u01c8\3\2\2\2\u01cd\65\3\2\2\2\u01ce\u01d2\5\62\32\2\u01cf"+
"\u01d2\5\64\33\2\u01d0\u01d2\7u\2\2\u01d1\u01ce\3\2\2\2\u01d1\u01cf\3"+
"\2\2\2\u01d1\u01d0\3\2\2\2\u01d2\67\3\2\2\2\u01d3\u01d8\5:\36\2\u01d4"+
"\u01d5\7t\2\2\u01d5\u01d7\5:\36\2\u01d6\u01d4\3\2\2\2\u01d7\u01da\3\2"+
"\2\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d99\3\2\2\2\u01da\u01d8"+
"\3\2\2\2\u01db\u01e1\5<\37\2\u01dc\u01dd\7r\2\2\u01dd\u01de\5<\37\2\u01de"+
"\u01df\7s\2\2\u01df\u01e1\3\2\2\2\u01e0\u01db\3\2\2\2\u01e0\u01dc\3\2"+
"\2\2\u01e1;\3\2\2\2\u01e2\u01e6\5> \2\u01e3\u01e5\5@!\2\u01e4\u01e3\3"+
"\2\2\2\u01e5\u01e8\3\2\2\2\u01e6\u01e4\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7"+
"=\3\2\2\2\u01e8\u01e6\3\2\2\2\u01e9\u01eb\5d\63\2\u01ea\u01ec\5L\'\2\u01eb"+
"\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01fc\3\2\2\2\u01ed\u01f2\5B"+
"\"\2\u01ee\u01f0\5L\'\2\u01ef\u01f1\5P)\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1"+
"\3\2\2\2\u01f1\u01f3\3\2\2\2\u01f2\u01ee\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3"+
"\u01fc\3\2\2\2\u01f4\u01f9\5D#\2\u01f5\u01f7\5L\'\2\u01f6\u01f8\5P)\2"+
"\u01f7\u01f6\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fa\3\2\2\2\u01f9\u01f5"+
"\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fc\3\2\2\2\u01fb\u01e9\3\2\2\2\u01fb"+
"\u01ed\3\2\2\2\u01fb\u01f4\3\2\2\2\u01fc?\3\2\2\2\u01fd\u01ff\7#\2\2\u01fe"+
"\u01fd\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0205\3\2\2\2\u0200\u0202\t\13"+
"\2\2\u0201\u0203\7.\2\2\u0202\u0201\3\2\2\2\u0202\u0203\3\2\2\2\u0203"+
"\u0205\3\2\2\2\u0204\u01fe\3\2\2\2\u0204\u0200\3\2\2\2\u0205\u0206\3\2"+
"\2\2\u0206\u0207\7&\2\2\u0207\u0208\5:\36\2\u0208\u0209\7+\2\2\u0209\u020a"+
"\5\26\f\2\u020a\u0215\3\2\2\2\u020b\u020c\7\r\2\2\u020c\u020d\7&\2\2\u020d"+
"\u0215\5:\36\2\u020e\u020f\7\r\2\2\u020f\u0210\7@\2\2\u0210\u0215\5:\36"+
"\2\u0211\u0212\7.\2\2\u0212\u0213\7@\2\2\u0213\u0215\5:\36\2\u0214\u0204"+
"\3\2\2\2\u0214\u020b\3\2\2\2\u0214\u020e\3\2\2\2\u0214\u0211\3\2\2\2\u0215"+
"A\3\2\2\2\u0216\u0221\5\24\13\2\u0217\u0218\7r\2\2\u0218\u0219\5\24\13"+
"\2\u0219\u021a\7s\2\2\u021a\u0221\3\2\2\2\u021b\u0221\5T+\2\u021c\u021d"+
"\7r\2\2\u021d\u021e\5T+\2\u021e\u021f\7s\2\2\u021f\u0221\3\2\2\2\u0220"+
"\u0216\3\2\2\2\u0220\u0217\3\2\2\2\u0220\u021b\3\2\2\2\u0220\u021c\3\2"+
"\2\2\u0221C\3\2\2\2\u0222\u0223\7A\2\2\u0223\u0224\7r\2\2\u0224\u0225"+
"\5\6\4\2\u0225\u0226\7\6\2\2\u0226\u0227\5j\66\2\u0227\u0228\7s\2\2\u0228"+
"\u027c\3\2\2\2\u0229\u022a\7\f\2\2\u022a\u022b\7r\2\2\u022b\u022c\5j\66"+
"\2\u022c\u022d\7t\2\2\u022d\u0230\5\6\4\2\u022e\u022f\7t\2\2\u022f\u0231"+
"\5\6\4\2\u0230\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0232\3\2\2\2\u0232"+
"\u0233\7s\2\2\u0233\u027c\3\2\2\2\u0234\u027c\7\21\2\2\u0235\u027c\7\22"+
"\2\2\u0236\u0237\7D\2\2\u0237\u0238\7r\2\2\u0238\u0239\7^\2\2\u0239\u023a"+
"\7t\2\2\u023a\u023b\5\6\4\2\u023b\u023c\7t\2\2\u023c\u023d\5\6\4\2\u023d"+
"\u023e\7s\2\2\u023e\u027c\3\2\2\2\u023f\u0240\7E\2\2\u0240\u0241\7r\2"+
"\2\u0241\u0242\7^\2\2\u0242\u0243\7t\2\2\u0243\u0244\5\6\4\2\u0244\u0245"+
"\7t\2\2\u0245\u0246\5\6\4\2\u0246\u0247\7s\2\2\u0247\u027c\3\2\2\2\u0248"+
"\u0249\7F\2\2\u0249\u024a\7r\2\2\u024a\u024b\7^\2\2\u024b\u024c\7t\2\2"+
"\u024c\u024d\5\6\4\2\u024d\u024e\7s\2\2\u024e\u027c\3\2\2\2\u024f\u0250"+
"\7G\2\2\u0250\u0251\7r\2\2\u0251\u0252\7^\2\2\u0252\u0253\7t\2\2\u0253"+
"\u0254\5\6\4\2\u0254\u0255\7s\2\2\u0255\u027c\3\2\2\2\u0256\u027c\7K\2"+
"\2\u0257\u027c\7\64\2\2\u0258\u027c\7\67\2\2\u0259\u025a\7!\2\2\u025a"+
"\u025b\7r\2\2\u025b\u025c\5\26\f\2\u025c\u025d\7t\2\2\u025d\u025e\5\6"+
"\4\2\u025e\u025f\7t\2\2\u025f\u0260\5\6\4\2\u0260\u0261\7s\2\2\u0261\u027c"+
"\3\2\2\2\u0262\u0263\t\f\2\2\u0263\u0264\7r\2\2\u0264\u0265\7u\2\2\u0265"+
"\u0267\7s\2\2\u0266\u0268\5X-\2\u0267\u0266\3\2\2\2\u0267\u0268\3\2\2"+
"\2\u0268\u027c\3\2\2\2\u0269\u026a\7^\2\2\u026a\u026c\7r\2\2\u026b\u026d"+
"\t\6\2\2\u026c\u026b\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026f\3\2\2\2\u026e"+
"\u0270\5V,\2\u026f\u026e\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0271\3\2\2"+
"\2\u0271\u0279\7s\2\2\u0272\u0273\7?\2\2\u0273\u0274\7\36\2\2\u0274\u0275"+
"\7r\2\2\u0275\u0276\5*\26\2\u0276\u0277\7s\2\2\u0277\u027a\3\2\2\2\u0278"+
"\u027a\5X-\2\u0279\u0272\3\2\2\2\u0279\u0278\3\2\2\2\u0279\u027a\3\2\2"+
"\2\u027a\u027c\3\2\2\2\u027b\u0222\3\2\2\2\u027b\u0229\3\2\2\2\u027b\u0234"+
"\3\2\2\2\u027b\u0235\3\2\2\2\u027b\u0236\3\2\2\2\u027b\u023f\3\2\2\2\u027b"+
"\u0248\3\2\2\2\u027b\u024f\3\2\2\2\u027b\u0256\3\2\2\2\u027b\u0257\3\2"+
"\2\2\u027b\u0258\3\2\2\2\u027b\u0259\3\2\2\2\u027b\u0262\3\2\2\2\u027b"+
"\u0269\3\2\2\2\u027cE\3\2\2\2\u027d\u027e\7<\2\2\u027e\u027f\5\6\4\2\u027f"+
"\u0280\78\2\2\u0280\u0281\5\6\4\2\u0281G\3\2\2\2\u0282\u0283\7<\2\2\u0283"+
"\u0284\5\26\f\2\u0284\u0285\78\2\2\u0285\u0286\5\6\4\2\u0286I\3\2\2\2"+
"\u0287\u0289\7\6\2\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u028a"+
"\3\2\2\2\u028a\u028b\5R*\2\u028bK\3\2\2\2\u028c\u028e\7\6\2\2\u028d\u028c"+
"\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u028f\3\2\2\2\u028f\u0290\5N(\2\u0290"+
"M\3\2\2\2\u0291\u0292\5p9\2\u0292O\3\2\2\2\u0293\u0294\7r\2\2\u0294\u0299"+
"\5R*\2\u0295\u0296\7t\2\2\u0296\u0298\5R*\2\u0297\u0295\3\2\2\2\u0298"+
"\u029b\3\2\2\2\u0299\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2"+
"\2\2\u029b\u0299\3\2\2\2\u029c\u029d\7s\2\2\u029dQ\3\2\2\2\u029e\u02a1"+
"\5p9\2\u029f\u02a1\7_\2\2\u02a0\u029e\3\2\2\2\u02a0\u029f\3\2\2\2\u02a1"+
"S\3\2\2\2\u02a2\u02a3\7;\2\2\u02a3\u02a4\7r\2\2\u02a4\u02a5\5V,\2\u02a5"+
"\u02ad\7s\2\2\u02a6\u02a7\7t\2\2\u02a7\u02a8\7r\2\2\u02a8\u02a9\5V,\2"+
"\u02a9\u02aa\7s\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a6\3\2\2\2\u02ac\u02af"+
"\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae\3\2\2\2\u02aeU\3\2\2\2\u02af"+
"\u02ad\3\2\2\2\u02b0\u02b5\5\6\4\2\u02b1\u02b2\7t\2\2\u02b2\u02b4\5\6"+
"\4\2\u02b3\u02b1\3\2\2\2\u02b4\u02b7\3\2\2\2\u02b5\u02b3\3\2\2\2\u02b5"+
"\u02b6\3\2\2\2\u02b6W\3\2\2\2\u02b7\u02b5\3\2\2\2\u02b8\u02b9\7/\2\2\u02b9"+
"\u02bd\7r\2\2\u02ba\u02bb\7O\2\2\u02bb\u02bc\7\t\2\2\u02bc\u02be\5V,\2"+
"\u02bd\u02ba\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c0\3\2\2\2\u02bf\u02c1"+
"\5*\26\2\u02c0\u02bf\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c3\3\2\2\2\u02c2"+
"\u02c4\5Z.\2\u02c3\u02c2\3\2\2\2\u02c3\u02c4\3\2\2\2\u02c4\u02c5\3\2\2"+
"\2\u02c5\u02c6\7s\2\2\u02c6Y\3\2\2\2\u02c7\u02c8\t\r\2\2\u02c8\u02c9\5"+
"\\/\2\u02c9[\3\2\2\2\u02ca\u02d1\5`\61\2\u02cb\u02cc\7\b\2\2\u02cc\u02cd"+
"\5^\60\2\u02cd\u02ce\7\4\2\2\u02ce\u02cf\5^\60\2\u02cf\u02d1\3\2\2\2\u02d0"+
"\u02ca\3\2\2\2\u02d0\u02cb\3\2\2\2\u02d1]\3\2\2\2\u02d2\u02d5\5`\61\2"+
"\u02d3\u02d5\5b\62\2\u02d4\u02d2\3\2\2\2\u02d4\u02d3\3\2\2\2\u02d5_\3"+
"\2\2\2\u02d6\u02d7\7V\2\2\u02d7\u02dd\7P\2\2\u02d8\u02d9\7]\2\2\u02d9"+
"\u02dd\7P\2\2\u02da\u02db\7\16\2\2\u02db\u02dd\7R\2\2\u02dc\u02d6\3\2"+
"\2\2\u02dc\u02d8\3\2\2\2\u02dc\u02da\3\2\2\2\u02dda\3\2\2\2\u02de\u02df"+
"\7V\2\2\u02df\u02e3\7I\2\2\u02e0\u02e1\7]\2\2\u02e1\u02e3\7I\2\2\u02e2"+
"\u02de\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e3c\3\2\2\2\u02e4\u02e9\5p9\2\u02e5"+
"\u02e6\7p\2\2\u02e6\u02e8\5p9\2\u02e7\u02e5\3\2\2\2\u02e8\u02eb\3\2\2"+
"\2\u02e9\u02e7\3\2\2\2\u02e9\u02ea\3\2\2\2\u02eae\3\2\2\2\u02eb\u02e9"+
"\3\2\2\2\u02ec\u02ed\5d\63\2\u02ed\u02ee\7p\2\2\u02ee\u02f0\3\2\2\2\u02ef"+
"\u02ec\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f2\5p"+
"9\2\u02f2g\3\2\2\2\u02f3\u02f5\7)\2\2\u02f4\u02f3\3\2\2\2\u02f4\u02f5"+
"\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02f7\7*\2\2\u02f7i\3\2\2\2\u02f8\u02fa"+
"\5p9\2\u02f9\u02fb\7 \2\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb"+
"\u0303\3\2\2\2\u02fc\u02fd\7r\2\2\u02fd\u0300\t\16\2\2\u02fe\u02ff\7t"+
"\2\2\u02ff\u0301\7]\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2\2\2\u0301"+
"\u0302\3\2\2\2\u0302\u0304\7s\2\2\u0303\u02fc\3\2\2\2\u0303\u0304\3\2"+
"\2\2\u0304\u030a\3\2\2\2\u0305\u0307\7\25\2\2\u0306\u0308\7\61\2\2\u0307"+
"\u0306\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u030a\3\2\2\2\u0309\u02f8\3\2"+
"\2\2\u0309\u0305\3\2\2\2\u030ak\3\2\2\2\u030b\u031b\7_\2\2\u030c\u031b"+
"\7`\2\2\u030d\u030f\5n8\2\u030e\u030d\3\2\2\2\u030e\u030f\3\2\2\2\u030f"+
"\u0310\3\2\2\2\u0310\u031b\7]\2\2\u0311\u0313\5n8\2\u0312\u0311\3\2\2"+
"\2\u0312\u0313\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u031b\t\7\2\2\u0315\u0317"+
"\5n8\2\u0316\u0315\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0318\3\2\2\2\u0318"+
"\u0319\7q\2\2\u0319\u031b\t\17\2\2\u031a\u030b\3\2\2\2\u031a\u030c\3\2"+
"\2\2\u031a\u030e\3\2\2\2\u031a\u0312\3\2\2\2\u031a\u0316\3\2\2\2\u031b"+
"m\3\2\2\2\u031c\u031d\t\4\2\2\u031do\3\2\2\2\u031e\u0322\5r:\2\u031f\u0322"+
"\7Z\2\2\u0320\u0322\7\\\2\2\u0321\u031e\3\2\2\2\u0321\u031f\3\2\2\2\u0321"+
"\u0320\3\2\2\2\u0322q\3\2\2\2\u0323\u0324\t\20\2\2\u0324s\3\2\2\2\u0325"+
"\u0335\7c\2\2\u0326\u0335\7d\2\2\u0327\u0335\7e\2\2\u0328\u0329\7e\2\2"+
"\u0329\u0335\7c\2\2\u032a\u032b\7d\2\2\u032b\u0335\7c\2\2\u032c\u032d"+
"\7e\2\2\u032d\u0335\7d\2\2\u032e\u032f\7f\2\2\u032f\u0335\7c\2\2\u0330"+
"\u0331\7f\2\2\u0331\u0335\7d\2\2\u0332\u0333\7f\2\2\u0333\u0335\7e\2\2"+
"\u0334\u0325\3\2\2\2\u0334\u0326\3\2\2\2\u0334\u0327\3\2\2\2\u0334\u0328"+
"\3\2\2\2\u0334\u032a\3\2\2\2\u0334\u032c\3\2\2\2\u0334\u032e\3\2\2\2\u0334"+
"\u0330\3\2\2\2\u0334\u0332\3\2\2\2\u0335u\3\2\2\2\u0336\u0337\t\21\2\2"+
"\u0337w\3\2\2\2e\177\u008b\u009e\u00a0\u00a6\u00ad\u00b1\u00b9\u00bd\u00c1"+
"\u00c7\u00d1\u00da\u00de\u00e7\u00ef\u00f3\u0109\u0112\u0118\u011e\u0124"+
"\u012e\u0135\u013a\u013f\u0143\u014a\u014e\u0151\u0156\u015a\u015f\u0166"+
"\u0169\u016d\u0172\u0176\u017f\u0186\u018f\u019b\u01a2\u01a6\u01af\u01b5"+
"\u01bc\u01bf\u01c2\u01ca\u01cc\u01d1\u01d8\u01e0\u01e6\u01eb\u01f0\u01f2"+
"\u01f7\u01f9\u01fb\u01fe\u0202\u0204\u0214\u0220\u0230\u0267\u026c\u026f"+
"\u0279\u027b\u0288\u028d\u0299\u02a0\u02ad\u02b5\u02bd\u02c0\u02c3\u02d0"+
"\u02d4\u02dc\u02e2\u02e9\u02ef\u02f4\u02fa\u0300\u0303\u0307\u0309\u030e"+
"\u0312\u0316\u031a\u0321\u0334";
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);
}
}
}