Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.blazebit.persistence.parser.JPQLNextParser Maven / Gradle / Ivy
// Generated from com\blazebit\persistence\parser\JPQLNextParser.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 JPQLNextParser 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
WS=1, INTEGER_LITERAL=2, BIG_INTEGER_LITERAL=3, LONG_LITERAL=4, FLOAT_LITERAL=5,
DOUBLE_LITERAL=6, BIG_DECIMAL_LITERAL=7, CHARACTER_LITERAL=8, STRING_LITERAL=9,
AFTER=10, ALL=11, AND=12, ANY=13, AS=14, ASC=15, BEFORE=16, BETWEEN=17,
BOTH=18, BY=19, CASE=20, COLLATE=21, CONTAINING=22, COUNT=23, CROSS=24,
CURRENT=25, CURRENT_DATE=26, CURRENT_INSTANT=27, CURRENT_TIME=28, CURRENT_TIMESTAMP=29,
DELETE=30, DESC=31, DISTINCT=32, ELSE=33, EMPTY=34, END=35, ENTRY=36,
ESCAPE=37, EXCEPT=38, EXCLUDE=39, EXISTS=40, FALSE=41, FETCH=42, FILTER=43,
FIRST=44, FOLLOWING=45, FROM=46, FULL=47, GROUP=48, GROUPS=49, HAVING=50,
IN=51, INDEX=52, INNER=53, INSERT=54, INTERSECT=55, INTO=56, IS=57, JOIN=58,
JUMP=59, KEY=60, LAST=61, LEADING=62, LEFT=63, LIKE=64, LIMIT=65, MEMBER=66,
NEW=67, NO=68, NOT=69, NULL=70, NULLS=71, OBJECT=72, OF=73, OFFSET=74,
OLD=75, ON=76, OR=77, ORDER=78, OTHERS=79, OUTER=80, OVER=81, PAGE=82,
PARTITION=83, PRECEDING=84, RANGE=85, RECURSIVE=86, RETURNING=87, RIGHT=88,
ROW=89, ROWS=90, SELECT=91, SET=92, SOME=93, THEN=94, TIES=95, TO=96,
TRAILING=97, TREAT=98, TRIM=99, TRUE=100, TYPE=101, UNBOUNDED=102, UNION=103,
UPDATE=104, VALUE=105, VALUES=106, WHEN=107, WHERE=108, WINDOW=109, WITH=110,
TIMESTAMP_ESCAPE_START=111, DATE_ESCAPE_START=112, TIME_ESCAPE_START=113,
TEMPORAL_ESCAPE_END=114, EQUAL=115, NOT_EQUAL=116, GREATER=117, GREATER_EQUAL=118,
LESS=119, LESS_EQUAL=120, COMMA=121, DOT=122, LP=123, RP=124, LB=125,
RB=126, PLUS=127, MINUS=128, ASTERISK=129, SLASH=130, PERCENT=131, COLON=132,
DOUBLE_PIPE=133, QUESTION_MARK=134, DOLLAR=135, IDENTIFIER=136, QUOTED_IDENTIFIER=137;
public static final int
RULE_parseStatement = 0, RULE_parseSelectExpression = 1, RULE_parsePathExpression = 2,
RULE_parseExpression = 3, RULE_parseInItemExpression = 4, RULE_parseInItemOrPathExpression = 5,
RULE_parsePredicate = 6, RULE_withQuery = 7, RULE_simpleStatement = 8,
RULE_selectStatement = 9, RULE_subQuery = 10, RULE_subQuerySpecification = 11,
RULE_subQueryOrderByClause = 12, RULE_deleteStatement = 13, RULE_updateStatement = 14,
RULE_insertStatement = 15, RULE_dmlAttributeName = 16, RULE_targetFieldsSpecification = 17,
RULE_returningClause = 18, RULE_querySpecification = 19, RULE_fromClause = 20,
RULE_subQueryFromClause = 21, RULE_fromItem = 22, RULE_subQueryFromItem = 23,
RULE_fromItemElement = 24, RULE_fromItemValuesItem = 25, RULE_entityName = 26,
RULE_identificationVariable = 27, RULE_crossJoin = 28, RULE_inCollectionJoin = 29,
RULE_qualifiedJoin = 30, RULE_subQueryQualifiedJoin = 31, RULE_joinItemElement = 32,
RULE_joinExpression = 33, RULE_joinTypeQualifier = 34, RULE_qualifiedJoinPredicate = 35,
RULE_selectClause = 36, RULE_subQuerySelectClause = 37, RULE_selectItem = 38,
RULE_subQuerySelectItem = 39, RULE_selectExpression = 40, RULE_resultIdentifier = 41,
RULE_mapEntrySelectExpression = 42, RULE_constructorExpression = 43, RULE_constructorItem = 44,
RULE_objectSelectExpression = 45, RULE_path = 46, RULE_macroPath = 47,
RULE_outerPath = 48, RULE_qualifiedPath = 49, RULE_simpleSubpath = 50,
RULE_generalSubpath = 51, RULE_groupByClause = 52, RULE_groupingValue = 53,
RULE_havingClause = 54, RULE_orderByClause = 55, RULE_orderByItem = 56,
RULE_windowClause = 57, RULE_windowDefinition = 58, RULE_partitionByClause = 59,
RULE_frameClause = 60, RULE_frameStart = 61, RULE_frameEnd = 62, RULE_frameExclusionClause = 63,
RULE_limitClause = 64, RULE_offsetClause = 65, RULE_parameterOrNumberLiteral = 66,
RULE_keysetClause = 67, RULE_parameterOrLiteral = 68, RULE_entityTypeOrEnumLiteral = 69,
RULE_whereClause = 70, RULE_expression = 71, RULE_predicate = 72, RULE_inList = 73,
RULE_entityType = 74, RULE_simpleCaseWhen = 75, RULE_searchedCaseWhen = 76,
RULE_literal = 77, RULE_timestampLiteral = 78, RULE_dateLiteral = 79,
RULE_timeLiteral = 80, RULE_dateTimeLiteralText = 81, RULE_parameter = 82,
RULE_function = 83, RULE_trimSpecification = 84, RULE_trimCharacter = 85,
RULE_identifier = 86;
private static String[] makeRuleNames() {
return new String[] {
"parseStatement", "parseSelectExpression", "parsePathExpression", "parseExpression",
"parseInItemExpression", "parseInItemOrPathExpression", "parsePredicate",
"withQuery", "simpleStatement", "selectStatement", "subQuery", "subQuerySpecification",
"subQueryOrderByClause", "deleteStatement", "updateStatement", "insertStatement",
"dmlAttributeName", "targetFieldsSpecification", "returningClause", "querySpecification",
"fromClause", "subQueryFromClause", "fromItem", "subQueryFromItem", "fromItemElement",
"fromItemValuesItem", "entityName", "identificationVariable", "crossJoin",
"inCollectionJoin", "qualifiedJoin", "subQueryQualifiedJoin", "joinItemElement",
"joinExpression", "joinTypeQualifier", "qualifiedJoinPredicate", "selectClause",
"subQuerySelectClause", "selectItem", "subQuerySelectItem", "selectExpression",
"resultIdentifier", "mapEntrySelectExpression", "constructorExpression",
"constructorItem", "objectSelectExpression", "path", "macroPath", "outerPath",
"qualifiedPath", "simpleSubpath", "generalSubpath", "groupByClause",
"groupingValue", "havingClause", "orderByClause", "orderByItem", "windowClause",
"windowDefinition", "partitionByClause", "frameClause", "frameStart",
"frameEnd", "frameExclusionClause", "limitClause", "offsetClause", "parameterOrNumberLiteral",
"keysetClause", "parameterOrLiteral", "entityTypeOrEnumLiteral", "whereClause",
"expression", "predicate", "inList", "entityType", "simpleCaseWhen",
"searchedCaseWhen", "literal", "timestampLiteral", "dateLiteral", "timeLiteral",
"dateTimeLiteralText", "parameter", "function", "trimSpecification",
"trimCharacter", "identifier"
};
}
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,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "'{ts'", "'{d'", "'{t'", "'}'", "'='", null, "'>'",
"'>='", "'<'", "'<='", "','", "'.'", "'('", "')'", "'['", "']'", "'+'",
"'-'", "'*'", "'/'", "'%'", "':'", "'||'", "'?'", "'$'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "WS", "INTEGER_LITERAL", "BIG_INTEGER_LITERAL", "LONG_LITERAL",
"FLOAT_LITERAL", "DOUBLE_LITERAL", "BIG_DECIMAL_LITERAL", "CHARACTER_LITERAL",
"STRING_LITERAL", "AFTER", "ALL", "AND", "ANY", "AS", "ASC", "BEFORE",
"BETWEEN", "BOTH", "BY", "CASE", "COLLATE", "CONTAINING", "COUNT", "CROSS",
"CURRENT", "CURRENT_DATE", "CURRENT_INSTANT", "CURRENT_TIME", "CURRENT_TIMESTAMP",
"DELETE", "DESC", "DISTINCT", "ELSE", "EMPTY", "END", "ENTRY", "ESCAPE",
"EXCEPT", "EXCLUDE", "EXISTS", "FALSE", "FETCH", "FILTER", "FIRST", "FOLLOWING",
"FROM", "FULL", "GROUP", "GROUPS", "HAVING", "IN", "INDEX", "INNER",
"INSERT", "INTERSECT", "INTO", "IS", "JOIN", "JUMP", "KEY", "LAST", "LEADING",
"LEFT", "LIKE", "LIMIT", "MEMBER", "NEW", "NO", "NOT", "NULL", "NULLS",
"OBJECT", "OF", "OFFSET", "OLD", "ON", "OR", "ORDER", "OTHERS", "OUTER",
"OVER", "PAGE", "PARTITION", "PRECEDING", "RANGE", "RECURSIVE", "RETURNING",
"RIGHT", "ROW", "ROWS", "SELECT", "SET", "SOME", "THEN", "TIES", "TO",
"TRAILING", "TREAT", "TRIM", "TRUE", "TYPE", "UNBOUNDED", "UNION", "UPDATE",
"VALUE", "VALUES", "WHEN", "WHERE", "WINDOW", "WITH", "TIMESTAMP_ESCAPE_START",
"DATE_ESCAPE_START", "TIME_ESCAPE_START", "TEMPORAL_ESCAPE_END", "EQUAL",
"NOT_EQUAL", "GREATER", "GREATER_EQUAL", "LESS", "LESS_EQUAL", "COMMA",
"DOT", "LP", "RP", "LB", "RB", "PLUS", "MINUS", "ASTERISK", "SLASH",
"PERCENT", "COLON", "DOUBLE_PIPE", "QUESTION_MARK", "DOLLAR", "IDENTIFIER",
"QUOTED_IDENTIFIER"
};
}
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 "JPQLNextParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public JPQLNextParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ParseStatementContext extends ParserRuleContext {
public SimpleStatementContext simpleStatement() {
return getRuleContext(SimpleStatementContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public TerminalNode WITH() { return getToken(JPQLNextParser.WITH, 0); }
public WithQueryContext withQuery() {
return getRuleContext(WithQueryContext.class,0);
}
public TerminalNode RECURSIVE() { return getToken(JPQLNextParser.RECURSIVE, 0); }
public ParseStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseStatement(this);
else return visitor.visitChildren(this);
}
}
public final ParseStatementContext parseStatement() throws RecognitionException {
ParseStatementContext _localctx = new ParseStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parseStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(179);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(174);
match(WITH);
setState(176);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(175);
match(RECURSIVE);
}
break;
}
setState(178);
withQuery();
}
}
setState(181);
simpleStatement();
setState(182);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseSelectExpressionContext extends ParserRuleContext {
public SelectExpressionContext selectExpression() {
return getRuleContext(SelectExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParseSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseSelectExpressionContext parseSelectExpression() throws RecognitionException {
ParseSelectExpressionContext _localctx = new ParseSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_parseSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(184);
selectExpression();
setState(185);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParsePathExpressionContext extends ParserRuleContext {
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public OuterPathContext outerPath() {
return getRuleContext(OuterPathContext.class,0);
}
public MacroPathContext macroPath() {
return getRuleContext(MacroPathContext.class,0);
}
public ParsePathExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parsePathExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParsePathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParsePathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParsePathExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParsePathExpressionContext parsePathExpression() throws RecognitionException {
ParsePathExpressionContext _localctx = new ParsePathExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_parsePathExpression);
try {
setState(196);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(187);
path();
setState(188);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(190);
outerPath();
setState(191);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(193);
macroPath();
setState(194);
match(EOF);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseExpressionContext parseExpression() throws RecognitionException {
ParseExpressionContext _localctx = new ParseExpressionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_parseExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(198);
expression(0);
setState(199);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseInItemExpressionContext extends ParserRuleContext {
public ParameterOrLiteralContext parameterOrLiteral() {
return getRuleContext(ParameterOrLiteralContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public EntityTypeOrEnumLiteralContext entityTypeOrEnumLiteral() {
return getRuleContext(EntityTypeOrEnumLiteralContext.class,0);
}
public ParseInItemExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseInItemExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseInItemExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseInItemExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseInItemExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseInItemExpressionContext parseInItemExpression() throws RecognitionException {
ParseInItemExpressionContext _localctx = new ParseInItemExpressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_parseInItemExpression);
try {
setState(207);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(201);
parameterOrLiteral();
setState(202);
match(EOF);
}
break;
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(204);
entityTypeOrEnumLiteral();
setState(205);
match(EOF);
}
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 ParseInItemOrPathExpressionContext extends ParserRuleContext {
public ParameterOrLiteralContext parameterOrLiteral() {
return getRuleContext(ParameterOrLiteralContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParsePathExpressionContext parsePathExpression() {
return getRuleContext(ParsePathExpressionContext.class,0);
}
public ParseInItemOrPathExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseInItemOrPathExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseInItemOrPathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseInItemOrPathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseInItemOrPathExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseInItemOrPathExpressionContext parseInItemOrPathExpression() throws RecognitionException {
ParseInItemOrPathExpressionContext _localctx = new ParseInItemOrPathExpressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_parseInItemOrPathExpression);
try {
setState(213);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(209);
parameterOrLiteral();
setState(210);
match(EOF);
}
break;
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(212);
parsePathExpression();
}
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 ParsePredicateContext extends ParserRuleContext {
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParsePredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parsePredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParsePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParsePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParsePredicate(this);
else return visitor.visitChildren(this);
}
}
public final ParsePredicateContext parsePredicate() throws RecognitionException {
ParsePredicateContext _localctx = new ParsePredicateContext(_ctx, getState());
enterRule(_localctx, 12, RULE_parsePredicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(215);
predicate(0);
setState(216);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithQueryContext extends ParserRuleContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public SimpleStatementContext simpleStatement() {
return getRuleContext(SimpleStatementContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WithQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWithQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWithQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWithQuery(this);
else return visitor.visitChildren(this);
}
}
public final WithQueryContext withQuery() throws RecognitionException {
WithQueryContext _localctx = new WithQueryContext(_ctx, getState());
enterRule(_localctx, 14, RULE_withQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
entityName();
setState(219);
match(LP);
setState(220);
identifier();
setState(225);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(221);
match(COMMA);
setState(222);
identifier();
}
}
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(228);
match(RP);
setState(229);
match(AS);
setState(230);
match(LP);
setState(231);
simpleStatement();
setState(232);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleStatementContext extends ParserRuleContext {
public SelectStatementContext selectStatement() {
return getRuleContext(SelectStatementContext.class,0);
}
public UpdateStatementContext updateStatement() {
return getRuleContext(UpdateStatementContext.class,0);
}
public DeleteStatementContext deleteStatement() {
return getRuleContext(DeleteStatementContext.class,0);
}
public InsertStatementContext insertStatement() {
return getRuleContext(InsertStatementContext.class,0);
}
public SimpleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SimpleStatementContext simpleStatement() throws RecognitionException {
SimpleStatementContext _localctx = new SimpleStatementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_simpleStatement);
try {
setState(238);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
case LP:
enterOuterAlt(_localctx, 1);
{
setState(234);
selectStatement();
}
break;
case UPDATE:
enterOuterAlt(_localctx, 2);
{
setState(235);
updateStatement();
}
break;
case DELETE:
enterOuterAlt(_localctx, 3);
{
setState(236);
deleteStatement();
}
break;
case INSERT:
enterOuterAlt(_localctx, 4);
{
setState(237);
insertStatement();
}
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 SelectStatementContext extends ParserRuleContext {
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List selectStatement() {
return getRuleContexts(SelectStatementContext.class);
}
public SelectStatementContext selectStatement(int i) {
return getRuleContext(SelectStatementContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public SelectStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectStatement(this);
else return visitor.visitChildren(this);
}
}
public final SelectStatementContext selectStatement() throws RecognitionException {
SelectStatementContext _localctx = new SelectStatementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_selectStatement);
int _la;
try {
setState(250);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(240);
querySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(241);
match(LP);
setState(242);
selectStatement();
setState(243);
match(RP);
setState(244);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(246);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(245);
_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(248);
selectStatement();
}
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 SubQueryContext extends ParserRuleContext {
public SubQuerySpecificationContext subQuerySpecification() {
return getRuleContext(SubQuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List subQuery() {
return getRuleContexts(SubQueryContext.class);
}
public SubQueryContext subQuery(int i) {
return getRuleContext(SubQueryContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 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 JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuery(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryContext subQuery() throws RecognitionException {
SubQueryContext _localctx = new SubQueryContext(_ctx, getState());
enterRule(_localctx, 20, RULE_subQuery);
int _la;
try {
setState(262);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(252);
subQuerySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(253);
match(LP);
setState(254);
subQuery();
setState(255);
match(RP);
setState(256);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(258);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(257);
_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(260);
subQuery();
}
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 SubQuerySpecificationContext extends ParserRuleContext {
public SubQuerySelectClauseContext subQuerySelectClause() {
return getRuleContext(SubQuerySelectClauseContext.class,0);
}
public SubQueryFromClauseContext subQueryFromClause() {
return getRuleContext(SubQueryFromClauseContext.class,0);
}
public KeysetClauseContext keysetClause() {
return getRuleContext(KeysetClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public GroupByClauseContext groupByClause() {
return getRuleContext(GroupByClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public SubQueryContext subQuery() {
return getRuleContext(SubQueryContext.class,0);
}
public SubQueryOrderByClauseContext subQueryOrderByClause() {
return getRuleContext(SubQueryOrderByClauseContext.class,0);
}
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public SubQuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySpecificationContext subQuerySpecification() throws RecognitionException {
SubQuerySpecificationContext _localctx = new SubQuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 22, RULE_subQuerySpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(264);
subQuerySelectClause();
setState(265);
subQueryFromClause();
setState(267);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(266);
keysetClause();
}
}
setState(270);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(269);
whereClause();
}
}
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(272);
groupByClause();
}
}
setState(276);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(275);
havingClause();
}
}
setState(283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(278);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(280);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(279);
_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(282);
subQuery();
}
}
setState(286);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(285);
subQueryOrderByClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryOrderByClauseContext extends ParserRuleContext {
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public SubQueryOrderByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryOrderByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryOrderByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryOrderByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryOrderByClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryOrderByClauseContext subQueryOrderByClause() throws RecognitionException {
SubQueryOrderByClauseContext _localctx = new SubQueryOrderByClauseContext(_ctx, getState());
enterRule(_localctx, 24, RULE_subQueryOrderByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(288);
orderByClause();
setState(294);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
{
{
setState(289);
limitClause();
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==JUMP || _la==OFFSET) {
{
setState(290);
offsetClause();
}
}
}
}
break;
case JUMP:
case OFFSET:
{
setState(293);
offsetClause();
}
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 DeleteStatementContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(JPQLNextParser.DELETE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public DeleteStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDeleteStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDeleteStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDeleteStatement(this);
else return visitor.visitChildren(this);
}
}
public final DeleteStatementContext deleteStatement() throws RecognitionException {
DeleteStatementContext _localctx = new DeleteStatementContext(_ctx, getState());
enterRule(_localctx, 26, RULE_deleteStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(296);
match(DELETE);
setState(298);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(297);
match(FROM);
}
break;
}
setState(300);
entityName();
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(301);
match(LP);
setState(302);
simpleSubpath();
setState(303);
match(RP);
}
}
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(307);
identificationVariable();
}
}
setState(311);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(310);
whereClause();
}
}
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(313);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateStatementContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(JPQLNextParser.UPDATE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode SET() { return getToken(JPQLNextParser.SET, 0); }
public List dmlAttributeName() {
return getRuleContexts(DmlAttributeNameContext.class);
}
public DmlAttributeNameContext dmlAttributeName(int i) {
return getRuleContext(DmlAttributeNameContext.class,i);
}
public List EQUAL() { return getTokens(JPQLNextParser.EQUAL); }
public TerminalNode EQUAL(int i) {
return getToken(JPQLNextParser.EQUAL, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public UpdateStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUpdateStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUpdateStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUpdateStatement(this);
else return visitor.visitChildren(this);
}
}
public final UpdateStatementContext updateStatement() throws RecognitionException {
UpdateStatementContext _localctx = new UpdateStatementContext(_ctx, getState());
enterRule(_localctx, 28, RULE_updateStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(316);
match(UPDATE);
setState(318);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(317);
match(FROM);
}
break;
}
setState(320);
entityName();
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(321);
match(LP);
setState(322);
simpleSubpath();
setState(323);
match(RP);
}
}
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(327);
identificationVariable();
}
}
setState(330);
match(SET);
setState(331);
dmlAttributeName();
setState(332);
match(EQUAL);
setState(333);
expression(0);
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(334);
match(COMMA);
setState(335);
dmlAttributeName();
setState(336);
match(EQUAL);
setState(337);
expression(0);
}
}
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(344);
whereClause();
}
}
setState(348);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(347);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertStatementContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(JPQLNextParser.INSERT, 0); }
public TerminalNode INTO() { return getToken(JPQLNextParser.INTO, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TargetFieldsSpecificationContext targetFieldsSpecification() {
return getRuleContext(TargetFieldsSpecificationContext.class,0);
}
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public InsertStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInsertStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInsertStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInsertStatement(this);
else return visitor.visitChildren(this);
}
}
public final InsertStatementContext insertStatement() throws RecognitionException {
InsertStatementContext _localctx = new InsertStatementContext(_ctx, getState());
enterRule(_localctx, 30, RULE_insertStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(350);
match(INSERT);
setState(351);
match(INTO);
setState(352);
entityName();
setState(357);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(353);
match(LP);
setState(354);
simpleSubpath();
setState(355);
match(RP);
}
break;
}
setState(359);
targetFieldsSpecification();
setState(360);
querySpecification();
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(361);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DmlAttributeNameContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode INDEX() { return getToken(JPQLNextParser.INDEX, 0); }
public DmlAttributeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dmlAttributeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDmlAttributeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDmlAttributeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDmlAttributeName(this);
else return visitor.visitChildren(this);
}
}
public final DmlAttributeNameContext dmlAttributeName() throws RecognitionException {
DmlAttributeNameContext _localctx = new DmlAttributeNameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_dmlAttributeName);
try {
setState(375);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(364);
simpleSubpath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(365);
match(KEY);
setState(366);
match(LP);
setState(367);
path();
setState(368);
match(RP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(370);
match(INDEX);
setState(371);
match(LP);
setState(372);
path();
setState(373);
match(RP);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TargetFieldsSpecificationContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List dmlAttributeName() {
return getRuleContexts(DmlAttributeNameContext.class);
}
public DmlAttributeNameContext dmlAttributeName(int i) {
return getRuleContext(DmlAttributeNameContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public TargetFieldsSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetFieldsSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTargetFieldsSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTargetFieldsSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTargetFieldsSpecification(this);
else return visitor.visitChildren(this);
}
}
public final TargetFieldsSpecificationContext targetFieldsSpecification() throws RecognitionException {
TargetFieldsSpecificationContext _localctx = new TargetFieldsSpecificationContext(_ctx, getState());
enterRule(_localctx, 34, RULE_targetFieldsSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(377);
match(LP);
setState(378);
dmlAttributeName();
setState(383);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(379);
match(COMMA);
setState(380);
dmlAttributeName();
}
}
setState(385);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(386);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturningClauseContext extends ParserRuleContext {
public TerminalNode RETURNING() { return getToken(JPQLNextParser.RETURNING, 0); }
public List simpleSubpath() {
return getRuleContexts(SimpleSubpathContext.class);
}
public SimpleSubpathContext simpleSubpath(int i) {
return getRuleContext(SimpleSubpathContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public ReturningClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returningClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterReturningClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitReturningClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitReturningClause(this);
else return visitor.visitChildren(this);
}
}
public final ReturningClauseContext returningClause() throws RecognitionException {
ReturningClauseContext _localctx = new ReturningClauseContext(_ctx, getState());
enterRule(_localctx, 36, RULE_returningClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(388);
match(RETURNING);
setState(389);
simpleSubpath();
setState(394);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(390);
match(COMMA);
setState(391);
simpleSubpath();
}
}
setState(396);
_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 QuerySpecificationContext extends ParserRuleContext {
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public KeysetClauseContext keysetClause() {
return getRuleContext(KeysetClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public GroupByClauseContext groupByClause() {
return getRuleContext(GroupByClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public QuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 38, RULE_querySpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(397);
selectClause();
}
}
setState(400);
fromClause();
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(401);
keysetClause();
}
}
setState(405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(404);
whereClause();
}
}
setState(408);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(407);
groupByClause();
}
}
setState(411);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(410);
havingClause();
}
}
setState(414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WINDOW) {
{
setState(413);
windowClause();
}
}
setState(421);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(416);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(417);
_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(420);
querySpecification();
}
}
setState(424);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(423);
orderByClause();
}
break;
}
setState(427);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(426);
limitClause();
}
break;
}
setState(430);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(429);
offsetClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public List fromItem() {
return getRuleContexts(FromItemContext.class);
}
public FromItemContext fromItem(int i) {
return getRuleContext(FromItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 40, RULE_fromClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(432);
match(FROM);
setState(433);
fromItem();
setState(438);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(434);
match(COMMA);
setState(435);
fromItem();
}
}
setState(440);
_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 SubQueryFromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public List subQueryFromItem() {
return getRuleContexts(SubQueryFromItemContext.class);
}
public SubQueryFromItemContext subQueryFromItem(int i) {
return getRuleContext(SubQueryFromItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SubQueryFromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryFromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryFromClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryFromClauseContext subQueryFromClause() throws RecognitionException {
SubQueryFromClauseContext _localctx = new SubQueryFromClauseContext(_ctx, getState());
enterRule(_localctx, 42, RULE_subQueryFromClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(441);
match(FROM);
setState(442);
subQueryFromItem();
setState(447);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(443);
match(COMMA);
setState(444);
subQueryFromItem();
}
}
setState(449);
_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 FromItemContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public List crossJoin() {
return getRuleContexts(CrossJoinContext.class);
}
public CrossJoinContext crossJoin(int i) {
return getRuleContext(CrossJoinContext.class,i);
}
public List inCollectionJoin() {
return getRuleContexts(InCollectionJoinContext.class);
}
public InCollectionJoinContext inCollectionJoin(int i) {
return getRuleContext(InCollectionJoinContext.class,i);
}
public List qualifiedJoin() {
return getRuleContexts(QualifiedJoinContext.class);
}
public QualifiedJoinContext qualifiedJoin(int i) {
return getRuleContext(QualifiedJoinContext.class,i);
}
public FromItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromItem(this);
else return visitor.visitChildren(this);
}
}
public final FromItemContext fromItem() throws RecognitionException {
FromItemContext _localctx = new FromItemContext(_ctx, getState());
enterRule(_localctx, 44, RULE_fromItem);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(450);
fromItemElement();
setState(456);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(454);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(451);
crossJoin();
}
break;
case COMMA:
{
setState(452);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(453);
qualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(458);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryFromItemContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public List crossJoin() {
return getRuleContexts(CrossJoinContext.class);
}
public CrossJoinContext crossJoin(int i) {
return getRuleContext(CrossJoinContext.class,i);
}
public List inCollectionJoin() {
return getRuleContexts(InCollectionJoinContext.class);
}
public InCollectionJoinContext inCollectionJoin(int i) {
return getRuleContext(InCollectionJoinContext.class,i);
}
public List subQueryQualifiedJoin() {
return getRuleContexts(SubQueryQualifiedJoinContext.class);
}
public SubQueryQualifiedJoinContext subQueryQualifiedJoin(int i) {
return getRuleContext(SubQueryQualifiedJoinContext.class,i);
}
public SubQueryFromItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryFromItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryFromItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryFromItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryFromItem(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryFromItemContext subQueryFromItem() throws RecognitionException {
SubQueryFromItemContext _localctx = new SubQueryFromItemContext(_ctx, getState());
enterRule(_localctx, 46, RULE_subQueryFromItem);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(459);
fromItemElement();
setState(465);
_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(463);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(460);
crossJoin();
}
break;
case COMMA:
{
setState(461);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(462);
subQueryQualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(467);
_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 FromItemElementContext extends ParserRuleContext {
public FromItemElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItemElement; }
public FromItemElementContext() { }
public void copyFrom(FromItemElementContext ctx) {
super.copyFrom(ctx);
}
}
public static class FromValuesListContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public List fromItemValuesItem() {
return getRuleContexts(FromItemValuesItemContext.class);
}
public FromItemValuesItemContext fromItemValuesItem(int i) {
return getRuleContext(FromItemValuesItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromValuesListContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromValuesList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromValuesList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromValuesList(this);
else return visitor.visitChildren(this);
}
}
public static class FromOldOrNewContext extends FromItemElementContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode OLD() { return getToken(JPQLNextParser.OLD, 0); }
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromOldOrNewContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromOldOrNew(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromOldOrNew(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromOldOrNew(this);
else return visitor.visitChildren(this);
}
}
public static class FromEntityContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromEntityContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromEntity(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromEntity(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromEntity(this);
else return visitor.visitChildren(this);
}
}
public static class FromSimpleValuesLikeEntityAttributeContext extends FromItemElementContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public FromSimpleValuesLikeEntityAttributeContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromSimpleValuesLikeEntityAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromSimpleValuesLikeEntityAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromSimpleValuesLikeEntityAttribute(this);
else return visitor.visitChildren(this);
}
}
public static class FromSimpleValuesListContext extends FromItemElementContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public List fromItemValuesItem() {
return getRuleContexts(FromItemValuesItemContext.class);
}
public FromItemValuesItemContext fromItemValuesItem(int i) {
return getRuleContext(FromItemValuesItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromSimpleValuesListContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromSimpleValuesList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromSimpleValuesList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromSimpleValuesList(this);
else return visitor.visitChildren(this);
}
}
public static class FromValuesContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromValuesContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromValues(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromValues(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromValues(this);
else return visitor.visitChildren(this);
}
}
public final FromItemElementContext fromItemElement() throws RecognitionException {
FromItemElementContext _localctx = new FromItemElementContext(_ctx, getState());
enterRule(_localctx, 48, RULE_fromItemElement);
int _la;
try {
setState(525);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
_localctx = new FromEntityContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(468);
entityName();
setState(470);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(469);
identificationVariable();
}
}
}
break;
case 2:
_localctx = new FromValuesContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(472);
entityName();
setState(473);
match(LP);
setState(474);
match(INTEGER_LITERAL);
setState(475);
match(VALUES);
setState(476);
match(RP);
setState(477);
identificationVariable();
}
break;
case 3:
_localctx = new FromValuesListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(479);
entityName();
setState(480);
match(LP);
setState(481);
match(VALUES);
setState(482);
fromItemValuesItem();
setState(487);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(483);
match(COMMA);
setState(484);
fromItemValuesItem();
}
}
setState(489);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(490);
match(RP);
setState(491);
identificationVariable();
}
break;
case 4:
_localctx = new FromSimpleValuesLikeEntityAttributeContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(493);
identifier();
setState(494);
match(LP);
setState(495);
match(INTEGER_LITERAL);
setState(496);
match(VALUES);
setState(499);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(497);
match(LIKE);
setState(498);
entityName();
}
}
setState(501);
match(RP);
setState(502);
identificationVariable();
}
break;
case 5:
_localctx = new FromSimpleValuesListContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(504);
identifier();
setState(505);
match(LP);
setState(506);
match(VALUES);
setState(507);
fromItemValuesItem();
setState(512);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(508);
match(COMMA);
setState(509);
fromItemValuesItem();
}
}
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(515);
match(RP);
setState(516);
identificationVariable();
}
break;
case 6:
_localctx = new FromOldOrNewContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(518);
_la = _input.LA(1);
if ( !(_la==NEW || _la==OLD) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(519);
match(LP);
setState(520);
entityName();
setState(521);
match(RP);
setState(523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(522);
identificationVariable();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromItemValuesItemContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List literal() {
return getRuleContexts(LiteralContext.class);
}
public LiteralContext literal(int i) {
return getRuleContext(LiteralContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromItemValuesItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItemValuesItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromItemValuesItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromItemValuesItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromItemValuesItem(this);
else return visitor.visitChildren(this);
}
}
public final FromItemValuesItemContext fromItemValuesItem() throws RecognitionException {
FromItemValuesItemContext _localctx = new FromItemValuesItemContext(_ctx, getState());
enterRule(_localctx, 50, RULE_fromItemValuesItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(527);
match(LP);
setState(528);
literal();
setState(533);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(529);
match(COMMA);
setState(530);
literal();
}
}
setState(535);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(536);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EntityNameContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public EntityNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityName(this);
else return visitor.visitChildren(this);
}
}
public final EntityNameContext entityName() throws RecognitionException {
EntityNameContext _localctx = new EntityNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_entityName);
try {
enterOuterAlt(_localctx, 1);
{
setState(538);
simpleSubpath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentificationVariableContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public IdentificationVariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identificationVariable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIdentificationVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIdentificationVariable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIdentificationVariable(this);
else return visitor.visitChildren(this);
}
}
public final IdentificationVariableContext identificationVariable() throws RecognitionException {
IdentificationVariableContext _localctx = new IdentificationVariableContext(_ctx, getState());
enterRule(_localctx, 54, RULE_identificationVariable);
try {
setState(543);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(540);
match(AS);
setState(541);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(542);
match(IDENTIFIER);
}
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 CrossJoinContext extends ParserRuleContext {
public TerminalNode CROSS() { return getToken(JPQLNextParser.CROSS, 0); }
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public CrossJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crossJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterCrossJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitCrossJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitCrossJoin(this);
else return visitor.visitChildren(this);
}
}
public final CrossJoinContext crossJoin() throws RecognitionException {
CrossJoinContext _localctx = new CrossJoinContext(_ctx, getState());
enterRule(_localctx, 56, RULE_crossJoin);
try {
enterOuterAlt(_localctx, 1);
{
setState(545);
match(CROSS);
setState(546);
match(JOIN);
setState(547);
fromItemElement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InCollectionJoinContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(JPQLNextParser.COMMA, 0); }
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public InCollectionJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inCollectionJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInCollectionJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInCollectionJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInCollectionJoin(this);
else return visitor.visitChildren(this);
}
}
public final InCollectionJoinContext inCollectionJoin() throws RecognitionException {
InCollectionJoinContext _localctx = new InCollectionJoinContext(_ctx, getState());
enterRule(_localctx, 58, RULE_inCollectionJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(549);
match(COMMA);
setState(550);
match(IN);
setState(551);
match(LP);
setState(552);
path();
setState(553);
match(RP);
setState(555);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(554);
identificationVariable();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedJoinContext extends ParserRuleContext {
public JoinTypeQualifierContext joinTypeQualifier() {
return getRuleContext(JoinTypeQualifierContext.class,0);
}
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public JoinItemElementContext joinItemElement() {
return getRuleContext(JoinItemElementContext.class,0);
}
public TerminalNode FETCH() { return getToken(JPQLNextParser.FETCH, 0); }
public QualifiedJoinPredicateContext qualifiedJoinPredicate() {
return getRuleContext(QualifiedJoinPredicateContext.class,0);
}
public QualifiedJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQualifiedJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQualifiedJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQualifiedJoin(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedJoinContext qualifiedJoin() throws RecognitionException {
QualifiedJoinContext _localctx = new QualifiedJoinContext(_ctx, getState());
enterRule(_localctx, 60, RULE_qualifiedJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(557);
joinTypeQualifier();
setState(558);
match(JOIN);
setState(560);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(559);
match(FETCH);
}
break;
}
setState(562);
joinItemElement();
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(563);
qualifiedJoinPredicate();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryQualifiedJoinContext extends ParserRuleContext {
public JoinTypeQualifierContext joinTypeQualifier() {
return getRuleContext(JoinTypeQualifierContext.class,0);
}
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public JoinItemElementContext joinItemElement() {
return getRuleContext(JoinItemElementContext.class,0);
}
public QualifiedJoinPredicateContext qualifiedJoinPredicate() {
return getRuleContext(QualifiedJoinPredicateContext.class,0);
}
public SubQueryQualifiedJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryQualifiedJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryQualifiedJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryQualifiedJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryQualifiedJoin(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryQualifiedJoinContext subQueryQualifiedJoin() throws RecognitionException {
SubQueryQualifiedJoinContext _localctx = new SubQueryQualifiedJoinContext(_ctx, getState());
enterRule(_localctx, 62, RULE_subQueryQualifiedJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(566);
joinTypeQualifier();
setState(567);
match(JOIN);
setState(568);
joinItemElement();
setState(570);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(569);
qualifiedJoinPredicate();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinItemElementContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public JoinExpressionContext joinExpression() {
return getRuleContext(JoinExpressionContext.class,0);
}
public JoinItemElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinItemElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinItemElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinItemElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinItemElement(this);
else return visitor.visitChildren(this);
}
}
public final JoinItemElementContext joinItemElement() throws RecognitionException {
JoinItemElementContext _localctx = new JoinItemElementContext(_ctx, getState());
enterRule(_localctx, 64, RULE_joinItemElement);
try {
setState(574);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(572);
fromItemElement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(573);
joinExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinExpressionContext extends ParserRuleContext {
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public JoinExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinExpression(this);
else return visitor.visitChildren(this);
}
}
public final JoinExpressionContext joinExpression() throws RecognitionException {
JoinExpressionContext _localctx = new JoinExpressionContext(_ctx, getState());
enterRule(_localctx, 66, RULE_joinExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(576);
match(TREAT);
setState(577);
match(LP);
setState(578);
path();
setState(579);
match(AS);
setState(580);
entityName();
setState(581);
match(RP);
setState(584);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(582);
match(DOT);
setState(583);
generalSubpath();
}
}
setState(587);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(586);
identificationVariable();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinTypeQualifierContext extends ParserRuleContext {
public TerminalNode INNER() { return getToken(JPQLNextParser.INNER, 0); }
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode LEFT() { return getToken(JPQLNextParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(JPQLNextParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(JPQLNextParser.FULL, 0); }
public JoinTypeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinTypeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinTypeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinTypeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinTypeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final JoinTypeQualifierContext joinTypeQualifier() throws RecognitionException {
JoinTypeQualifierContext _localctx = new JoinTypeQualifierContext(_ctx, getState());
enterRule(_localctx, 68, RULE_joinTypeQualifier);
int _la;
try {
setState(598);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(590);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(589);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(593);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (FULL - 47)) | (1L << (LEFT - 47)) | (1L << (RIGHT - 47)))) != 0)) {
{
setState(592);
_la = _input.LA(1);
if ( !(((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (FULL - 47)) | (1L << (LEFT - 47)) | (1L << (RIGHT - 47)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(595);
match(OUTER);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedJoinPredicateContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(JPQLNextParser.ON, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public QualifiedJoinPredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedJoinPredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQualifiedJoinPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQualifiedJoinPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQualifiedJoinPredicate(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedJoinPredicateContext qualifiedJoinPredicate() throws RecognitionException {
QualifiedJoinPredicateContext _localctx = new QualifiedJoinPredicateContext(_ctx, getState());
enterRule(_localctx, 70, RULE_qualifiedJoinPredicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(600);
match(ON);
setState(601);
predicate(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public List selectItem() {
return getRuleContexts(SelectItemContext.class);
}
public SelectItemContext selectItem(int i) {
return getRuleContext(SelectItemContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_selectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(603);
match(SELECT);
setState(605);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(604);
match(DISTINCT);
}
break;
}
setState(607);
selectItem();
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(608);
match(COMMA);
setState(609);
selectItem();
}
}
setState(614);
_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 SubQuerySelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public List subQuerySelectItem() {
return getRuleContexts(SubQuerySelectItemContext.class);
}
public SubQuerySelectItemContext subQuerySelectItem(int i) {
return getRuleContext(SubQuerySelectItemContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SubQuerySelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySelectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySelectClauseContext subQuerySelectClause() throws RecognitionException {
SubQuerySelectClauseContext _localctx = new SubQuerySelectClauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_subQuerySelectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
match(SELECT);
setState(617);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(616);
match(DISTINCT);
}
break;
}
setState(619);
subQuerySelectItem();
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(620);
match(COMMA);
setState(621);
subQuerySelectItem();
}
}
setState(626);
_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 SelectItemContext extends ParserRuleContext {
public SelectExpressionContext selectExpression() {
return getRuleContext(SelectExpressionContext.class,0);
}
public ResultIdentifierContext resultIdentifier() {
return getRuleContext(ResultIdentifierContext.class,0);
}
public SelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectItem(this);
else return visitor.visitChildren(this);
}
}
public final SelectItemContext selectItem() throws RecognitionException {
SelectItemContext _localctx = new SelectItemContext(_ctx, getState());
enterRule(_localctx, 76, RULE_selectItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(627);
selectExpression();
setState(629);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(628);
resultIdentifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQuerySelectItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SubQuerySelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySelectItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySelectItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySelectItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySelectItem(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySelectItemContext subQuerySelectItem() throws RecognitionException {
SubQuerySelectItemContext _localctx = new SubQuerySelectItemContext(_ctx, getState());
enterRule(_localctx, 78, RULE_subQuerySelectItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(631);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectExpressionContext extends ParserRuleContext {
public ConstructorExpressionContext constructorExpression() {
return getRuleContext(ConstructorExpressionContext.class,0);
}
public ObjectSelectExpressionContext objectSelectExpression() {
return getRuleContext(ObjectSelectExpressionContext.class,0);
}
public MapEntrySelectExpressionContext mapEntrySelectExpression() {
return getRuleContext(MapEntrySelectExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final SelectExpressionContext selectExpression() throws RecognitionException {
SelectExpressionContext _localctx = new SelectExpressionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_selectExpression);
try {
setState(637);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(633);
constructorExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(634);
objectSelectExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(635);
mapEntrySelectExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(636);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResultIdentifierContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public ResultIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resultIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterResultIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitResultIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitResultIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ResultIdentifierContext resultIdentifier() throws RecognitionException {
ResultIdentifierContext _localctx = new ResultIdentifierContext(_ctx, getState());
enterRule(_localctx, 82, RULE_resultIdentifier);
try {
setState(642);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(639);
match(AS);
setState(640);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(641);
match(IDENTIFIER);
}
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 MapEntrySelectExpressionContext extends ParserRuleContext {
public TerminalNode ENTRY() { return getToken(JPQLNextParser.ENTRY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public MapEntrySelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapEntrySelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMapEntrySelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMapEntrySelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMapEntrySelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final MapEntrySelectExpressionContext mapEntrySelectExpression() throws RecognitionException {
MapEntrySelectExpressionContext _localctx = new MapEntrySelectExpressionContext(_ctx, getState());
enterRule(_localctx, 84, RULE_mapEntrySelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(644);
match(ENTRY);
setState(645);
match(LP);
setState(646);
path();
setState(647);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorExpressionContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List constructorItem() {
return getRuleContexts(ConstructorItemContext.class);
}
public ConstructorItemContext constructorItem(int i) {
return getRuleContext(ConstructorItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public ConstructorExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConstructorExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConstructorExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConstructorExpression(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorExpressionContext constructorExpression() throws RecognitionException {
ConstructorExpressionContext _localctx = new ConstructorExpressionContext(_ctx, getState());
enterRule(_localctx, 86, RULE_constructorExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(649);
match(NEW);
setState(650);
simpleSubpath();
setState(651);
match(LP);
setState(652);
constructorItem();
setState(657);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(653);
match(COMMA);
setState(654);
constructorItem();
}
}
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(660);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstructorItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConstructorItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConstructorItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConstructorItem(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorItemContext constructorItem() throws RecognitionException {
ConstructorItemContext _localctx = new ConstructorItemContext(_ctx, getState());
enterRule(_localctx, 88, RULE_constructorItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(662);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectSelectExpressionContext extends ParserRuleContext {
public TerminalNode OBJECT() { return getToken(JPQLNextParser.OBJECT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ObjectSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterObjectSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitObjectSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitObjectSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final ObjectSelectExpressionContext objectSelectExpression() throws RecognitionException {
ObjectSelectExpressionContext _localctx = new ObjectSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 90, RULE_objectSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(664);
match(OBJECT);
setState(665);
match(LP);
setState(666);
identifier();
setState(667);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathContext extends ParserRuleContext {
public QualifiedPathContext qualifiedPath() {
return getRuleContext(QualifiedPathContext.class,0);
}
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public PathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_path; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPath(this);
else return visitor.visitChildren(this);
}
}
public final PathContext path() throws RecognitionException {
PathContext _localctx = new PathContext(_ctx, getState());
enterRule(_localctx, 92, RULE_path);
try {
setState(675);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(669);
qualifiedPath();
setState(672);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(670);
match(DOT);
setState(671);
generalSubpath();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(674);
generalSubpath();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MacroPathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public MacroPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMacroPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMacroPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMacroPath(this);
else return visitor.visitChildren(this);
}
}
public final MacroPathContext macroPath() throws RecognitionException {
MacroPathContext _localctx = new MacroPathContext(_ctx, getState());
enterRule(_localctx, 94, RULE_macroPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(677);
identifier();
setState(678);
match(LP);
setState(687);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INTEGER_LITERAL) | (1L << BIG_INTEGER_LITERAL) | (1L << LONG_LITERAL) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIG_DECIMAL_LITERAL) | (1L << CHARACTER_LITERAL) | (1L << STRING_LITERAL) | (1L << AFTER) | (1L << ALL) | (1L << AND) | (1L << ANY) | (1L << AS) | (1L << ASC) | (1L << BEFORE) | (1L << BETWEEN) | (1L << BOTH) | (1L << BY) | (1L << CASE) | (1L << COLLATE) | (1L << CONTAINING) | (1L << COUNT) | (1L << CROSS) | (1L << CURRENT) | (1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP) | (1L << DELETE) | (1L << DESC) | (1L << DISTINCT) | (1L << ELSE) | (1L << EMPTY) | (1L << END) | (1L << ENTRY) | (1L << ESCAPE) | (1L << EXCEPT) | (1L << EXCLUDE) | (1L << EXISTS) | (1L << FALSE) | (1L << FETCH) | (1L << FILTER) | (1L << FIRST) | (1L << FOLLOWING) | (1L << FROM) | (1L << FULL) | (1L << GROUP) | (1L << GROUPS) | (1L << HAVING) | (1L << IN) | (1L << INDEX) | (1L << INNER) | (1L << INSERT) | (1L << INTERSECT) | (1L << INTO) | (1L << IS) | (1L << JOIN) | (1L << JUMP) | (1L << KEY) | (1L << LAST) | (1L << LEADING) | (1L << LEFT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LIKE - 64)) | (1L << (LIMIT - 64)) | (1L << (MEMBER - 64)) | (1L << (NEW - 64)) | (1L << (NO - 64)) | (1L << (NOT - 64)) | (1L << (NULL - 64)) | (1L << (NULLS - 64)) | (1L << (OBJECT - 64)) | (1L << (OF - 64)) | (1L << (OFFSET - 64)) | (1L << (ON - 64)) | (1L << (OR - 64)) | (1L << (ORDER - 64)) | (1L << (OTHERS - 64)) | (1L << (OUTER - 64)) | (1L << (OVER - 64)) | (1L << (PAGE - 64)) | (1L << (PARTITION - 64)) | (1L << (PRECEDING - 64)) | (1L << (RANGE - 64)) | (1L << (RECURSIVE - 64)) | (1L << (RETURNING - 64)) | (1L << (RIGHT - 64)) | (1L << (ROW - 64)) | (1L << (ROWS - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SOME - 64)) | (1L << (THEN - 64)) | (1L << (TIES - 64)) | (1L << (TO - 64)) | (1L << (TRAILING - 64)) | (1L << (TREAT - 64)) | (1L << (TRIM - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (UNBOUNDED - 64)) | (1L << (UNION - 64)) | (1L << (UPDATE - 64)) | (1L << (VALUE - 64)) | (1L << (VALUES - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WINDOW - 64)) | (1L << (WITH - 64)) | (1L << (TIMESTAMP_ESCAPE_START - 64)) | (1L << (DATE_ESCAPE_START - 64)) | (1L << (TIME_ESCAPE_START - 64)) | (1L << (LP - 64)) | (1L << (PLUS - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (MINUS - 128)) | (1L << (COLON - 128)) | (1L << (QUESTION_MARK - 128)) | (1L << (IDENTIFIER - 128)))) != 0)) {
{
setState(679);
expression(0);
setState(684);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(680);
match(COMMA);
setState(681);
expression(0);
}
}
setState(686);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(689);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterPathContext extends ParserRuleContext {
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public MacroPathContext macroPath() {
return getRuleContext(MacroPathContext.class,0);
}
public OuterPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOuterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOuterPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOuterPath(this);
else return visitor.visitChildren(this);
}
}
public final OuterPathContext outerPath() throws RecognitionException {
OuterPathContext _localctx = new OuterPathContext(_ctx, getState());
enterRule(_localctx, 96, RULE_outerPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(691);
match(OUTER);
setState(692);
match(LP);
setState(695);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(693);
simpleSubpath();
}
break;
case 2:
{
setState(694);
macroPath();
}
break;
}
setState(697);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedPathContext extends ParserRuleContext {
public QualifiedPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedPath; }
public QualifiedPathContext() { }
public void copyFrom(QualifiedPathContext ctx) {
super.copyFrom(ctx);
}
}
public static class TreatPathContext extends QualifiedPathContext {
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TreatPathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTreatPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTreatPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTreatPath(this);
else return visitor.visitChildren(this);
}
}
public static class ValuePathContext extends QualifiedPathContext {
public TerminalNode VALUE() { return getToken(JPQLNextParser.VALUE, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ValuePathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterValuePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitValuePath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitValuePath(this);
else return visitor.visitChildren(this);
}
}
public static class MapKeyPathContext extends QualifiedPathContext {
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public MapKeyPathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMapKeyPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMapKeyPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMapKeyPath(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedPathContext qualifiedPath() throws RecognitionException {
QualifiedPathContext _localctx = new QualifiedPathContext(_ctx, getState());
enterRule(_localctx, 98, RULE_qualifiedPath);
try {
setState(716);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TREAT:
_localctx = new TreatPathContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(699);
match(TREAT);
setState(700);
match(LP);
setState(701);
path();
setState(702);
match(AS);
setState(703);
entityName();
setState(704);
match(RP);
}
break;
case VALUE:
_localctx = new ValuePathContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(706);
match(VALUE);
setState(707);
match(LP);
setState(708);
path();
setState(709);
match(RP);
}
break;
case KEY:
_localctx = new MapKeyPathContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(711);
match(KEY);
setState(712);
match(LP);
setState(713);
path();
setState(714);
match(RP);
}
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 SimpleSubpathContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(JPQLNextParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(JPQLNextParser.DOT, i);
}
public SimpleSubpathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSubpath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleSubpath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleSubpath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleSubpath(this);
else return visitor.visitChildren(this);
}
}
public final SimpleSubpathContext simpleSubpath() throws RecognitionException {
SimpleSubpathContext _localctx = new SimpleSubpathContext(_ctx, getState());
enterRule(_localctx, 100, RULE_simpleSubpath);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(718);
identifier();
setState(723);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(719);
match(DOT);
setState(720);
identifier();
}
}
}
setState(725);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneralSubpathContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode LB() { return getToken(JPQLNextParser.LB, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RB() { return getToken(JPQLNextParser.RB, 0); }
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public GeneralSubpathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generalSubpath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGeneralSubpath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGeneralSubpath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGeneralSubpath(this);
else return visitor.visitChildren(this);
}
}
public final GeneralSubpathContext generalSubpath() throws RecognitionException {
GeneralSubpathContext _localctx = new GeneralSubpathContext(_ctx, getState());
enterRule(_localctx, 102, RULE_generalSubpath);
try {
enterOuterAlt(_localctx, 1);
{
setState(726);
simpleSubpath();
setState(734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(727);
match(LB);
setState(728);
expression(0);
setState(729);
match(RB);
setState(732);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(730);
match(DOT);
setState(731);
generalSubpath();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByClauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List groupingValue() {
return getRuleContexts(GroupingValueContext.class);
}
public GroupingValueContext groupingValue(int i) {
return getRuleContext(GroupingValueContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public GroupByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupByClause(this);
else return visitor.visitChildren(this);
}
}
public final GroupByClauseContext groupByClause() throws RecognitionException {
GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_groupByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(736);
match(GROUP);
setState(737);
match(BY);
setState(738);
groupingValue();
setState(743);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(739);
match(COMMA);
setState(740);
groupingValue();
}
}
setState(745);
_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 GroupingValueContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GroupingValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupingValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupingValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupingValue(this);
else return visitor.visitChildren(this);
}
}
public final GroupingValueContext groupingValue() throws RecognitionException {
GroupingValueContext _localctx = new GroupingValueContext(_ctx, getState());
enterRule(_localctx, 106, RULE_groupingValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(746);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(JPQLNextParser.HAVING, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitHavingClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 108, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(748);
match(HAVING);
setState(749);
predicate(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByClauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(JPQLNextParser.ORDER, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List orderByItem() {
return getRuleContexts(OrderByItemContext.class);
}
public OrderByItemContext orderByItem(int i) {
return getRuleContext(OrderByItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public OrderByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrderByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrderByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrderByClause(this);
else return visitor.visitChildren(this);
}
}
public final OrderByClauseContext orderByClause() throws RecognitionException {
OrderByClauseContext _localctx = new OrderByClauseContext(_ctx, getState());
enterRule(_localctx, 110, RULE_orderByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(751);
match(ORDER);
setState(752);
match(BY);
setState(753);
orderByItem();
setState(758);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(754);
match(COMMA);
setState(755);
orderByItem();
}
}
setState(760);
_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 OrderByItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode COLLATE() { return getToken(JPQLNextParser.COLLATE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode ASC() { return getToken(JPQLNextParser.ASC, 0); }
public TerminalNode DESC() { return getToken(JPQLNextParser.DESC, 0); }
public TerminalNode NULLS() { return getToken(JPQLNextParser.NULLS, 0); }
public TerminalNode FIRST() { return getToken(JPQLNextParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(JPQLNextParser.LAST, 0); }
public OrderByItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrderByItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrderByItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrderByItem(this);
else return visitor.visitChildren(this);
}
}
public final OrderByItemContext orderByItem() throws RecognitionException {
OrderByItemContext _localctx = new OrderByItemContext(_ctx, getState());
enterRule(_localctx, 112, RULE_orderByItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(761);
expression(0);
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE) {
{
setState(762);
match(COLLATE);
setState(763);
match(STRING_LITERAL);
}
}
setState(771);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(766);
_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();
}
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(767);
match(NULLS);
setState(768);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
_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 WindowClauseContext extends ParserRuleContext {
public TerminalNode WINDOW() { return getToken(JPQLNextParser.WINDOW, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List AS() { return getTokens(JPQLNextParser.AS); }
public TerminalNode AS(int i) {
return getToken(JPQLNextParser.AS, i);
}
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List windowDefinition() {
return getRuleContexts(WindowDefinitionContext.class);
}
public WindowDefinitionContext windowDefinition(int i) {
return getRuleContext(WindowDefinitionContext.class,i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WindowClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWindowClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWindowClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWindowClause(this);
else return visitor.visitChildren(this);
}
}
public final WindowClauseContext windowClause() throws RecognitionException {
WindowClauseContext _localctx = new WindowClauseContext(_ctx, getState());
enterRule(_localctx, 114, RULE_windowClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(773);
match(WINDOW);
setState(774);
identifier();
setState(775);
match(AS);
setState(776);
match(LP);
setState(777);
windowDefinition();
setState(778);
match(RP);
setState(788);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(779);
match(COMMA);
setState(780);
identifier();
setState(781);
match(AS);
setState(782);
match(LP);
setState(783);
windowDefinition();
setState(784);
match(RP);
}
}
setState(790);
_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 WindowDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PartitionByClauseContext partitionByClause() {
return getRuleContext(PartitionByClauseContext.class,0);
}
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public FrameClauseContext frameClause() {
return getRuleContext(FrameClauseContext.class,0);
}
public WindowDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWindowDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWindowDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWindowDefinition(this);
else return visitor.visitChildren(this);
}
}
public final WindowDefinitionContext windowDefinition() throws RecognitionException {
WindowDefinitionContext _localctx = new WindowDefinitionContext(_ctx, getState());
enterRule(_localctx, 116, RULE_windowDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(792);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(791);
identifier();
}
break;
}
setState(795);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(794);
partitionByClause();
}
}
setState(798);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(797);
orderByClause();
}
}
setState(801);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) {
{
setState(800);
frameClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionByClauseContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(JPQLNextParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List groupingValue() {
return getRuleContexts(GroupingValueContext.class);
}
public GroupingValueContext groupingValue(int i) {
return getRuleContext(GroupingValueContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public PartitionByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPartitionByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPartitionByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPartitionByClause(this);
else return visitor.visitChildren(this);
}
}
public final PartitionByClauseContext partitionByClause() throws RecognitionException {
PartitionByClauseContext _localctx = new PartitionByClauseContext(_ctx, getState());
enterRule(_localctx, 118, RULE_partitionByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(803);
match(PARTITION);
setState(804);
match(BY);
setState(805);
groupingValue();
setState(810);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(806);
match(COMMA);
setState(807);
groupingValue();
}
}
setState(812);
_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 FrameClauseContext extends ParserRuleContext {
public Token frameMode;
public FrameStartContext frameStart() {
return getRuleContext(FrameStartContext.class,0);
}
public TerminalNode RANGE() { return getToken(JPQLNextParser.RANGE, 0); }
public TerminalNode ROWS() { return getToken(JPQLNextParser.ROWS, 0); }
public TerminalNode GROUPS() { return getToken(JPQLNextParser.GROUPS, 0); }
public FrameExclusionClauseContext frameExclusionClause() {
return getRuleContext(FrameExclusionClauseContext.class,0);
}
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public FrameEndContext frameEnd() {
return getRuleContext(FrameEndContext.class,0);
}
public FrameClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameClause(this);
else return visitor.visitChildren(this);
}
}
public final FrameClauseContext frameClause() throws RecognitionException {
FrameClauseContext _localctx = new FrameClauseContext(_ctx, getState());
enterRule(_localctx, 120, RULE_frameClause);
int _la;
try {
setState(826);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(813);
((FrameClauseContext)_localctx).frameMode = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) ) {
((FrameClauseContext)_localctx).frameMode = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(814);
frameStart();
setState(816);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(815);
frameExclusionClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(818);
((FrameClauseContext)_localctx).frameMode = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) ) {
((FrameClauseContext)_localctx).frameMode = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(819);
match(BETWEEN);
setState(820);
frameStart();
setState(821);
match(AND);
setState(822);
frameEnd();
setState(824);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(823);
frameExclusionClause();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameStartContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public FrameStartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameStart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameStart(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameStart(this);
else return visitor.visitChildren(this);
}
}
public final FrameStartContext frameStart() throws RecognitionException {
FrameStartContext _localctx = new FrameStartContext(_ctx, getState());
enterRule(_localctx, 122, RULE_frameStart);
try {
setState(838);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(828);
match(UNBOUNDED);
setState(829);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(830);
parameterOrNumberLiteral();
setState(831);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(833);
match(CURRENT);
setState(834);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(835);
parameterOrNumberLiteral();
setState(836);
match(FOLLOWING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameEndContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public FrameEndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameEnd; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameEnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameEnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameEnd(this);
else return visitor.visitChildren(this);
}
}
public final FrameEndContext frameEnd() throws RecognitionException {
FrameEndContext _localctx = new FrameEndContext(_ctx, getState());
enterRule(_localctx, 124, RULE_frameEnd);
try {
setState(852);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(840);
match(UNBOUNDED);
setState(841);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(842);
parameterOrNumberLiteral();
setState(843);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(845);
match(CURRENT);
setState(846);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(847);
parameterOrNumberLiteral();
setState(848);
match(FOLLOWING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(850);
match(UNBOUNDED);
setState(851);
match(FOLLOWING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameExclusionClauseContext extends ParserRuleContext {
public TerminalNode EXCLUDE() { return getToken(JPQLNextParser.EXCLUDE, 0); }
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode TIES() { return getToken(JPQLNextParser.TIES, 0); }
public TerminalNode NO() { return getToken(JPQLNextParser.NO, 0); }
public TerminalNode OTHERS() { return getToken(JPQLNextParser.OTHERS, 0); }
public FrameExclusionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameExclusionClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameExclusionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameExclusionClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameExclusionClause(this);
else return visitor.visitChildren(this);
}
}
public final FrameExclusionClauseContext frameExclusionClause() throws RecognitionException {
FrameExclusionClauseContext _localctx = new FrameExclusionClauseContext(_ctx, getState());
enterRule(_localctx, 126, RULE_frameExclusionClause);
try {
setState(864);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(854);
match(EXCLUDE);
setState(855);
match(CURRENT);
setState(856);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(857);
match(EXCLUDE);
setState(858);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(859);
match(EXCLUDE);
setState(860);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(861);
match(EXCLUDE);
setState(862);
match(NO);
setState(863);
match(OTHERS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LimitClauseContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(JPQLNextParser.LIMIT, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public LimitClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLimitClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLimitClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLimitClause(this);
else return visitor.visitChildren(this);
}
}
public final LimitClauseContext limitClause() throws RecognitionException {
LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_limitClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(866);
match(LIMIT);
setState(867);
parameterOrNumberLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OffsetClauseContext extends ParserRuleContext {
public TerminalNode OFFSET() { return getToken(JPQLNextParser.OFFSET, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode JUMP() { return getToken(JPQLNextParser.JUMP, 0); }
public TerminalNode TO() { return getToken(JPQLNextParser.TO, 0); }
public TerminalNode PAGE() { return getToken(JPQLNextParser.PAGE, 0); }
public TerminalNode CONTAINING() { return getToken(JPQLNextParser.CONTAINING, 0); }
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public OffsetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offsetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOffsetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOffsetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOffsetClause(this);
else return visitor.visitChildren(this);
}
}
public final OffsetClauseContext offsetClause() throws RecognitionException {
OffsetClauseContext _localctx = new OffsetClauseContext(_ctx, getState());
enterRule(_localctx, 130, RULE_offsetClause);
try {
setState(876);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OFFSET:
enterOuterAlt(_localctx, 1);
{
setState(869);
match(OFFSET);
setState(870);
parameterOrNumberLiteral();
}
break;
case JUMP:
enterOuterAlt(_localctx, 2);
{
setState(871);
match(JUMP);
setState(872);
match(TO);
setState(873);
match(PAGE);
setState(874);
match(CONTAINING);
setState(875);
parameter();
}
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 ParameterOrNumberLiteralContext extends ParserRuleContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public ParameterOrNumberLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterOrNumberLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterOrNumberLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterOrNumberLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterOrNumberLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ParameterOrNumberLiteralContext parameterOrNumberLiteral() throws RecognitionException {
ParameterOrNumberLiteralContext _localctx = new ParameterOrNumberLiteralContext(_ctx, getState());
enterRule(_localctx, 132, RULE_parameterOrNumberLiteral);
try {
setState(880);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(878);
parameter();
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(879);
match(INTEGER_LITERAL);
}
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 KeysetClauseContext extends ParserRuleContext {
public List parameterOrLiteral() {
return getRuleContexts(ParameterOrLiteralContext.class);
}
public ParameterOrLiteralContext parameterOrLiteral(int i) {
return getRuleContext(ParameterOrLiteralContext.class,i);
}
public TerminalNode BEFORE() { return getToken(JPQLNextParser.BEFORE, 0); }
public TerminalNode AFTER() { return getToken(JPQLNextParser.AFTER, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public KeysetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keysetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterKeysetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitKeysetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitKeysetClause(this);
else return visitor.visitChildren(this);
}
}
public final KeysetClauseContext keysetClause() throws RecognitionException {
KeysetClauseContext _localctx = new KeysetClauseContext(_ctx, getState());
enterRule(_localctx, 134, RULE_keysetClause);
int _la;
try {
setState(896);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(882);
_la = _input.LA(1);
if ( !(_la==AFTER || _la==BEFORE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(883);
parameterOrLiteral();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(884);
_la = _input.LA(1);
if ( !(_la==AFTER || _la==BEFORE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(885);
match(LP);
setState(886);
parameterOrLiteral();
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(887);
match(COMMA);
setState(888);
parameterOrLiteral();
}
}
setState(893);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(894);
match(RP);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterOrLiteralContext extends ParserRuleContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public ParameterOrLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterOrLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterOrLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterOrLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterOrLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ParameterOrLiteralContext parameterOrLiteral() throws RecognitionException {
ParameterOrLiteralContext _localctx = new ParameterOrLiteralContext(_ctx, getState());
enterRule(_localctx, 136, RULE_parameterOrLiteral);
try {
setState(900);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(898);
parameter();
}
break;
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 2);
{
setState(899);
literal();
}
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 EntityTypeOrEnumLiteralContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List DOT() { return getTokens(JPQLNextParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(JPQLNextParser.DOT, i);
}
public List DOLLAR() { return getTokens(JPQLNextParser.DOLLAR); }
public TerminalNode DOLLAR(int i) {
return getToken(JPQLNextParser.DOLLAR, i);
}
public EntityTypeOrEnumLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityTypeOrEnumLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityTypeOrEnumLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityTypeOrEnumLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityTypeOrEnumLiteral(this);
else return visitor.visitChildren(this);
}
}
public final EntityTypeOrEnumLiteralContext entityTypeOrEnumLiteral() throws RecognitionException {
EntityTypeOrEnumLiteralContext _localctx = new EntityTypeOrEnumLiteralContext(_ctx, getState());
enterRule(_localctx, 138, RULE_entityTypeOrEnumLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(902);
identifier();
setState(907);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==DOLLAR) {
{
{
setState(903);
_la = _input.LA(1);
if ( !(_la==DOT || _la==DOLLAR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(904);
identifier();
}
}
setState(909);
_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 WhereClauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(JPQLNextParser.WHERE, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 140, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(910);
match(WHERE);
setState(911);
predicate(0);
}
}
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 ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class AdditionExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode PLUS() { return getToken(JPQLNextParser.PLUS, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public AdditionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterAdditionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitAdditionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitAdditionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class LiteralExpressionContext extends ExpressionContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public LiteralExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLiteralExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLiteralExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLiteralExpression(this);
else return visitor.visitChildren(this);
}
}
public static class EntityTypeExpressionContext extends ExpressionContext {
public EntityTypeContext entityType() {
return getRuleContext(EntityTypeContext.class,0);
}
public EntityTypeExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityTypeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityTypeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityTypeExpression(this);
else return visitor.visitChildren(this);
}
}
public static class GroupedExpressionContext extends ExpressionContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public GroupedExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupedExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ConcatenationExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode DOUBLE_PIPE() { return getToken(JPQLNextParser.DOUBLE_PIPE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ConcatenationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConcatenationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConcatenationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConcatenationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class SimpleCaseExpressionContext extends ExpressionContext {
public ExpressionContext operand;
public ExpressionContext otherwise;
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List simpleCaseWhen() {
return getRuleContexts(SimpleCaseWhenContext.class);
}
public SimpleCaseWhenContext simpleCaseWhen(int i) {
return getRuleContext(SimpleCaseWhenContext.class,i);
}
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public SimpleCaseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleCaseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleCaseExpression(this);
else return visitor.visitChildren(this);
}
}
public static class SubtractionExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode MINUS() { return getToken(JPQLNextParser.MINUS, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public SubtractionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubtractionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubtractionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubtractionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class FunctionExpressionContext extends ExpressionContext {
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public FunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFunctionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFunctionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFunctionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryMinusExpressionContext extends ExpressionContext {
public TerminalNode MINUS() { return getToken(JPQLNextParser.MINUS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnaryMinusExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUnaryMinusExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUnaryMinusExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUnaryMinusExpression(this);
else return visitor.visitChildren(this);
}
}
public static class PathExpressionContext extends ExpressionContext {
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public PathExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPathExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ParameterExpressionContext extends ExpressionContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public ParameterExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterExpression(this);
else return visitor.visitChildren(this);
}
}
public static class TemporalFunctionExpressionContext extends ExpressionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(JPQLNextParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(JPQLNextParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(JPQLNextParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_INSTANT() { return getToken(JPQLNextParser.CURRENT_INSTANT, 0); }
public TemporalFunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTemporalFunctionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTemporalFunctionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTemporalFunctionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryPlusExpressionContext extends ExpressionContext {
public TerminalNode PLUS() { return getToken(JPQLNextParser.PLUS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnaryPlusExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUnaryPlusExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUnaryPlusExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUnaryPlusExpression(this);
else return visitor.visitChildren(this);
}
}
public static class DivisionExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode SLASH() { return getToken(JPQLNextParser.SLASH, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public DivisionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDivisionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDivisionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDivisionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class GeneralCaseExpressionContext extends ExpressionContext {
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public List searchedCaseWhen() {
return getRuleContexts(SearchedCaseWhenContext.class);
}
public SearchedCaseWhenContext searchedCaseWhen(int i) {
return getRuleContext(SearchedCaseWhenContext.class,i);
}
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GeneralCaseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGeneralCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGeneralCaseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGeneralCaseExpression(this);
else return visitor.visitChildren(this);
}
}
public static class MultiplicationExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode ASTERISK() { return getToken(JPQLNextParser.ASTERISK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public MultiplicationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMultiplicationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMultiplicationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMultiplicationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ModuloExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode PERCENT() { return getToken(JPQLNextParser.PERCENT, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ModuloExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterModuloExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitModuloExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitModuloExpression(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 = 142;
enterRecursionRule(_localctx, 142, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(953);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
_localctx = new GroupedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(914);
match(LP);
setState(915);
expression(0);
setState(916);
match(RP);
}
break;
case 2:
{
_localctx = new UnaryMinusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(918);
match(MINUS);
setState(919);
expression(10);
}
break;
case 3:
{
_localctx = new UnaryPlusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(920);
match(PLUS);
setState(921);
expression(9);
}
break;
case 4:
{
_localctx = new SimpleCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(922);
match(CASE);
setState(923);
((SimpleCaseExpressionContext)_localctx).operand = expression(0);
setState(925);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(924);
simpleCaseWhen();
}
}
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(931);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(929);
match(ELSE);
setState(930);
((SimpleCaseExpressionContext)_localctx).otherwise = expression(0);
}
}
setState(933);
match(END);
}
break;
case 5:
{
_localctx = new GeneralCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(935);
match(CASE);
setState(937);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(936);
searchedCaseWhen();
}
}
setState(939);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(943);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(941);
match(ELSE);
setState(942);
expression(0);
}
}
setState(945);
match(END);
}
break;
case 6:
{
_localctx = new LiteralExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(947);
literal();
}
break;
case 7:
{
_localctx = new ParameterExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(948);
parameter();
}
break;
case 8:
{
_localctx = new EntityTypeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(949);
entityType();
}
break;
case 9:
{
_localctx = new TemporalFunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(950);
((TemporalFunctionExpressionContext)_localctx).name = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP))) != 0)) ) {
((TemporalFunctionExpressionContext)_localctx).name = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 10:
{
_localctx = new PathExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(951);
path();
}
break;
case 11:
{
_localctx = new FunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(952);
function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(975);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(973);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
{
_localctx = new MultiplicationExpressionContext(new ExpressionContext(_parentctx, _parentState));
((MultiplicationExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(955);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(956);
match(ASTERISK);
setState(957);
((MultiplicationExpressionContext)_localctx).rhs = expression(17);
}
break;
case 2:
{
_localctx = new DivisionExpressionContext(new ExpressionContext(_parentctx, _parentState));
((DivisionExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(958);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(959);
match(SLASH);
setState(960);
((DivisionExpressionContext)_localctx).rhs = expression(16);
}
break;
case 3:
{
_localctx = new ModuloExpressionContext(new ExpressionContext(_parentctx, _parentState));
((ModuloExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(961);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(962);
match(PERCENT);
setState(963);
((ModuloExpressionContext)_localctx).rhs = expression(15);
}
break;
case 4:
{
_localctx = new ConcatenationExpressionContext(new ExpressionContext(_parentctx, _parentState));
((ConcatenationExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(964);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(965);
match(DOUBLE_PIPE);
setState(966);
((ConcatenationExpressionContext)_localctx).rhs = expression(14);
}
break;
case 5:
{
_localctx = new AdditionExpressionContext(new ExpressionContext(_parentctx, _parentState));
((AdditionExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(967);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(968);
match(PLUS);
setState(969);
((AdditionExpressionContext)_localctx).rhs = expression(13);
}
break;
case 6:
{
_localctx = new SubtractionExpressionContext(new ExpressionContext(_parentctx, _parentState));
((SubtractionExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(970);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(971);
match(MINUS);
setState(972);
((SubtractionExpressionContext)_localctx).rhs = expression(12);
}
break;
}
}
}
setState(977);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PredicateContext extends ParserRuleContext {
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
public PredicateContext() { }
public void copyFrom(PredicateContext ctx) {
super.copyFrom(ctx);
}
}
public static class QuantifiedSimpleLessThanOrEqualPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LESS_EQUAL() { return getToken(JPQLNextParser.LESS_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleLessThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleLessThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleLessThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleLessThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class ExistsSimplePredicateContext extends PredicateContext {
public TerminalNode EXISTS() { return getToken(JPQLNextParser.EXISTS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public ExistsSimplePredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterExistsSimplePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitExistsSimplePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitExistsSimplePredicate(this);
else return visitor.visitChildren(this);
}
}
public static class BetweenPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext start;
public ExpressionContext end;
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public BetweenPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterBetweenPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitBetweenPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitBetweenPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleGreaterThanPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode GREATER() { return getToken(JPQLNextParser.GREATER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleGreaterThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleGreaterThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleGreaterThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleGreaterThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class AndPredicateContext extends PredicateContext {
public List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public AndPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterAndPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitAndPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitAndPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class InequalityPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode NOT_EQUAL() { return getToken(JPQLNextParser.NOT_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public InequalityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInequalityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInequalityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInequalityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LessThanOrEqualPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode LESS_EQUAL() { return getToken(JPQLNextParser.LESS_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public LessThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLessThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLessThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLessThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GroupedPredicateContext extends PredicateContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public GroupedPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupedPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupedPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupedPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LikePredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext like;
public ExpressionContext escape;
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public TerminalNode ESCAPE() { return getToken(JPQLNextParser.ESCAPE, 0); }
public LikePredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLikePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLikePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLikePredicate(this);
else return visitor.visitChildren(this);
}
}
public static class InPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public InListContext inList() {
return getRuleContext(InListContext.class,0);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public InPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class EqualityPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode EQUAL() { return getToken(JPQLNextParser.EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public EqualityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEqualityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEqualityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEqualityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleInequalityPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NOT_EQUAL() { return getToken(JPQLNextParser.NOT_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleInequalityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleInequalityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleInequalityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleInequalityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GreaterThanPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode GREATER() { return getToken(JPQLNextParser.GREATER, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public GreaterThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGreaterThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGreaterThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGreaterThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class NegatedPredicateContext extends PredicateContext {
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public NegatedPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterNegatedPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitNegatedPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitNegatedPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleLessThanPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LESS() { return getToken(JPQLNextParser.LESS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleLessThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleLessThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleLessThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleLessThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class OrPredicateContext extends PredicateContext {
public List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public TerminalNode OR() { return getToken(JPQLNextParser.OR, 0); }
public OrPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class MemberOfPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode MEMBER() { return getToken(JPQLNextParser.MEMBER, 0); }
public TerminalNode OF() { return getToken(JPQLNextParser.OF, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public MemberOfPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMemberOfPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMemberOfPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMemberOfPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class IsEmptyPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode EMPTY() { return getToken(JPQLNextParser.EMPTY, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public IsEmptyPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIsEmptyPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIsEmptyPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIsEmptyPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleEqualityPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EQUAL() { return getToken(JPQLNextParser.EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleEqualityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleEqualityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleEqualityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleEqualityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LessThanPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode LESS() { return getToken(JPQLNextParser.LESS, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public LessThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLessThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLessThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLessThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class IsNullPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode NULL() { return getToken(JPQLNextParser.NULL, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public IsNullPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIsNullPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIsNullPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIsNullPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GreaterThanOrEqualPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode GREATER_EQUAL() { return getToken(JPQLNextParser.GREATER_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public GreaterThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGreaterThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGreaterThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGreaterThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleGreaterThanOrEqualPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode GREATER_EQUAL() { return getToken(JPQLNextParser.GREATER_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleGreaterThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleGreaterThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleGreaterThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleGreaterThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
return predicate(0);
}
private PredicateContext predicate(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PredicateContext _localctx = new PredicateContext(_ctx, _parentState);
PredicateContext _prevctx = _localctx;
int _startState = 144;
enterRecursionRule(_localctx, 144, RULE_predicate, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
_localctx = new GroupedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(979);
match(LP);
setState(980);
predicate(0);
setState(981);
match(RP);
}
break;
case 2:
{
_localctx = new NegatedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(983);
match(NOT);
setState(984);
predicate(22);
}
break;
case 3:
{
_localctx = new ExistsSimplePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(986);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(985);
match(NOT);
}
}
setState(988);
match(EXISTS);
setState(994);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(989);
identifier();
}
break;
case LP:
{
setState(990);
match(LP);
setState(991);
identifier();
setState(992);
match(RP);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
{
_localctx = new IsNullPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(996);
expression(0);
setState(997);
match(IS);
setState(999);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(998);
match(NOT);
}
}
setState(1001);
match(NULL);
}
break;
case 5:
{
_localctx = new IsEmptyPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1003);
expression(0);
setState(1004);
match(IS);
setState(1006);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1005);
match(NOT);
}
}
setState(1008);
match(EMPTY);
}
break;
case 6:
{
_localctx = new QuantifiedSimpleEqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1010);
expression(0);
setState(1011);
match(EQUAL);
setState(1013);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1012);
((QuantifiedSimpleEqualityPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleEqualityPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1020);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1015);
identifier();
}
break;
case LP:
{
{
setState(1016);
match(LP);
setState(1017);
identifier();
setState(1018);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
{
_localctx = new QuantifiedSimpleInequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1022);
expression(0);
setState(1023);
match(NOT_EQUAL);
setState(1025);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1024);
((QuantifiedSimpleInequalityPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleInequalityPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1032);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1027);
identifier();
}
break;
case LP:
{
{
setState(1028);
match(LP);
setState(1029);
identifier();
setState(1030);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
{
_localctx = new QuantifiedSimpleGreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1034);
expression(0);
setState(1035);
match(GREATER);
setState(1037);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1036);
((QuantifiedSimpleGreaterThanPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleGreaterThanPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1044);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1039);
identifier();
}
break;
case LP:
{
{
setState(1040);
match(LP);
setState(1041);
identifier();
setState(1042);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
_localctx = new QuantifiedSimpleGreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1046);
expression(0);
setState(1047);
match(GREATER_EQUAL);
setState(1049);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1048);
((QuantifiedSimpleGreaterThanOrEqualPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleGreaterThanOrEqualPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1056);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1051);
identifier();
}
break;
case LP:
{
{
setState(1052);
match(LP);
setState(1053);
identifier();
setState(1054);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 10:
{
_localctx = new QuantifiedSimpleLessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1058);
expression(0);
setState(1059);
match(LESS);
setState(1061);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1060);
((QuantifiedSimpleLessThanPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleLessThanPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1068);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1063);
identifier();
}
break;
case LP:
{
{
setState(1064);
match(LP);
setState(1065);
identifier();
setState(1066);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 11:
{
_localctx = new QuantifiedSimpleLessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1070);
expression(0);
setState(1071);
match(LESS_EQUAL);
setState(1073);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1072);
((QuantifiedSimpleLessThanOrEqualPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleLessThanOrEqualPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1080);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1075);
identifier();
}
break;
case LP:
{
{
setState(1076);
match(LP);
setState(1077);
identifier();
setState(1078);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 12:
{
_localctx = new EqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1082);
((EqualityPredicateContext)_localctx).lhs = expression(0);
setState(1083);
match(EQUAL);
setState(1084);
((EqualityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 13:
{
_localctx = new InequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1086);
((InequalityPredicateContext)_localctx).lhs = expression(0);
setState(1087);
match(NOT_EQUAL);
setState(1088);
((InequalityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 14:
{
_localctx = new GreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1090);
((GreaterThanPredicateContext)_localctx).lhs = expression(0);
setState(1091);
match(GREATER);
setState(1092);
((GreaterThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 15:
{
_localctx = new GreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1094);
((GreaterThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1095);
match(GREATER_EQUAL);
setState(1096);
((GreaterThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 16:
{
_localctx = new LessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1098);
((LessThanPredicateContext)_localctx).lhs = expression(0);
setState(1099);
match(LESS);
setState(1100);
((LessThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 17:
{
_localctx = new LessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1102);
((LessThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1103);
match(LESS_EQUAL);
setState(1104);
((LessThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 18:
{
_localctx = new InPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1106);
expression(0);
setState(1108);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1107);
match(NOT);
}
}
setState(1110);
match(IN);
setState(1111);
inList();
}
break;
case 19:
{
_localctx = new BetweenPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1113);
((BetweenPredicateContext)_localctx).lhs = expression(0);
setState(1115);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1114);
match(NOT);
}
}
setState(1117);
match(BETWEEN);
setState(1118);
((BetweenPredicateContext)_localctx).start = expression(0);
setState(1119);
match(AND);
setState(1120);
((BetweenPredicateContext)_localctx).end = expression(0);
}
break;
case 20:
{
_localctx = new LikePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1122);
((LikePredicateContext)_localctx).lhs = expression(0);
setState(1124);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1123);
match(NOT);
}
}
setState(1126);
match(LIKE);
setState(1127);
((LikePredicateContext)_localctx).like = expression(0);
setState(1130);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1128);
match(ESCAPE);
setState(1129);
((LikePredicateContext)_localctx).escape = expression(0);
}
break;
}
}
break;
case 21:
{
_localctx = new MemberOfPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1132);
expression(0);
setState(1134);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1133);
match(NOT);
}
}
setState(1136);
match(MEMBER);
setState(1137);
match(OF);
setState(1138);
path();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1150);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,142,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1148);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
{
_localctx = new AndPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1142);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1143);
match(AND);
setState(1144);
predicate(22);
}
break;
case 2:
{
_localctx = new OrPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1145);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1146);
match(OR);
setState(1147);
predicate(21);
}
break;
}
}
}
setState(1152);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,142,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InListContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public InListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInList(this);
else return visitor.visitChildren(this);
}
}
public final InListContext inList() throws RecognitionException {
InListContext _localctx = new InListContext(_ctx, getState());
enterRule(_localctx, 146, RULE_inList);
int _la;
try {
setState(1165);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1153);
match(LP);
setState(1154);
expression(0);
setState(1159);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1155);
match(COMMA);
setState(1156);
expression(0);
}
}
setState(1161);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1162);
match(RP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1164);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EntityTypeContext extends ParserRuleContext {
public TerminalNode TYPE() { return getToken(JPQLNextParser.TYPE, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public EntityTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityType(this);
else return visitor.visitChildren(this);
}
}
public final EntityTypeContext entityType() throws RecognitionException {
EntityTypeContext _localctx = new EntityTypeContext(_ctx, getState());
enterRule(_localctx, 148, RULE_entityType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1167);
match(TYPE);
setState(1168);
match(LP);
setState(1171);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1169);
path();
}
break;
case COLON:
case QUESTION_MARK:
{
setState(1170);
parameter();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1173);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleCaseWhenContext extends ParserRuleContext {
public ExpressionContext when;
public ExpressionContext then;
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public SimpleCaseWhenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleCaseWhen; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleCaseWhen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleCaseWhen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleCaseWhen(this);
else return visitor.visitChildren(this);
}
}
public final SimpleCaseWhenContext simpleCaseWhen() throws RecognitionException {
SimpleCaseWhenContext _localctx = new SimpleCaseWhenContext(_ctx, getState());
enterRule(_localctx, 150, RULE_simpleCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1175);
match(WHEN);
setState(1176);
((SimpleCaseWhenContext)_localctx).when = expression(0);
setState(1177);
match(THEN);
setState(1178);
((SimpleCaseWhenContext)_localctx).then = expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SearchedCaseWhenContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SearchedCaseWhenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_searchedCaseWhen; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSearchedCaseWhen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSearchedCaseWhen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSearchedCaseWhen(this);
else return visitor.visitChildren(this);
}
}
public final SearchedCaseWhenContext searchedCaseWhen() throws RecognitionException {
SearchedCaseWhenContext _localctx = new SearchedCaseWhenContext(_ctx, getState());
enterRule(_localctx, 152, RULE_searchedCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1180);
match(WHEN);
setState(1181);
predicate(0);
setState(1182);
match(THEN);
setState(1183);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode LONG_LITERAL() { return getToken(JPQLNextParser.LONG_LITERAL, 0); }
public TerminalNode BIG_INTEGER_LITERAL() { return getToken(JPQLNextParser.BIG_INTEGER_LITERAL, 0); }
public TerminalNode FLOAT_LITERAL() { return getToken(JPQLNextParser.FLOAT_LITERAL, 0); }
public TerminalNode DOUBLE_LITERAL() { return getToken(JPQLNextParser.DOUBLE_LITERAL, 0); }
public TerminalNode BIG_DECIMAL_LITERAL() { return getToken(JPQLNextParser.BIG_DECIMAL_LITERAL, 0); }
public TerminalNode NULL() { return getToken(JPQLNextParser.NULL, 0); }
public TerminalNode TRUE() { return getToken(JPQLNextParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(JPQLNextParser.FALSE, 0); }
public TimestampLiteralContext timestampLiteral() {
return getRuleContext(TimestampLiteralContext.class,0);
}
public DateLiteralContext dateLiteral() {
return getRuleContext(DateLiteralContext.class,0);
}
public TimeLiteralContext timeLiteral() {
return getRuleContext(TimeLiteralContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 154, RULE_literal);
try {
setState(1199);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1185);
match(STRING_LITERAL);
}
break;
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1186);
match(CHARACTER_LITERAL);
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1187);
match(INTEGER_LITERAL);
}
break;
case LONG_LITERAL:
enterOuterAlt(_localctx, 4);
{
setState(1188);
match(LONG_LITERAL);
}
break;
case BIG_INTEGER_LITERAL:
enterOuterAlt(_localctx, 5);
{
setState(1189);
match(BIG_INTEGER_LITERAL);
}
break;
case FLOAT_LITERAL:
enterOuterAlt(_localctx, 6);
{
setState(1190);
match(FLOAT_LITERAL);
}
break;
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 7);
{
setState(1191);
match(DOUBLE_LITERAL);
}
break;
case BIG_DECIMAL_LITERAL:
enterOuterAlt(_localctx, 8);
{
setState(1192);
match(BIG_DECIMAL_LITERAL);
}
break;
case NULL:
enterOuterAlt(_localctx, 9);
{
setState(1193);
match(NULL);
}
break;
case TRUE:
enterOuterAlt(_localctx, 10);
{
setState(1194);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 11);
{
setState(1195);
match(FALSE);
}
break;
case TIMESTAMP_ESCAPE_START:
enterOuterAlt(_localctx, 12);
{
setState(1196);
timestampLiteral();
}
break;
case DATE_ESCAPE_START:
enterOuterAlt(_localctx, 13);
{
setState(1197);
dateLiteral();
}
break;
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 14);
{
setState(1198);
timeLiteral();
}
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 TimestampLiteralContext extends ParserRuleContext {
public TerminalNode TIMESTAMP_ESCAPE_START() { return getToken(JPQLNextParser.TIMESTAMP_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public TimestampLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timestampLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTimestampLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTimestampLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTimestampLiteral(this);
else return visitor.visitChildren(this);
}
}
public final TimestampLiteralContext timestampLiteral() throws RecognitionException {
TimestampLiteralContext _localctx = new TimestampLiteralContext(_ctx, getState());
enterRule(_localctx, 156, RULE_timestampLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1201);
match(TIMESTAMP_ESCAPE_START);
setState(1202);
dateTimeLiteralText();
setState(1203);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateLiteralContext extends ParserRuleContext {
public TerminalNode DATE_ESCAPE_START() { return getToken(JPQLNextParser.DATE_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public DateLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDateLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDateLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDateLiteral(this);
else return visitor.visitChildren(this);
}
}
public final DateLiteralContext dateLiteral() throws RecognitionException {
DateLiteralContext _localctx = new DateLiteralContext(_ctx, getState());
enterRule(_localctx, 158, RULE_dateLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1205);
match(DATE_ESCAPE_START);
setState(1206);
dateTimeLiteralText();
setState(1207);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeLiteralContext extends ParserRuleContext {
public TerminalNode TIME_ESCAPE_START() { return getToken(JPQLNextParser.TIME_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public TimeLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTimeLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTimeLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTimeLiteral(this);
else return visitor.visitChildren(this);
}
}
public final TimeLiteralContext timeLiteral() throws RecognitionException {
TimeLiteralContext _localctx = new TimeLiteralContext(_ctx, getState());
enterRule(_localctx, 160, RULE_timeLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1209);
match(TIME_ESCAPE_START);
setState(1210);
dateTimeLiteralText();
setState(1211);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateTimeLiteralTextContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public DateTimeLiteralTextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimeLiteralText; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDateTimeLiteralText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDateTimeLiteralText(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDateTimeLiteralText(this);
else return visitor.visitChildren(this);
}
}
public final DateTimeLiteralTextContext dateTimeLiteralText() throws RecognitionException {
DateTimeLiteralTextContext _localctx = new DateTimeLiteralTextContext(_ctx, getState());
enterRule(_localctx, 162, RULE_dateTimeLiteralText);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1213);
_la = _input.LA(1);
if ( !(_la==CHARACTER_LITERAL || _la==STRING_LITERAL) ) {
_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 ParameterContext extends ParserRuleContext {
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
public ParameterContext() { }
public void copyFrom(ParameterContext ctx) {
super.copyFrom(ctx);
}
}
public static class NamedParameterContext extends ParameterContext {
public TerminalNode COLON() { return getToken(JPQLNextParser.COLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NamedParameterContext(ParameterContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterNamedParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitNamedParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitNamedParameter(this);
else return visitor.visitChildren(this);
}
}
public static class PositionalParameterContext extends ParameterContext {
public TerminalNode QUESTION_MARK() { return getToken(JPQLNextParser.QUESTION_MARK, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public PositionalParameterContext(ParameterContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPositionalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPositionalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPositionalParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 164, RULE_parameter);
try {
setState(1219);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
_localctx = new NamedParameterContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1215);
match(COLON);
setState(1216);
identifier();
}
break;
case QUESTION_MARK:
_localctx = new PositionalParameterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1217);
match(QUESTION_MARK);
setState(1218);
match(INTEGER_LITERAL);
}
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 FunctionContext extends ParserRuleContext {
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
public FunctionContext() { }
public void copyFrom(FunctionContext ctx) {
super.copyFrom(ctx);
}
}
public static class TemporalFunctionContext extends FunctionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(JPQLNextParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(JPQLNextParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(JPQLNextParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_INSTANT() { return getToken(JPQLNextParser.CURRENT_INSTANT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TemporalFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTemporalFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTemporalFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTemporalFunction(this);
else return visitor.visitChildren(this);
}
}
public static class TrimFunctionContext extends FunctionContext {
public TerminalNode TRIM() { return getToken(JPQLNextParser.TRIM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TrimSpecificationContext trimSpecification() {
return getRuleContext(TrimSpecificationContext.class,0);
}
public TrimCharacterContext trimCharacter() {
return getRuleContext(TrimCharacterContext.class,0);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TrimFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimFunction(this);
else return visitor.visitChildren(this);
}
}
public static class CountFunctionContext extends FunctionContext {
public IdentifierContext windowName;
public TerminalNode COUNT() { return getToken(JPQLNextParser.COUNT, 0); }
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public TerminalNode ASTERISK() { return getToken(JPQLNextParser.ASTERISK, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public WindowDefinitionContext windowDefinition() {
return getRuleContext(WindowDefinitionContext.class,0);
}
public CountFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterCountFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitCountFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitCountFunction(this);
else return visitor.visitChildren(this);
}
}
public static class GenericFunctionInvocationContext extends FunctionContext {
public IdentifierContext name;
public IdentifierContext windowName;
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public WindowDefinitionContext windowDefinition() {
return getRuleContext(WindowDefinitionContext.class,0);
}
public GenericFunctionInvocationContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGenericFunctionInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGenericFunctionInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGenericFunctionInvocation(this);
else return visitor.visitChildren(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 166, RULE_function);
int _la;
try {
setState(1300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
_localctx = new TrimFunctionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1221);
match(TRIM);
setState(1222);
match(LP);
setState(1224);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
{
setState(1223);
trimSpecification();
}
break;
}
setState(1227);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(1226);
trimCharacter();
}
break;
}
setState(1230);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1229);
match(FROM);
}
break;
}
setState(1232);
expression(0);
setState(1233);
match(RP);
}
break;
case 2:
_localctx = new TemporalFunctionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1235);
((TemporalFunctionContext)_localctx).name = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP))) != 0)) ) {
((TemporalFunctionContext)_localctx).name = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1238);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1236);
match(LP);
setState(1237);
match(RP);
}
break;
}
}
break;
case 3:
_localctx = new CountFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1240);
match(COUNT);
setState(1241);
match(LP);
setState(1247);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case CURRENT_DATE:
case CURRENT_INSTANT:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FALSE:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULL:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TRUE:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case LP:
case PLUS:
case MINUS:
case COLON:
case QUESTION_MARK:
case IDENTIFIER:
{
{
setState(1243);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1242);
match(DISTINCT);
}
break;
}
setState(1245);
expression(0);
}
}
break;
case ASTERISK:
{
setState(1246);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1249);
match(RP);
setState(1265);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
case 1:
{
setState(1255);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FILTER) {
{
setState(1250);
match(FILTER);
setState(1251);
match(LP);
setState(1252);
whereClause();
setState(1253);
match(RP);
}
}
{
setState(1257);
match(OVER);
setState(1263);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1258);
((CountFunctionContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1259);
match(LP);
setState(1260);
windowDefinition();
setState(1261);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
}
}
break;
case 4:
_localctx = new GenericFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1267);
((GenericFunctionInvocationContext)_localctx).name = identifier();
setState(1268);
match(LP);
setState(1270);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
{
setState(1269);
match(DISTINCT);
}
break;
}
setState(1280);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INTEGER_LITERAL) | (1L << BIG_INTEGER_LITERAL) | (1L << LONG_LITERAL) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIG_DECIMAL_LITERAL) | (1L << CHARACTER_LITERAL) | (1L << STRING_LITERAL) | (1L << AFTER) | (1L << ALL) | (1L << AND) | (1L << ANY) | (1L << AS) | (1L << ASC) | (1L << BEFORE) | (1L << BETWEEN) | (1L << BOTH) | (1L << BY) | (1L << CASE) | (1L << COLLATE) | (1L << CONTAINING) | (1L << COUNT) | (1L << CROSS) | (1L << CURRENT) | (1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP) | (1L << DELETE) | (1L << DESC) | (1L << DISTINCT) | (1L << ELSE) | (1L << EMPTY) | (1L << END) | (1L << ENTRY) | (1L << ESCAPE) | (1L << EXCEPT) | (1L << EXCLUDE) | (1L << EXISTS) | (1L << FALSE) | (1L << FETCH) | (1L << FILTER) | (1L << FIRST) | (1L << FOLLOWING) | (1L << FROM) | (1L << FULL) | (1L << GROUP) | (1L << GROUPS) | (1L << HAVING) | (1L << IN) | (1L << INDEX) | (1L << INNER) | (1L << INSERT) | (1L << INTERSECT) | (1L << INTO) | (1L << IS) | (1L << JOIN) | (1L << JUMP) | (1L << KEY) | (1L << LAST) | (1L << LEADING) | (1L << LEFT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LIKE - 64)) | (1L << (LIMIT - 64)) | (1L << (MEMBER - 64)) | (1L << (NEW - 64)) | (1L << (NO - 64)) | (1L << (NOT - 64)) | (1L << (NULL - 64)) | (1L << (NULLS - 64)) | (1L << (OBJECT - 64)) | (1L << (OF - 64)) | (1L << (OFFSET - 64)) | (1L << (ON - 64)) | (1L << (OR - 64)) | (1L << (ORDER - 64)) | (1L << (OTHERS - 64)) | (1L << (OUTER - 64)) | (1L << (OVER - 64)) | (1L << (PAGE - 64)) | (1L << (PARTITION - 64)) | (1L << (PRECEDING - 64)) | (1L << (RANGE - 64)) | (1L << (RECURSIVE - 64)) | (1L << (RETURNING - 64)) | (1L << (RIGHT - 64)) | (1L << (ROW - 64)) | (1L << (ROWS - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SOME - 64)) | (1L << (THEN - 64)) | (1L << (TIES - 64)) | (1L << (TO - 64)) | (1L << (TRAILING - 64)) | (1L << (TREAT - 64)) | (1L << (TRIM - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (UNBOUNDED - 64)) | (1L << (UNION - 64)) | (1L << (UPDATE - 64)) | (1L << (VALUE - 64)) | (1L << (VALUES - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WINDOW - 64)) | (1L << (WITH - 64)) | (1L << (TIMESTAMP_ESCAPE_START - 64)) | (1L << (DATE_ESCAPE_START - 64)) | (1L << (TIME_ESCAPE_START - 64)) | (1L << (LP - 64)) | (1L << (PLUS - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (MINUS - 128)) | (1L << (COLON - 128)) | (1L << (QUESTION_MARK - 128)) | (1L << (IDENTIFIER - 128)))) != 0)) {
{
setState(1272);
expression(0);
setState(1277);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1273);
match(COMMA);
setState(1274);
expression(0);
}
}
setState(1279);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1282);
match(RP);
setState(1298);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1288);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FILTER) {
{
setState(1283);
match(FILTER);
setState(1284);
match(LP);
setState(1285);
whereClause();
setState(1286);
match(RP);
}
}
{
setState(1290);
match(OVER);
setState(1296);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1291);
((GenericFunctionInvocationContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1292);
match(LP);
setState(1293);
windowDefinition();
setState(1294);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrimSpecificationContext extends ParserRuleContext {
public TerminalNode LEADING() { return getToken(JPQLNextParser.LEADING, 0); }
public TerminalNode TRAILING() { return getToken(JPQLNextParser.TRAILING, 0); }
public TerminalNode BOTH() { return getToken(JPQLNextParser.BOTH, 0); }
public TrimSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimSpecification(this);
else return visitor.visitChildren(this);
}
}
public final TrimSpecificationContext trimSpecification() throws RecognitionException {
TrimSpecificationContext _localctx = new TrimSpecificationContext(_ctx, getState());
enterRule(_localctx, 168, RULE_trimSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1302);
_la = _input.LA(1);
if ( !(_la==BOTH || _la==LEADING || _la==TRAILING) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrimCharacterContext extends ParserRuleContext {
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TrimCharacterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimCharacter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimCharacter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimCharacter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimCharacter(this);
else return visitor.visitChildren(this);
}
}
public final TrimCharacterContext trimCharacter() throws RecognitionException {
TrimCharacterContext _localctx = new TrimCharacterContext(_ctx, getState());
enterRule(_localctx, 170, RULE_trimCharacter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1304);
_la = _input.LA(1);
if ( !(_la==CHARACTER_LITERAL || _la==STRING_LITERAL) ) {
_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 IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public TerminalNode AFTER() { return getToken(JPQLNextParser.AFTER, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public TerminalNode ASC() { return getToken(JPQLNextParser.ASC, 0); }
public TerminalNode BEFORE() { return getToken(JPQLNextParser.BEFORE, 0); }
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode BOTH() { return getToken(JPQLNextParser.BOTH, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode COLLATE() { return getToken(JPQLNextParser.COLLATE, 0); }
public TerminalNode CONTAINING() { return getToken(JPQLNextParser.CONTAINING, 0); }
public TerminalNode COUNT() { return getToken(JPQLNextParser.COUNT, 0); }
public TerminalNode CROSS() { return getToken(JPQLNextParser.CROSS, 0); }
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode DELETE() { return getToken(JPQLNextParser.DELETE, 0); }
public TerminalNode DESC() { return getToken(JPQLNextParser.DESC, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public TerminalNode EMPTY() { return getToken(JPQLNextParser.EMPTY, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public TerminalNode ENTRY() { return getToken(JPQLNextParser.ENTRY, 0); }
public TerminalNode ESCAPE() { return getToken(JPQLNextParser.ESCAPE, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode EXCLUDE() { return getToken(JPQLNextParser.EXCLUDE, 0); }
public TerminalNode EXISTS() { return getToken(JPQLNextParser.EXISTS, 0); }
public TerminalNode FETCH() { return getToken(JPQLNextParser.FETCH, 0); }
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public TerminalNode FIRST() { return getToken(JPQLNextParser.FIRST, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode FULL() { return getToken(JPQLNextParser.FULL, 0); }
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode GROUPS() { return getToken(JPQLNextParser.GROUPS, 0); }
public TerminalNode HAVING() { return getToken(JPQLNextParser.HAVING, 0); }
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public TerminalNode INDEX() { return getToken(JPQLNextParser.INDEX, 0); }
public TerminalNode INNER() { return getToken(JPQLNextParser.INNER, 0); }
public TerminalNode INSERT() { return getToken(JPQLNextParser.INSERT, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode INTO() { return getToken(JPQLNextParser.INTO, 0); }
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public TerminalNode JUMP() { return getToken(JPQLNextParser.JUMP, 0); }
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LAST() { return getToken(JPQLNextParser.LAST, 0); }
public TerminalNode LEADING() { return getToken(JPQLNextParser.LEADING, 0); }
public TerminalNode LEFT() { return getToken(JPQLNextParser.LEFT, 0); }
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public TerminalNode LIMIT() { return getToken(JPQLNextParser.LIMIT, 0); }
public TerminalNode MEMBER() { return getToken(JPQLNextParser.MEMBER, 0); }
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public TerminalNode NO() { return getToken(JPQLNextParser.NO, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public TerminalNode NULLS() { return getToken(JPQLNextParser.NULLS, 0); }
public TerminalNode OBJECT() { return getToken(JPQLNextParser.OBJECT, 0); }
public TerminalNode OF() { return getToken(JPQLNextParser.OF, 0); }
public TerminalNode OFFSET() { return getToken(JPQLNextParser.OFFSET, 0); }
public TerminalNode ON() { return getToken(JPQLNextParser.ON, 0); }
public TerminalNode OR() { return getToken(JPQLNextParser.OR, 0); }
public TerminalNode ORDER() { return getToken(JPQLNextParser.ORDER, 0); }
public TerminalNode OTHERS() { return getToken(JPQLNextParser.OTHERS, 0); }
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public TerminalNode PAGE() { return getToken(JPQLNextParser.PAGE, 0); }
public TerminalNode PARTITION() { return getToken(JPQLNextParser.PARTITION, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public TerminalNode RANGE() { return getToken(JPQLNextParser.RANGE, 0); }
public TerminalNode RECURSIVE() { return getToken(JPQLNextParser.RECURSIVE, 0); }
public TerminalNode RETURNING() { return getToken(JPQLNextParser.RETURNING, 0); }
public TerminalNode RIGHT() { return getToken(JPQLNextParser.RIGHT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode ROWS() { return getToken(JPQLNextParser.ROWS, 0); }
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public TerminalNode SET() { return getToken(JPQLNextParser.SET, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public TerminalNode TIES() { return getToken(JPQLNextParser.TIES, 0); }
public TerminalNode TO() { return getToken(JPQLNextParser.TO, 0); }
public TerminalNode TRAILING() { return getToken(JPQLNextParser.TRAILING, 0); }
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode TRIM() { return getToken(JPQLNextParser.TRIM, 0); }
public TerminalNode TYPE() { return getToken(JPQLNextParser.TYPE, 0); }
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode UPDATE() { return getToken(JPQLNextParser.UPDATE, 0); }
public TerminalNode VALUE() { return getToken(JPQLNextParser.VALUE, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public TerminalNode WHERE() { return getToken(JPQLNextParser.WHERE, 0); }
public TerminalNode WINDOW() { return getToken(JPQLNextParser.WINDOW, 0); }
public TerminalNode WITH() { return getToken(JPQLNextParser.WITH, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 172, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1306);
_la = _input.LA(1);
if ( !(((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (AFTER - 10)) | (1L << (ALL - 10)) | (1L << (AND - 10)) | (1L << (ANY - 10)) | (1L << (AS - 10)) | (1L << (ASC - 10)) | (1L << (BEFORE - 10)) | (1L << (BETWEEN - 10)) | (1L << (BOTH - 10)) | (1L << (BY - 10)) | (1L << (CASE - 10)) | (1L << (COLLATE - 10)) | (1L << (CONTAINING - 10)) | (1L << (COUNT - 10)) | (1L << (CROSS - 10)) | (1L << (CURRENT - 10)) | (1L << (DELETE - 10)) | (1L << (DESC - 10)) | (1L << (DISTINCT - 10)) | (1L << (ELSE - 10)) | (1L << (EMPTY - 10)) | (1L << (END - 10)) | (1L << (ENTRY - 10)) | (1L << (ESCAPE - 10)) | (1L << (EXCEPT - 10)) | (1L << (EXCLUDE - 10)) | (1L << (EXISTS - 10)) | (1L << (FETCH - 10)) | (1L << (FILTER - 10)) | (1L << (FIRST - 10)) | (1L << (FOLLOWING - 10)) | (1L << (FROM - 10)) | (1L << (FULL - 10)) | (1L << (GROUP - 10)) | (1L << (GROUPS - 10)) | (1L << (HAVING - 10)) | (1L << (IN - 10)) | (1L << (INDEX - 10)) | (1L << (INNER - 10)) | (1L << (INSERT - 10)) | (1L << (INTERSECT - 10)) | (1L << (INTO - 10)) | (1L << (IS - 10)) | (1L << (JOIN - 10)) | (1L << (JUMP - 10)) | (1L << (KEY - 10)) | (1L << (LAST - 10)) | (1L << (LEADING - 10)) | (1L << (LEFT - 10)) | (1L << (LIKE - 10)) | (1L << (LIMIT - 10)) | (1L << (MEMBER - 10)) | (1L << (NEW - 10)) | (1L << (NO - 10)) | (1L << (NOT - 10)) | (1L << (NULLS - 10)) | (1L << (OBJECT - 10)) | (1L << (OF - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (OFFSET - 74)) | (1L << (ON - 74)) | (1L << (OR - 74)) | (1L << (ORDER - 74)) | (1L << (OTHERS - 74)) | (1L << (OUTER - 74)) | (1L << (OVER - 74)) | (1L << (PAGE - 74)) | (1L << (PARTITION - 74)) | (1L << (PRECEDING - 74)) | (1L << (RANGE - 74)) | (1L << (RECURSIVE - 74)) | (1L << (RETURNING - 74)) | (1L << (RIGHT - 74)) | (1L << (ROW - 74)) | (1L << (ROWS - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SOME - 74)) | (1L << (THEN - 74)) | (1L << (TIES - 74)) | (1L << (TO - 74)) | (1L << (TRAILING - 74)) | (1L << (TREAT - 74)) | (1L << (TRIM - 74)) | (1L << (TYPE - 74)) | (1L << (UNBOUNDED - 74)) | (1L << (UNION - 74)) | (1L << (UPDATE - 74)) | (1L << (VALUE - 74)) | (1L << (VALUES - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (WINDOW - 74)) | (1L << (WITH - 74)) | (1L << (IDENTIFIER - 74)))) != 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 71:
return expression_sempred((ExpressionContext)_localctx, predIndex);
case 72:
return predicate_sempred((PredicateContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 16);
case 1:
return precpred(_ctx, 15);
case 2:
return precpred(_ctx, 14);
case 3:
return precpred(_ctx, 13);
case 4:
return precpred(_ctx, 12);
case 5:
return precpred(_ctx, 11);
}
return true;
}
private boolean predicate_sempred(PredicateContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 21);
case 7:
return precpred(_ctx, 20);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u008b\u051f\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<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\3\2\3\2\5\2\u00b3\n\2\3\2\5\2\u00b6\n\2\3\2\3"+
"\2\3\2\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00c7\n\4\3"+
"\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00d2\n\6\3\7\3\7\3\7\3\7\5\7\u00d8"+
"\n\7\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7\t\u00e2\n\t\f\t\16\t\u00e5\13\t"+
"\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u00f1\n\n\3\13\3\13\3\13"+
"\3\13\3\13\3\13\5\13\u00f9\n\13\3\13\3\13\5\13\u00fd\n\13\3\f\3\f\3\f"+
"\3\f\3\f\3\f\5\f\u0105\n\f\3\f\3\f\5\f\u0109\n\f\3\r\3\r\3\r\5\r\u010e"+
"\n\r\3\r\5\r\u0111\n\r\3\r\5\r\u0114\n\r\3\r\5\r\u0117\n\r\3\r\3\r\5\r"+
"\u011b\n\r\3\r\5\r\u011e\n\r\3\r\5\r\u0121\n\r\3\16\3\16\3\16\5\16\u0126"+
"\n\16\3\16\5\16\u0129\n\16\3\17\3\17\5\17\u012d\n\17\3\17\3\17\3\17\3"+
"\17\3\17\5\17\u0134\n\17\3\17\5\17\u0137\n\17\3\17\5\17\u013a\n\17\3\17"+
"\5\17\u013d\n\17\3\20\3\20\5\20\u0141\n\20\3\20\3\20\3\20\3\20\3\20\5"+
"\20\u0148\n\20\3\20\5\20\u014b\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+
"\3\20\3\20\7\20\u0156\n\20\f\20\16\20\u0159\13\20\3\20\5\20\u015c\n\20"+
"\3\20\5\20\u015f\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0168\n"+
"\21\3\21\3\21\3\21\5\21\u016d\n\21\3\22\3\22\3\22\3\22\3\22\3\22\3\22"+
"\3\22\3\22\3\22\3\22\5\22\u017a\n\22\3\23\3\23\3\23\3\23\7\23\u0180\n"+
"\23\f\23\16\23\u0183\13\23\3\23\3\23\3\24\3\24\3\24\3\24\7\24\u018b\n"+
"\24\f\24\16\24\u018e\13\24\3\25\5\25\u0191\n\25\3\25\3\25\5\25\u0195\n"+
"\25\3\25\5\25\u0198\n\25\3\25\5\25\u019b\n\25\3\25\5\25\u019e\n\25\3\25"+
"\5\25\u01a1\n\25\3\25\3\25\5\25\u01a5\n\25\3\25\5\25\u01a8\n\25\3\25\5"+
"\25\u01ab\n\25\3\25\5\25\u01ae\n\25\3\25\5\25\u01b1\n\25\3\26\3\26\3\26"+
"\3\26\7\26\u01b7\n\26\f\26\16\26\u01ba\13\26\3\27\3\27\3\27\3\27\7\27"+
"\u01c0\n\27\f\27\16\27\u01c3\13\27\3\30\3\30\3\30\3\30\7\30\u01c9\n\30"+
"\f\30\16\30\u01cc\13\30\3\31\3\31\3\31\3\31\7\31\u01d2\n\31\f\31\16\31"+
"\u01d5\13\31\3\32\3\32\5\32\u01d9\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3"+
"\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u01e8\n\32\f\32\16\32\u01eb\13"+
"\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u01f6\n\32\3\32"+
"\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u0201\n\32\f\32\16\32\u0204"+
"\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u020e\n\32\5\32\u0210"+
"\n\32\3\33\3\33\3\33\3\33\7\33\u0216\n\33\f\33\16\33\u0219\13\33\3\33"+
"\3\33\3\34\3\34\3\35\3\35\3\35\5\35\u0222\n\35\3\36\3\36\3\36\3\36\3\37"+
"\3\37\3\37\3\37\3\37\3\37\5\37\u022e\n\37\3 \3 \3 \5 \u0233\n \3 \3 \5"+
" \u0237\n \3!\3!\3!\3!\5!\u023d\n!\3\"\3\"\5\"\u0241\n\"\3#\3#\3#\3#\3"+
"#\3#\3#\3#\5#\u024b\n#\3#\5#\u024e\n#\3$\5$\u0251\n$\3$\5$\u0254\n$\3"+
"$\5$\u0257\n$\5$\u0259\n$\3%\3%\3%\3&\3&\5&\u0260\n&\3&\3&\3&\7&\u0265"+
"\n&\f&\16&\u0268\13&\3\'\3\'\5\'\u026c\n\'\3\'\3\'\3\'\7\'\u0271\n\'\f"+
"\'\16\'\u0274\13\'\3(\3(\5(\u0278\n(\3)\3)\3*\3*\3*\3*\5*\u0280\n*\3+"+
"\3+\3+\5+\u0285\n+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\7-\u0292\n-\f-\16"+
"-\u0295\13-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u02a3\n\60"+
"\3\60\5\60\u02a6\n\60\3\61\3\61\3\61\3\61\3\61\7\61\u02ad\n\61\f\61\16"+
"\61\u02b0\13\61\5\61\u02b2\n\61\3\61\3\61\3\62\3\62\3\62\3\62\5\62\u02ba"+
"\n\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63"+
"\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02cf\n\63\3\64\3\64\3\64\7\64\u02d4"+
"\n\64\f\64\16\64\u02d7\13\64\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u02df"+
"\n\65\5\65\u02e1\n\65\3\66\3\66\3\66\3\66\3\66\7\66\u02e8\n\66\f\66\16"+
"\66\u02eb\13\66\3\67\3\67\38\38\38\39\39\39\39\39\79\u02f7\n9\f9\169\u02fa"+
"\139\3:\3:\3:\5:\u02ff\n:\3:\3:\3:\5:\u0304\n:\5:\u0306\n:\3;\3;\3;\3"+
";\3;\3;\3;\3;\3;\3;\3;\3;\3;\7;\u0315\n;\f;\16;\u0318\13;\3<\5<\u031b"+
"\n<\3<\5<\u031e\n<\3<\5<\u0321\n<\3<\5<\u0324\n<\3=\3=\3=\3=\3=\7=\u032b"+
"\n=\f=\16=\u032e\13=\3>\3>\3>\5>\u0333\n>\3>\3>\3>\3>\3>\3>\5>\u033b\n"+
">\5>\u033d\n>\3?\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u0349\n?\3@\3@\3@\3@\3"+
"@\3@\3@\3@\3@\3@\3@\3@\5@\u0357\n@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u0363"+
"\nA\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\5C\u036f\nC\3D\3D\5D\u0373\nD\3E\3E"+
"\3E\3E\3E\3E\3E\7E\u037c\nE\fE\16E\u037f\13E\3E\3E\5E\u0383\nE\3F\3F\5"+
"F\u0387\nF\3G\3G\3G\7G\u038c\nG\fG\16G\u038f\13G\3H\3H\3H\3I\3I\3I\3I"+
"\3I\3I\3I\3I\3I\3I\3I\3I\6I\u03a0\nI\rI\16I\u03a1\3I\3I\5I\u03a6\nI\3"+
"I\3I\3I\3I\6I\u03ac\nI\rI\16I\u03ad\3I\3I\5I\u03b2\nI\3I\3I\3I\3I\3I\3"+
"I\3I\3I\5I\u03bc\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3"+
"I\3I\7I\u03d0\nI\fI\16I\u03d3\13I\3J\3J\3J\3J\3J\3J\3J\3J\5J\u03dd\nJ"+
"\3J\3J\3J\3J\3J\3J\5J\u03e5\nJ\3J\3J\3J\5J\u03ea\nJ\3J\3J\3J\3J\3J\5J"+
"\u03f1\nJ\3J\3J\3J\3J\3J\5J\u03f8\nJ\3J\3J\3J\3J\3J\5J\u03ff\nJ\3J\3J"+
"\3J\5J\u0404\nJ\3J\3J\3J\3J\3J\5J\u040b\nJ\3J\3J\3J\5J\u0410\nJ\3J\3J"+
"\3J\3J\3J\5J\u0417\nJ\3J\3J\3J\5J\u041c\nJ\3J\3J\3J\3J\3J\5J\u0423\nJ"+
"\3J\3J\3J\5J\u0428\nJ\3J\3J\3J\3J\3J\5J\u042f\nJ\3J\3J\3J\5J\u0434\nJ"+
"\3J\3J\3J\3J\3J\5J\u043b\nJ\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J"+
"\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u0457\nJ\3J\3J\3J\3J\3J\5J\u045e"+
"\nJ\3J\3J\3J\3J\3J\3J\3J\5J\u0467\nJ\3J\3J\3J\3J\5J\u046d\nJ\3J\3J\5J"+
"\u0471\nJ\3J\3J\3J\3J\5J\u0477\nJ\3J\3J\3J\3J\3J\3J\7J\u047f\nJ\fJ\16"+
"J\u0482\13J\3K\3K\3K\3K\7K\u0488\nK\fK\16K\u048b\13K\3K\3K\3K\5K\u0490"+
"\nK\3L\3L\3L\3L\5L\u0496\nL\3L\3L\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3O\3O"+
"\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u04b2\nO\3P\3P\3P\3P\3Q\3Q\3Q"+
"\3Q\3R\3R\3R\3R\3S\3S\3T\3T\3T\3T\5T\u04c6\nT\3U\3U\3U\5U\u04cb\nU\3U"+
"\5U\u04ce\nU\3U\5U\u04d1\nU\3U\3U\3U\3U\3U\3U\5U\u04d9\nU\3U\3U\3U\5U"+
"\u04de\nU\3U\3U\5U\u04e2\nU\3U\3U\3U\3U\3U\3U\5U\u04ea\nU\3U\3U\3U\3U"+
"\3U\3U\5U\u04f2\nU\5U\u04f4\nU\3U\3U\3U\5U\u04f9\nU\3U\3U\3U\7U\u04fe"+
"\nU\fU\16U\u0501\13U\5U\u0503\nU\3U\3U\3U\3U\3U\3U\5U\u050b\nU\3U\3U\3"+
"U\3U\3U\3U\5U\u0513\nU\5U\u0515\nU\5U\u0517\nU\3V\3V\3W\3W\3X\3X\3X\2"+
"\4\u0090\u0092Y\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62"+
"\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+
"\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+
"\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\2\20\5\2((99ii\4\2\r\r\"\""+
"\4\2EEMM\5\2\61\61AAZZ\4\2\21\21!!\4\2..??\5\2\63\63WW\\\\\4\2\f\f\22"+
"\22\4\2||\u0089\u0089\3\2\34\37\5\2\r\r\17\17__\3\2\n\13\5\2\24\24@@c"+
"c\t\2\f\33 *,GILNegp\u008a\u008a\2\u05ad\2\u00b5\3\2\2\2\4\u00ba\3\2\2"+
"\2\6\u00c6\3\2\2\2\b\u00c8\3\2\2\2\n\u00d1\3\2\2\2\f\u00d7\3\2\2\2\16"+
"\u00d9\3\2\2\2\20\u00dc\3\2\2\2\22\u00f0\3\2\2\2\24\u00fc\3\2\2\2\26\u0108"+
"\3\2\2\2\30\u010a\3\2\2\2\32\u0122\3\2\2\2\34\u012a\3\2\2\2\36\u013e\3"+
"\2\2\2 \u0160\3\2\2\2\"\u0179\3\2\2\2$\u017b\3\2\2\2&\u0186\3\2\2\2(\u0190"+
"\3\2\2\2*\u01b2\3\2\2\2,\u01bb\3\2\2\2.\u01c4\3\2\2\2\60\u01cd\3\2\2\2"+
"\62\u020f\3\2\2\2\64\u0211\3\2\2\2\66\u021c\3\2\2\28\u0221\3\2\2\2:\u0223"+
"\3\2\2\2<\u0227\3\2\2\2>\u022f\3\2\2\2@\u0238\3\2\2\2B\u0240\3\2\2\2D"+
"\u0242\3\2\2\2F\u0258\3\2\2\2H\u025a\3\2\2\2J\u025d\3\2\2\2L\u0269\3\2"+
"\2\2N\u0275\3\2\2\2P\u0279\3\2\2\2R\u027f\3\2\2\2T\u0284\3\2\2\2V\u0286"+
"\3\2\2\2X\u028b\3\2\2\2Z\u0298\3\2\2\2\\\u029a\3\2\2\2^\u02a5\3\2\2\2"+
"`\u02a7\3\2\2\2b\u02b5\3\2\2\2d\u02ce\3\2\2\2f\u02d0\3\2\2\2h\u02d8\3"+
"\2\2\2j\u02e2\3\2\2\2l\u02ec\3\2\2\2n\u02ee\3\2\2\2p\u02f1\3\2\2\2r\u02fb"+
"\3\2\2\2t\u0307\3\2\2\2v\u031a\3\2\2\2x\u0325\3\2\2\2z\u033c\3\2\2\2|"+
"\u0348\3\2\2\2~\u0356\3\2\2\2\u0080\u0362\3\2\2\2\u0082\u0364\3\2\2\2"+
"\u0084\u036e\3\2\2\2\u0086\u0372\3\2\2\2\u0088\u0382\3\2\2\2\u008a\u0386"+
"\3\2\2\2\u008c\u0388\3\2\2\2\u008e\u0390\3\2\2\2\u0090\u03bb\3\2\2\2\u0092"+
"\u0476\3\2\2\2\u0094\u048f\3\2\2\2\u0096\u0491\3\2\2\2\u0098\u0499\3\2"+
"\2\2\u009a\u049e\3\2\2\2\u009c\u04b1\3\2\2\2\u009e\u04b3\3\2\2\2\u00a0"+
"\u04b7\3\2\2\2\u00a2\u04bb\3\2\2\2\u00a4\u04bf\3\2\2\2\u00a6\u04c5\3\2"+
"\2\2\u00a8\u0516\3\2\2\2\u00aa\u0518\3\2\2\2\u00ac\u051a\3\2\2\2\u00ae"+
"\u051c\3\2\2\2\u00b0\u00b2\7p\2\2\u00b1\u00b3\7X\2\2\u00b2\u00b1\3\2\2"+
"\2\u00b2\u00b3\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b6\5\20\t\2\u00b5"+
"\u00b0\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\5\22"+
"\n\2\u00b8\u00b9\7\2\2\3\u00b9\3\3\2\2\2\u00ba\u00bb\5R*\2\u00bb\u00bc"+
"\7\2\2\3\u00bc\5\3\2\2\2\u00bd\u00be\5^\60\2\u00be\u00bf\7\2\2\3\u00bf"+
"\u00c7\3\2\2\2\u00c0\u00c1\5b\62\2\u00c1\u00c2\7\2\2\3\u00c2\u00c7\3\2"+
"\2\2\u00c3\u00c4\5`\61\2\u00c4\u00c5\7\2\2\3\u00c5\u00c7\3\2\2\2\u00c6"+
"\u00bd\3\2\2\2\u00c6\u00c0\3\2\2\2\u00c6\u00c3\3\2\2\2\u00c7\7\3\2\2\2"+
"\u00c8\u00c9\5\u0090I\2\u00c9\u00ca\7\2\2\3\u00ca\t\3\2\2\2\u00cb\u00cc"+
"\5\u008aF\2\u00cc\u00cd\7\2\2\3\u00cd\u00d2\3\2\2\2\u00ce\u00cf\5\u008c"+
"G\2\u00cf\u00d0\7\2\2\3\u00d0\u00d2\3\2\2\2\u00d1\u00cb\3\2\2\2\u00d1"+
"\u00ce\3\2\2\2\u00d2\13\3\2\2\2\u00d3\u00d4\5\u008aF\2\u00d4\u00d5\7\2"+
"\2\3\u00d5\u00d8\3\2\2\2\u00d6\u00d8\5\6\4\2\u00d7\u00d3\3\2\2\2\u00d7"+
"\u00d6\3\2\2\2\u00d8\r\3\2\2\2\u00d9\u00da\5\u0092J\2\u00da\u00db\7\2"+
"\2\3\u00db\17\3\2\2\2\u00dc\u00dd\5\66\34\2\u00dd\u00de\7}\2\2\u00de\u00e3"+
"\5\u00aeX\2\u00df\u00e0\7{\2\2\u00e0\u00e2\5\u00aeX\2\u00e1\u00df\3\2"+
"\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4"+
"\u00e6\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00e7\7~\2\2\u00e7\u00e8\7\20"+
"\2\2\u00e8\u00e9\7}\2\2\u00e9\u00ea\5\22\n\2\u00ea\u00eb\7~\2\2\u00eb"+
"\21\3\2\2\2\u00ec\u00f1\5\24\13\2\u00ed\u00f1\5\36\20\2\u00ee\u00f1\5"+
"\34\17\2\u00ef\u00f1\5 \21\2\u00f0\u00ec\3\2\2\2\u00f0\u00ed\3\2\2\2\u00f0"+
"\u00ee\3\2\2\2\u00f0\u00ef\3\2\2\2\u00f1\23\3\2\2\2\u00f2\u00fd\5(\25"+
"\2\u00f3\u00f4\7}\2\2\u00f4\u00f5\5\24\13\2\u00f5\u00f6\7~\2\2\u00f6\u00f8"+
"\t\2\2\2\u00f7\u00f9\t\3\2\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9"+
"\u00fa\3\2\2\2\u00fa\u00fb\5\24\13\2\u00fb\u00fd\3\2\2\2\u00fc\u00f2\3"+
"\2\2\2\u00fc\u00f3\3\2\2\2\u00fd\25\3\2\2\2\u00fe\u0109\5\30\r\2\u00ff"+
"\u0100\7}\2\2\u0100\u0101\5\26\f\2\u0101\u0102\7~\2\2\u0102\u0104\t\2"+
"\2\2\u0103\u0105\t\3\2\2\u0104\u0103\3\2\2\2\u0104\u0105\3\2\2\2\u0105"+
"\u0106\3\2\2\2\u0106\u0107\5\26\f\2\u0107\u0109\3\2\2\2\u0108\u00fe\3"+
"\2\2\2\u0108\u00ff\3\2\2\2\u0109\27\3\2\2\2\u010a\u010b\5L\'\2\u010b\u010d"+
"\5,\27\2\u010c\u010e\5\u0088E\2\u010d\u010c\3\2\2\2\u010d\u010e\3\2\2"+
"\2\u010e\u0110\3\2\2\2\u010f\u0111\5\u008eH\2\u0110\u010f\3\2\2\2\u0110"+
"\u0111\3\2\2\2\u0111\u0113\3\2\2\2\u0112\u0114\5j\66\2\u0113\u0112\3\2"+
"\2\2\u0113\u0114\3\2\2\2\u0114\u0116\3\2\2\2\u0115\u0117\5n8\2\u0116\u0115"+
"\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u011d\3\2\2\2\u0118\u011a\t\2\2\2\u0119"+
"\u011b\t\3\2\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011c\3\2"+
"\2\2\u011c\u011e\5\26\f\2\u011d\u0118\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
"\u0120\3\2\2\2\u011f\u0121\5\32\16\2\u0120\u011f\3\2\2\2\u0120\u0121\3"+
"\2\2\2\u0121\31\3\2\2\2\u0122\u0128\5p9\2\u0123\u0125\5\u0082B\2\u0124"+
"\u0126\5\u0084C\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0129"+
"\3\2\2\2\u0127\u0129\5\u0084C\2\u0128\u0123\3\2\2\2\u0128\u0127\3\2\2"+
"\2\u0129\33\3\2\2\2\u012a\u012c\7 \2\2\u012b\u012d\7\60\2\2\u012c\u012b"+
"\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0133\5\66\34\2"+
"\u012f\u0130\7}\2\2\u0130\u0131\5f\64\2\u0131\u0132\7~\2\2\u0132\u0134"+
"\3\2\2\2\u0133\u012f\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135"+
"\u0137\58\35\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0139\3\2"+
"\2\2\u0138\u013a\5\u008eH\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a"+
"\u013c\3\2\2\2\u013b\u013d\5&\24\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2"+
"\2\2\u013d\35\3\2\2\2\u013e\u0140\7j\2\2\u013f\u0141\7\60\2\2\u0140\u013f"+
"\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0142\3\2\2\2\u0142\u0147\5\66\34\2"+
"\u0143\u0144\7}\2\2\u0144\u0145\5f\64\2\u0145\u0146\7~\2\2\u0146\u0148"+
"\3\2\2\2\u0147\u0143\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149"+
"\u014b\58\35\2\u014a\u0149\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u014c\3\2"+
"\2\2\u014c\u014d\7^\2\2\u014d\u014e\5\"\22\2\u014e\u014f\7u\2\2\u014f"+
"\u0157\5\u0090I\2\u0150\u0151\7{\2\2\u0151\u0152\5\"\22\2\u0152\u0153"+
"\7u\2\2\u0153\u0154\5\u0090I\2\u0154\u0156\3\2\2\2\u0155\u0150\3\2\2\2"+
"\u0156\u0159\3\2\2\2\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u015b"+
"\3\2\2\2\u0159\u0157\3\2\2\2\u015a\u015c\5\u008eH\2\u015b\u015a\3\2\2"+
"\2\u015b\u015c\3\2\2\2\u015c\u015e\3\2\2\2\u015d\u015f\5&\24\2\u015e\u015d"+
"\3\2\2\2\u015e\u015f\3\2\2\2\u015f\37\3\2\2\2\u0160\u0161\78\2\2\u0161"+
"\u0162\7:\2\2\u0162\u0167\5\66\34\2\u0163\u0164\7}\2\2\u0164\u0165\5f"+
"\64\2\u0165\u0166\7~\2\2\u0166\u0168\3\2\2\2\u0167\u0163\3\2\2\2\u0167"+
"\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\5$\23\2\u016a\u016c\5("+
"\25\2\u016b\u016d\5&\24\2\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d"+
"!\3\2\2\2\u016e\u017a\5f\64\2\u016f\u0170\7>\2\2\u0170\u0171\7}\2\2\u0171"+
"\u0172\5^\60\2\u0172\u0173\7~\2\2\u0173\u017a\3\2\2\2\u0174\u0175\7\66"+
"\2\2\u0175\u0176\7}\2\2\u0176\u0177\5^\60\2\u0177\u0178\7~\2\2\u0178\u017a"+
"\3\2\2\2\u0179\u016e\3\2\2\2\u0179\u016f\3\2\2\2\u0179\u0174\3\2\2\2\u017a"+
"#\3\2\2\2\u017b\u017c\7}\2\2\u017c\u0181\5\"\22\2\u017d\u017e\7{\2\2\u017e"+
"\u0180\5\"\22\2\u017f\u017d\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3"+
"\2\2\2\u0181\u0182\3\2\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184"+
"\u0185\7~\2\2\u0185%\3\2\2\2\u0186\u0187\7Y\2\2\u0187\u018c\5f\64\2\u0188"+
"\u0189\7{\2\2\u0189\u018b\5f\64\2\u018a\u0188\3\2\2\2\u018b\u018e\3\2"+
"\2\2\u018c\u018a\3\2\2\2\u018c\u018d\3\2\2\2\u018d\'\3\2\2\2\u018e\u018c"+
"\3\2\2\2\u018f\u0191\5J&\2\u0190\u018f\3\2\2\2\u0190\u0191\3\2\2\2\u0191"+
"\u0192\3\2\2\2\u0192\u0194\5*\26\2\u0193\u0195\5\u0088E\2\u0194\u0193"+
"\3\2\2\2\u0194\u0195\3\2\2\2\u0195\u0197\3\2\2\2\u0196\u0198\5\u008eH"+
"\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u019a\3\2\2\2\u0199\u019b"+
"\5j\66\2\u019a\u0199\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019d\3\2\2\2\u019c"+
"\u019e\5n8\2\u019d\u019c\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u01a0\3\2\2"+
"\2\u019f\u01a1\5t;\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a7"+
"\3\2\2\2\u01a2\u01a4\t\2\2\2\u01a3\u01a5\t\3\2\2\u01a4\u01a3\3\2\2\2\u01a4"+
"\u01a5\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a8\5(\25\2\u01a7\u01a2\3\2"+
"\2\2\u01a7\u01a8\3\2\2\2\u01a8\u01aa\3\2\2\2\u01a9\u01ab\5p9\2\u01aa\u01a9"+
"\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ad\3\2\2\2\u01ac\u01ae\5\u0082B"+
"\2\u01ad\u01ac\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\3\2\2\2\u01af\u01b1"+
"\5\u0084C\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1)\3\2\2\2\u01b2"+
"\u01b3\7\60\2\2\u01b3\u01b8\5.\30\2\u01b4\u01b5\7{\2\2\u01b5\u01b7\5."+
"\30\2\u01b6\u01b4\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b8"+
"\u01b9\3\2\2\2\u01b9+\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01bc\7\60\2\2"+
"\u01bc\u01c1\5\60\31\2\u01bd\u01be\7{\2\2\u01be\u01c0\5\60\31\2\u01bf"+
"\u01bd\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c1\u01c2\3\2"+
"\2\2\u01c2-\3\2\2\2\u01c3\u01c1\3\2\2\2\u01c4\u01ca\5\62\32\2\u01c5\u01c9"+
"\5:\36\2\u01c6\u01c9\5<\37\2\u01c7\u01c9\5> \2\u01c8\u01c5\3\2\2\2\u01c8"+
"\u01c6\3\2\2\2\u01c8\u01c7\3\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01c8\3\2"+
"\2\2\u01ca\u01cb\3\2\2\2\u01cb/\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cd\u01d3"+
"\5\62\32\2\u01ce\u01d2\5:\36\2\u01cf\u01d2\5<\37\2\u01d0\u01d2\5@!\2\u01d1"+
"\u01ce\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d1\u01d0\3\2\2\2\u01d2\u01d5\3\2"+
"\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\61\3\2\2\2\u01d5\u01d3"+
"\3\2\2\2\u01d6\u01d8\5\66\34\2\u01d7\u01d9\58\35\2\u01d8\u01d7\3\2\2\2"+
"\u01d8\u01d9\3\2\2\2\u01d9\u0210\3\2\2\2\u01da\u01db\5\66\34\2\u01db\u01dc"+
"\7}\2\2\u01dc\u01dd\7\4\2\2\u01dd\u01de\7l\2\2\u01de\u01df\7~\2\2\u01df"+
"\u01e0\58\35\2\u01e0\u0210\3\2\2\2\u01e1\u01e2\5\66\34\2\u01e2\u01e3\7"+
"}\2\2\u01e3\u01e4\7l\2\2\u01e4\u01e9\5\64\33\2\u01e5\u01e6\7{\2\2\u01e6"+
"\u01e8\5\64\33\2\u01e7\u01e5\3\2\2\2\u01e8\u01eb\3\2\2\2\u01e9\u01e7\3"+
"\2\2\2\u01e9\u01ea\3\2\2\2\u01ea\u01ec\3\2\2\2\u01eb\u01e9\3\2\2\2\u01ec"+
"\u01ed\7~\2\2\u01ed\u01ee\58\35\2\u01ee\u0210\3\2\2\2\u01ef\u01f0\5\u00ae"+
"X\2\u01f0\u01f1\7}\2\2\u01f1\u01f2\7\4\2\2\u01f2\u01f5\7l\2\2\u01f3\u01f4"+
"\7B\2\2\u01f4\u01f6\5\66\34\2\u01f5\u01f3\3\2\2\2\u01f5\u01f6\3\2\2\2"+
"\u01f6\u01f7\3\2\2\2\u01f7\u01f8\7~\2\2\u01f8\u01f9\58\35\2\u01f9\u0210"+
"\3\2\2\2\u01fa\u01fb\5\u00aeX\2\u01fb\u01fc\7}\2\2\u01fc\u01fd\7l\2\2"+
"\u01fd\u0202\5\64\33\2\u01fe\u01ff\7{\2\2\u01ff\u0201\5\64\33\2\u0200"+
"\u01fe\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2"+
"\2\2\u0203\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7~\2\2\u0206"+
"\u0207\58\35\2\u0207\u0210\3\2\2\2\u0208\u0209\t\4\2\2\u0209\u020a\7}"+
"\2\2\u020a\u020b\5\66\34\2\u020b\u020d\7~\2\2\u020c\u020e\58\35\2\u020d"+
"\u020c\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2\2\2\u020f\u01d6\3\2"+
"\2\2\u020f\u01da\3\2\2\2\u020f\u01e1\3\2\2\2\u020f\u01ef\3\2\2\2\u020f"+
"\u01fa\3\2\2\2\u020f\u0208\3\2\2\2\u0210\63\3\2\2\2\u0211\u0212\7}\2\2"+
"\u0212\u0217\5\u009cO\2\u0213\u0214\7{\2\2\u0214\u0216\5\u009cO\2\u0215"+
"\u0213\3\2\2\2\u0216\u0219\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0218\3\2"+
"\2\2\u0218\u021a\3\2\2\2\u0219\u0217\3\2\2\2\u021a\u021b\7~\2\2\u021b"+
"\65\3\2\2\2\u021c\u021d\5f\64\2\u021d\67\3\2\2\2\u021e\u021f\7\20\2\2"+
"\u021f\u0222\5\u00aeX\2\u0220\u0222\7\u008a\2\2\u0221\u021e\3\2\2\2\u0221"+
"\u0220\3\2\2\2\u02229\3\2\2\2\u0223\u0224\7\32\2\2\u0224\u0225\7<\2\2"+
"\u0225\u0226\5\62\32\2\u0226;\3\2\2\2\u0227\u0228\7{\2\2\u0228\u0229\7"+
"\65\2\2\u0229\u022a\7}\2\2\u022a\u022b\5^\60\2\u022b\u022d\7~\2\2\u022c"+
"\u022e\58\35\2\u022d\u022c\3\2\2\2\u022d\u022e\3\2\2\2\u022e=\3\2\2\2"+
"\u022f\u0230\5F$\2\u0230\u0232\7<\2\2\u0231\u0233\7,\2\2\u0232\u0231\3"+
"\2\2\2\u0232\u0233\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0236\5B\"\2\u0235"+
"\u0237\5H%\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237?\3\2\2\2\u0238"+
"\u0239\5F$\2\u0239\u023a\7<\2\2\u023a\u023c\5B\"\2\u023b\u023d\5H%\2\u023c"+
"\u023b\3\2\2\2\u023c\u023d\3\2\2\2\u023dA\3\2\2\2\u023e\u0241\5\62\32"+
"\2\u023f\u0241\5D#\2\u0240\u023e\3\2\2\2\u0240\u023f\3\2\2\2\u0241C\3"+
"\2\2\2\u0242\u0243\7d\2\2\u0243\u0244\7}\2\2\u0244\u0245\5^\60\2\u0245"+
"\u0246\7\20\2\2\u0246\u0247\5\66\34\2\u0247\u024a\7~\2\2\u0248\u0249\7"+
"|\2\2\u0249\u024b\5h\65\2\u024a\u0248\3\2\2\2\u024a\u024b\3\2\2\2\u024b"+
"\u024d\3\2\2\2\u024c\u024e\58\35\2\u024d\u024c\3\2\2\2\u024d\u024e\3\2"+
"\2\2\u024eE\3\2\2\2\u024f\u0251\7\67\2\2\u0250\u024f\3\2\2\2\u0250\u0251"+
"\3\2\2\2\u0251\u0259\3\2\2\2\u0252\u0254\t\5\2\2\u0253\u0252\3\2\2\2\u0253"+
"\u0254\3\2\2\2\u0254\u0256\3\2\2\2\u0255\u0257\7R\2\2\u0256\u0255\3\2"+
"\2\2\u0256\u0257\3\2\2\2\u0257\u0259\3\2\2\2\u0258\u0250\3\2\2\2\u0258"+
"\u0253\3\2\2\2\u0259G\3\2\2\2\u025a\u025b\7N\2\2\u025b\u025c\5\u0092J"+
"\2\u025cI\3\2\2\2\u025d\u025f\7]\2\2\u025e\u0260\7\"\2\2\u025f\u025e\3"+
"\2\2\2\u025f\u0260\3\2\2\2\u0260\u0261\3\2\2\2\u0261\u0266\5N(\2\u0262"+
"\u0263\7{\2\2\u0263\u0265\5N(\2\u0264\u0262\3\2\2\2\u0265\u0268\3\2\2"+
"\2\u0266\u0264\3\2\2\2\u0266\u0267\3\2\2\2\u0267K\3\2\2\2\u0268\u0266"+
"\3\2\2\2\u0269\u026b\7]\2\2\u026a\u026c\7\"\2\2\u026b\u026a\3\2\2\2\u026b"+
"\u026c\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u0272\5P)\2\u026e\u026f\7{\2"+
"\2\u026f\u0271\5P)\2\u0270\u026e\3\2\2\2\u0271\u0274\3\2\2\2\u0272\u0270"+
"\3\2\2\2\u0272\u0273\3\2\2\2\u0273M\3\2\2\2\u0274\u0272\3\2\2\2\u0275"+
"\u0277\5R*\2\u0276\u0278\5T+\2\u0277\u0276\3\2\2\2\u0277\u0278\3\2\2\2"+
"\u0278O\3\2\2\2\u0279\u027a\5\u0090I\2\u027aQ\3\2\2\2\u027b\u0280\5X-"+
"\2\u027c\u0280\5\\/\2\u027d\u0280\5V,\2\u027e\u0280\5\u0090I\2\u027f\u027b"+
"\3\2\2\2\u027f\u027c\3\2\2\2\u027f\u027d\3\2\2\2\u027f\u027e\3\2\2\2\u0280"+
"S\3\2\2\2\u0281\u0282\7\20\2\2\u0282\u0285\5\u00aeX\2\u0283\u0285\7\u008a"+
"\2\2\u0284\u0281\3\2\2\2\u0284\u0283\3\2\2\2\u0285U\3\2\2\2\u0286\u0287"+
"\7&\2\2\u0287\u0288\7}\2\2\u0288\u0289\5^\60\2\u0289\u028a\7~\2\2\u028a"+
"W\3\2\2\2\u028b\u028c\7E\2\2\u028c\u028d\5f\64\2\u028d\u028e\7}\2\2\u028e"+
"\u0293\5Z.\2\u028f\u0290\7{\2\2\u0290\u0292\5Z.\2\u0291\u028f\3\2\2\2"+
"\u0292\u0295\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294\u0296"+
"\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u0297\7~\2\2\u0297Y\3\2\2\2\u0298\u0299"+
"\5\u0090I\2\u0299[\3\2\2\2\u029a\u029b\7J\2\2\u029b\u029c\7}\2\2\u029c"+
"\u029d\5\u00aeX\2\u029d\u029e\7~\2\2\u029e]\3\2\2\2\u029f\u02a2\5d\63"+
"\2\u02a0\u02a1\7|\2\2\u02a1\u02a3\5h\65\2\u02a2\u02a0\3\2\2\2\u02a2\u02a3"+
"\3\2\2\2\u02a3\u02a6\3\2\2\2\u02a4\u02a6\5h\65\2\u02a5\u029f\3\2\2\2\u02a5"+
"\u02a4\3\2\2\2\u02a6_\3\2\2\2\u02a7\u02a8\5\u00aeX\2\u02a8\u02b1\7}\2"+
"\2\u02a9\u02ae\5\u0090I\2\u02aa\u02ab\7{\2\2\u02ab\u02ad\5\u0090I\2\u02ac"+
"\u02aa\3\2\2\2\u02ad\u02b0\3\2\2\2\u02ae\u02ac\3\2\2\2\u02ae\u02af\3\2"+
"\2\2\u02af\u02b2\3\2\2\2\u02b0\u02ae\3\2\2\2\u02b1\u02a9\3\2\2\2\u02b1"+
"\u02b2\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b4\7~\2\2\u02b4a\3\2\2\2\u02b5"+
"\u02b6\7R\2\2\u02b6\u02b9\7}\2\2\u02b7\u02ba\5f\64\2\u02b8\u02ba\5`\61"+
"\2\u02b9\u02b7\3\2\2\2\u02b9\u02b8\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bc"+
"\7~\2\2\u02bcc\3\2\2\2\u02bd\u02be\7d\2\2\u02be\u02bf\7}\2\2\u02bf\u02c0"+
"\5^\60\2\u02c0\u02c1\7\20\2\2\u02c1\u02c2\5\66\34\2\u02c2\u02c3\7~\2\2"+
"\u02c3\u02cf\3\2\2\2\u02c4\u02c5\7k\2\2\u02c5\u02c6\7}\2\2\u02c6\u02c7"+
"\5^\60\2\u02c7\u02c8\7~\2\2\u02c8\u02cf\3\2\2\2\u02c9\u02ca\7>\2\2\u02ca"+
"\u02cb\7}\2\2\u02cb\u02cc\5^\60\2\u02cc\u02cd\7~\2\2\u02cd\u02cf\3\2\2"+
"\2\u02ce\u02bd\3\2\2\2\u02ce\u02c4\3\2\2\2\u02ce\u02c9\3\2\2\2\u02cfe"+
"\3\2\2\2\u02d0\u02d5\5\u00aeX\2\u02d1\u02d2\7|\2\2\u02d2\u02d4\5\u00ae"+
"X\2\u02d3\u02d1\3\2\2\2\u02d4\u02d7\3\2\2\2\u02d5\u02d3\3\2\2\2\u02d5"+
"\u02d6\3\2\2\2\u02d6g\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8\u02e0\5f\64\2"+
"\u02d9\u02da\7\177\2\2\u02da\u02db\5\u0090I\2\u02db\u02de\7\u0080\2\2"+
"\u02dc\u02dd\7|\2\2\u02dd\u02df\5h\65\2\u02de\u02dc\3\2\2\2\u02de\u02df"+
"\3\2\2\2\u02df\u02e1\3\2\2\2\u02e0\u02d9\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1"+
"i\3\2\2\2\u02e2\u02e3\7\62\2\2\u02e3\u02e4\7\25\2\2\u02e4\u02e9\5l\67"+
"\2\u02e5\u02e6\7{\2\2\u02e6\u02e8\5l\67\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\u02eak\3\2\2\2\u02eb"+
"\u02e9\3\2\2\2\u02ec\u02ed\5\u0090I\2\u02edm\3\2\2\2\u02ee\u02ef\7\64"+
"\2\2\u02ef\u02f0\5\u0092J\2\u02f0o\3\2\2\2\u02f1\u02f2\7P\2\2\u02f2\u02f3"+
"\7\25\2\2\u02f3\u02f8\5r:\2\u02f4\u02f5\7{\2\2\u02f5\u02f7\5r:\2\u02f6"+
"\u02f4\3\2\2\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2"+
"\2\2\u02f9q\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb\u02fe\5\u0090I\2\u02fc\u02fd"+
"\7\27\2\2\u02fd\u02ff\7\13\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2"+
"\u02ff\u0305\3\2\2\2\u0300\u0303\t\6\2\2\u0301\u0302\7I\2\2\u0302\u0304"+
"\t\7\2\2\u0303\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0306\3\2\2\2\u0305"+
"\u0300\3\2\2\2\u0305\u0306\3\2\2\2\u0306s\3\2\2\2\u0307\u0308\7o\2\2\u0308"+
"\u0309\5\u00aeX\2\u0309\u030a\7\20\2\2\u030a\u030b\7}\2\2\u030b\u030c"+
"\5v<\2\u030c\u0316\7~\2\2\u030d\u030e\7{\2\2\u030e\u030f\5\u00aeX\2\u030f"+
"\u0310\7\20\2\2\u0310\u0311\7}\2\2\u0311\u0312\5v<\2\u0312\u0313\7~\2"+
"\2\u0313\u0315\3\2\2\2\u0314\u030d\3\2\2\2\u0315\u0318\3\2\2\2\u0316\u0314"+
"\3\2\2\2\u0316\u0317\3\2\2\2\u0317u\3\2\2\2\u0318\u0316\3\2\2\2\u0319"+
"\u031b\5\u00aeX\2\u031a\u0319\3\2\2\2\u031a\u031b\3\2\2\2\u031b\u031d"+
"\3\2\2\2\u031c\u031e\5x=\2\u031d\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e"+
"\u0320\3\2\2\2\u031f\u0321\5p9\2\u0320\u031f\3\2\2\2\u0320\u0321\3\2\2"+
"\2\u0321\u0323\3\2\2\2\u0322\u0324\5z>\2\u0323\u0322\3\2\2\2\u0323\u0324"+
"\3\2\2\2\u0324w\3\2\2\2\u0325\u0326\7U\2\2\u0326\u0327\7\25\2\2\u0327"+
"\u032c\5l\67\2\u0328\u0329\7{\2\2\u0329\u032b\5l\67\2\u032a\u0328\3\2"+
"\2\2\u032b\u032e\3\2\2\2\u032c\u032a\3\2\2\2\u032c\u032d\3\2\2\2\u032d"+
"y\3\2\2\2\u032e\u032c\3\2\2\2\u032f\u0330\t\b\2\2\u0330\u0332\5|?\2\u0331"+
"\u0333\5\u0080A\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u033d"+
"\3\2\2\2\u0334\u0335\t\b\2\2\u0335\u0336\7\23\2\2\u0336\u0337\5|?\2\u0337"+
"\u0338\7\16\2\2\u0338\u033a\5~@\2\u0339\u033b\5\u0080A\2\u033a\u0339\3"+
"\2\2\2\u033a\u033b\3\2\2\2\u033b\u033d\3\2\2\2\u033c\u032f\3\2\2\2\u033c"+
"\u0334\3\2\2\2\u033d{\3\2\2\2\u033e\u033f\7h\2\2\u033f\u0349\7V\2\2\u0340"+
"\u0341\5\u0086D\2\u0341\u0342\7V\2\2\u0342\u0349\3\2\2\2\u0343\u0344\7"+
"\33\2\2\u0344\u0349\7[\2\2\u0345\u0346\5\u0086D\2\u0346\u0347\7/\2\2\u0347"+
"\u0349\3\2\2\2\u0348\u033e\3\2\2\2\u0348\u0340\3\2\2\2\u0348\u0343\3\2"+
"\2\2\u0348\u0345\3\2\2\2\u0349}\3\2\2\2\u034a\u034b\7h\2\2\u034b\u0357"+
"\7V\2\2\u034c\u034d\5\u0086D\2\u034d\u034e\7V\2\2\u034e\u0357\3\2\2\2"+
"\u034f\u0350\7\33\2\2\u0350\u0357\7[\2\2\u0351\u0352\5\u0086D\2\u0352"+
"\u0353\7/\2\2\u0353\u0357\3\2\2\2\u0354\u0355\7h\2\2\u0355\u0357\7/\2"+
"\2\u0356\u034a\3\2\2\2\u0356\u034c\3\2\2\2\u0356\u034f\3\2\2\2\u0356\u0351"+
"\3\2\2\2\u0356\u0354\3\2\2\2\u0357\177\3\2\2\2\u0358\u0359\7)\2\2\u0359"+
"\u035a\7\33\2\2\u035a\u0363\7[\2\2\u035b\u035c\7)\2\2\u035c\u0363\7\62"+
"\2\2\u035d\u035e\7)\2\2\u035e\u0363\7a\2\2\u035f\u0360\7)\2\2\u0360\u0361"+
"\7F\2\2\u0361\u0363\7Q\2\2\u0362\u0358\3\2\2\2\u0362\u035b\3\2\2\2\u0362"+
"\u035d\3\2\2\2\u0362\u035f\3\2\2\2\u0363\u0081\3\2\2\2\u0364\u0365\7C"+
"\2\2\u0365\u0366\5\u0086D\2\u0366\u0083\3\2\2\2\u0367\u0368\7L\2\2\u0368"+
"\u036f\5\u0086D\2\u0369\u036a\7=\2\2\u036a\u036b\7b\2\2\u036b\u036c\7"+
"T\2\2\u036c\u036d\7\30\2\2\u036d\u036f\5\u00a6T\2\u036e\u0367\3\2\2\2"+
"\u036e\u0369\3\2\2\2\u036f\u0085\3\2\2\2\u0370\u0373\5\u00a6T\2\u0371"+
"\u0373\7\4\2\2\u0372\u0370\3\2\2\2\u0372\u0371\3\2\2\2\u0373\u0087\3\2"+
"\2\2\u0374\u0375\t\t\2\2\u0375\u0383\5\u008aF\2\u0376\u0377\t\t\2\2\u0377"+
"\u0378\7}\2\2\u0378\u037d\5\u008aF\2\u0379\u037a\7{\2\2\u037a\u037c\5"+
"\u008aF\2\u037b\u0379\3\2\2\2\u037c\u037f\3\2\2\2\u037d\u037b\3\2\2\2"+
"\u037d\u037e\3\2\2\2\u037e\u0380\3\2\2\2\u037f\u037d\3\2\2\2\u0380\u0381"+
"\7~\2\2\u0381\u0383\3\2\2\2\u0382\u0374\3\2\2\2\u0382\u0376\3\2\2\2\u0383"+
"\u0089\3\2\2\2\u0384\u0387\5\u00a6T\2\u0385\u0387\5\u009cO\2\u0386\u0384"+
"\3\2\2\2\u0386\u0385\3\2\2\2\u0387\u008b\3\2\2\2\u0388\u038d\5\u00aeX"+
"\2\u0389\u038a\t\n\2\2\u038a\u038c\5\u00aeX\2\u038b\u0389\3\2\2\2\u038c"+
"\u038f\3\2\2\2\u038d\u038b\3\2\2\2\u038d\u038e\3\2\2\2\u038e\u008d\3\2"+
"\2\2\u038f\u038d\3\2\2\2\u0390\u0391\7n\2\2\u0391\u0392\5\u0092J\2\u0392"+
"\u008f\3\2\2\2\u0393\u0394\bI\1\2\u0394\u0395\7}\2\2\u0395\u0396\5\u0090"+
"I\2\u0396\u0397\7~\2\2\u0397\u03bc\3\2\2\2\u0398\u0399\7\u0082\2\2\u0399"+
"\u03bc\5\u0090I\f\u039a\u039b\7\u0081\2\2\u039b\u03bc\5\u0090I\13\u039c"+
"\u039d\7\26\2\2\u039d\u039f\5\u0090I\2\u039e\u03a0\5\u0098M\2\u039f\u039e"+
"\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2"+
"\u03a5\3\2\2\2\u03a3\u03a4\7#\2\2\u03a4\u03a6\5\u0090I\2\u03a5\u03a3\3"+
"\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a8\7%\2\2\u03a8"+
"\u03bc\3\2\2\2\u03a9\u03ab\7\26\2\2\u03aa\u03ac\5\u009aN\2\u03ab\u03aa"+
"\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03ab\3\2\2\2\u03ad\u03ae\3\2\2\2\u03ae"+
"\u03b1\3\2\2\2\u03af\u03b0\7#\2\2\u03b0\u03b2\5\u0090I\2\u03b1\u03af\3"+
"\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3\u03b4\7%\2\2\u03b4"+
"\u03bc\3\2\2\2\u03b5\u03bc\5\u009cO\2\u03b6\u03bc\5\u00a6T\2\u03b7\u03bc"+
"\5\u0096L\2\u03b8\u03bc\t\13\2\2\u03b9\u03bc\5^\60\2\u03ba\u03bc\5\u00a8"+
"U\2\u03bb\u0393\3\2\2\2\u03bb\u0398\3\2\2\2\u03bb\u039a\3\2\2\2\u03bb"+
"\u039c\3\2\2\2\u03bb\u03a9\3\2\2\2\u03bb\u03b5\3\2\2\2\u03bb\u03b6\3\2"+
"\2\2\u03bb\u03b7\3\2\2\2\u03bb\u03b8\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bb"+
"\u03ba\3\2\2\2\u03bc\u03d1\3\2\2\2\u03bd\u03be\f\22\2\2\u03be\u03bf\7"+
"\u0083\2\2\u03bf\u03d0\5\u0090I\23\u03c0\u03c1\f\21\2\2\u03c1\u03c2\7"+
"\u0084\2\2\u03c2\u03d0\5\u0090I\22\u03c3\u03c4\f\20\2\2\u03c4\u03c5\7"+
"\u0085\2\2\u03c5\u03d0\5\u0090I\21\u03c6\u03c7\f\17\2\2\u03c7\u03c8\7"+
"\u0087\2\2\u03c8\u03d0\5\u0090I\20\u03c9\u03ca\f\16\2\2\u03ca\u03cb\7"+
"\u0081\2\2\u03cb\u03d0\5\u0090I\17\u03cc\u03cd\f\r\2\2\u03cd\u03ce\7\u0082"+
"\2\2\u03ce\u03d0\5\u0090I\16\u03cf\u03bd\3\2\2\2\u03cf\u03c0\3\2\2\2\u03cf"+
"\u03c3\3\2\2\2\u03cf\u03c6\3\2\2\2\u03cf\u03c9\3\2\2\2\u03cf\u03cc\3\2"+
"\2\2\u03d0\u03d3\3\2\2\2\u03d1\u03cf\3\2\2\2\u03d1\u03d2\3\2\2\2\u03d2"+
"\u0091\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d4\u03d5\bJ\1\2\u03d5\u03d6\7}\2"+
"\2\u03d6\u03d7\5\u0092J\2\u03d7\u03d8\7~\2\2\u03d8\u0477\3\2\2\2\u03d9"+
"\u03da\7G\2\2\u03da\u0477\5\u0092J\30\u03db\u03dd\7G\2\2\u03dc\u03db\3"+
"\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03de\3\2\2\2\u03de\u03e4\7*\2\2\u03df"+
"\u03e5\5\u00aeX\2\u03e0\u03e1\7}\2\2\u03e1\u03e2\5\u00aeX\2\u03e2\u03e3"+
"\7~\2\2\u03e3\u03e5\3\2\2\2\u03e4\u03df\3\2\2\2\u03e4\u03e0\3\2\2\2\u03e5"+
"\u0477\3\2\2\2\u03e6\u03e7\5\u0090I\2\u03e7\u03e9\7;\2\2\u03e8\u03ea\7"+
"G\2\2\u03e9\u03e8\3\2\2\2\u03e9\u03ea\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb"+
"\u03ec\7H\2\2\u03ec\u0477\3\2\2\2\u03ed\u03ee\5\u0090I\2\u03ee\u03f0\7"+
";\2\2\u03ef\u03f1\7G\2\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1"+
"\u03f2\3\2\2\2\u03f2\u03f3\7$\2\2\u03f3\u0477\3\2\2\2\u03f4\u03f5\5\u0090"+
"I\2\u03f5\u03f7\7u\2\2\u03f6\u03f8\t\f\2\2\u03f7\u03f6\3\2\2\2\u03f7\u03f8"+
"\3\2\2\2\u03f8\u03fe\3\2\2\2\u03f9\u03ff\5\u00aeX\2\u03fa\u03fb\7}\2\2"+
"\u03fb\u03fc\5\u00aeX\2\u03fc\u03fd\7~\2\2\u03fd\u03ff\3\2\2\2\u03fe\u03f9"+
"\3\2\2\2\u03fe\u03fa\3\2\2\2\u03ff\u0477\3\2\2\2\u0400\u0401\5\u0090I"+
"\2\u0401\u0403\7v\2\2\u0402\u0404\t\f\2\2\u0403\u0402\3\2\2\2\u0403\u0404"+
"\3\2\2\2\u0404\u040a\3\2\2\2\u0405\u040b\5\u00aeX\2\u0406\u0407\7}\2\2"+
"\u0407\u0408\5\u00aeX\2\u0408\u0409\7~\2\2\u0409\u040b\3\2\2\2\u040a\u0405"+
"\3\2\2\2\u040a\u0406\3\2\2\2\u040b\u0477\3\2\2\2\u040c\u040d\5\u0090I"+
"\2\u040d\u040f\7w\2\2\u040e\u0410\t\f\2\2\u040f\u040e\3\2\2\2\u040f\u0410"+
"\3\2\2\2\u0410\u0416\3\2\2\2\u0411\u0417\5\u00aeX\2\u0412\u0413\7}\2\2"+
"\u0413\u0414\5\u00aeX\2\u0414\u0415\7~\2\2\u0415\u0417\3\2\2\2\u0416\u0411"+
"\3\2\2\2\u0416\u0412\3\2\2\2\u0417\u0477\3\2\2\2\u0418\u0419\5\u0090I"+
"\2\u0419\u041b\7x\2\2\u041a\u041c\t\f\2\2\u041b\u041a\3\2\2\2\u041b\u041c"+
"\3\2\2\2\u041c\u0422\3\2\2\2\u041d\u0423\5\u00aeX\2\u041e\u041f\7}\2\2"+
"\u041f\u0420\5\u00aeX\2\u0420\u0421\7~\2\2\u0421\u0423\3\2\2\2\u0422\u041d"+
"\3\2\2\2\u0422\u041e\3\2\2\2\u0423\u0477\3\2\2\2\u0424\u0425\5\u0090I"+
"\2\u0425\u0427\7y\2\2\u0426\u0428\t\f\2\2\u0427\u0426\3\2\2\2\u0427\u0428"+
"\3\2\2\2\u0428\u042e\3\2\2\2\u0429\u042f\5\u00aeX\2\u042a\u042b\7}\2\2"+
"\u042b\u042c\5\u00aeX\2\u042c\u042d\7~\2\2\u042d\u042f\3\2\2\2\u042e\u0429"+
"\3\2\2\2\u042e\u042a\3\2\2\2\u042f\u0477\3\2\2\2\u0430\u0431\5\u0090I"+
"\2\u0431\u0433\7z\2\2\u0432\u0434\t\f\2\2\u0433\u0432\3\2\2\2\u0433\u0434"+
"\3\2\2\2\u0434\u043a\3\2\2\2\u0435\u043b\5\u00aeX\2\u0436\u0437\7}\2\2"+
"\u0437\u0438\5\u00aeX\2\u0438\u0439\7~\2\2\u0439\u043b\3\2\2\2\u043a\u0435"+
"\3\2\2\2\u043a\u0436\3\2\2\2\u043b\u0477\3\2\2\2\u043c\u043d\5\u0090I"+
"\2\u043d\u043e\7u\2\2\u043e\u043f\5\u0090I\2\u043f\u0477\3\2\2\2\u0440"+
"\u0441\5\u0090I\2\u0441\u0442\7v\2\2\u0442\u0443\5\u0090I\2\u0443\u0477"+
"\3\2\2\2\u0444\u0445\5\u0090I\2\u0445\u0446\7w\2\2\u0446\u0447\5\u0090"+
"I\2\u0447\u0477\3\2\2\2\u0448\u0449\5\u0090I\2\u0449\u044a\7x\2\2\u044a"+
"\u044b\5\u0090I\2\u044b\u0477\3\2\2\2\u044c\u044d\5\u0090I\2\u044d\u044e"+
"\7y\2\2\u044e\u044f\5\u0090I\2\u044f\u0477\3\2\2\2\u0450\u0451\5\u0090"+
"I\2\u0451\u0452\7z\2\2\u0452\u0453\5\u0090I\2\u0453\u0477\3\2\2\2\u0454"+
"\u0456\5\u0090I\2\u0455\u0457\7G\2\2\u0456\u0455\3\2\2\2\u0456\u0457\3"+
"\2\2\2\u0457\u0458\3\2\2\2\u0458\u0459\7\65\2\2\u0459\u045a\5\u0094K\2"+
"\u045a\u0477\3\2\2\2\u045b\u045d\5\u0090I\2\u045c\u045e\7G\2\2\u045d\u045c"+
"\3\2\2\2\u045d\u045e\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0460\7\23\2\2"+
"\u0460\u0461\5\u0090I\2\u0461\u0462\7\16\2\2\u0462\u0463\5\u0090I\2\u0463"+
"\u0477\3\2\2\2\u0464\u0466\5\u0090I\2\u0465\u0467\7G\2\2\u0466\u0465\3"+
"\2\2\2\u0466\u0467\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0469\7B\2\2\u0469"+
"\u046c\5\u0090I\2\u046a\u046b\7\'\2\2\u046b\u046d\5\u0090I\2\u046c\u046a"+
"\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u0477\3\2\2\2\u046e\u0470\5\u0090I"+
"\2\u046f\u0471\7G\2\2\u0470\u046f\3\2\2\2\u0470\u0471\3\2\2\2\u0471\u0472"+
"\3\2\2\2\u0472\u0473\7D\2\2\u0473\u0474\7K\2\2\u0474\u0475\5^\60\2\u0475"+
"\u0477\3\2\2\2\u0476\u03d4\3\2\2\2\u0476\u03d9\3\2\2\2\u0476\u03dc\3\2"+
"\2\2\u0476\u03e6\3\2\2\2\u0476\u03ed\3\2\2\2\u0476\u03f4\3\2\2\2\u0476"+
"\u0400\3\2\2\2\u0476\u040c\3\2\2\2\u0476\u0418\3\2\2\2\u0476\u0424\3\2"+
"\2\2\u0476\u0430\3\2\2\2\u0476\u043c\3\2\2\2\u0476\u0440\3\2\2\2\u0476"+
"\u0444\3\2\2\2\u0476\u0448\3\2\2\2\u0476\u044c\3\2\2\2\u0476\u0450\3\2"+
"\2\2\u0476\u0454\3\2\2\2\u0476\u045b\3\2\2\2\u0476\u0464\3\2\2\2\u0476"+
"\u046e\3\2\2\2\u0477\u0480\3\2\2\2\u0478\u0479\f\27\2\2\u0479\u047a\7"+
"\16\2\2\u047a\u047f\5\u0092J\30\u047b\u047c\f\26\2\2\u047c\u047d\7O\2"+
"\2\u047d\u047f\5\u0092J\27\u047e\u0478\3\2\2\2\u047e\u047b\3\2\2\2\u047f"+
"\u0482\3\2\2\2\u0480\u047e\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u0093\3\2"+
"\2\2\u0482\u0480\3\2\2\2\u0483\u0484\7}\2\2\u0484\u0489\5\u0090I\2\u0485"+
"\u0486\7{\2\2\u0486\u0488\5\u0090I\2\u0487\u0485\3\2\2\2\u0488\u048b\3"+
"\2\2\2\u0489\u0487\3\2\2\2\u0489\u048a\3\2\2\2\u048a\u048c\3\2\2\2\u048b"+
"\u0489\3\2\2\2\u048c\u048d\7~\2\2\u048d\u0490\3\2\2\2\u048e\u0490\5\u0090"+
"I\2\u048f\u0483\3\2\2\2\u048f\u048e\3\2\2\2\u0490\u0095\3\2\2\2\u0491"+
"\u0492\7g\2\2\u0492\u0495\7}\2\2\u0493\u0496\5^\60\2\u0494\u0496\5\u00a6"+
"T\2\u0495\u0493\3\2\2\2\u0495\u0494\3\2\2\2\u0496\u0497\3\2\2\2\u0497"+
"\u0498\7~\2\2\u0498\u0097\3\2\2\2\u0499\u049a\7m\2\2\u049a\u049b\5\u0090"+
"I\2\u049b\u049c\7`\2\2\u049c\u049d\5\u0090I\2\u049d\u0099\3\2\2\2\u049e"+
"\u049f\7m\2\2\u049f\u04a0\5\u0092J\2\u04a0\u04a1\7`\2\2\u04a1\u04a2\5"+
"\u0090I\2\u04a2\u009b\3\2\2\2\u04a3\u04b2\7\13\2\2\u04a4\u04b2\7\n\2\2"+
"\u04a5\u04b2\7\4\2\2\u04a6\u04b2\7\6\2\2\u04a7\u04b2\7\5\2\2\u04a8\u04b2"+
"\7\7\2\2\u04a9\u04b2\7\b\2\2\u04aa\u04b2\7\t\2\2\u04ab\u04b2\7H\2\2\u04ac"+
"\u04b2\7f\2\2\u04ad\u04b2\7+\2\2\u04ae\u04b2\5\u009eP\2\u04af\u04b2\5"+
"\u00a0Q\2\u04b0\u04b2\5\u00a2R\2\u04b1\u04a3\3\2\2\2\u04b1\u04a4\3\2\2"+
"\2\u04b1\u04a5\3\2\2\2\u04b1\u04a6\3\2\2\2\u04b1\u04a7\3\2\2\2\u04b1\u04a8"+
"\3\2\2\2\u04b1\u04a9\3\2\2\2\u04b1\u04aa\3\2\2\2\u04b1\u04ab\3\2\2\2\u04b1"+
"\u04ac\3\2\2\2\u04b1\u04ad\3\2\2\2\u04b1\u04ae\3\2\2\2\u04b1\u04af\3\2"+
"\2\2\u04b1\u04b0\3\2\2\2\u04b2\u009d\3\2\2\2\u04b3\u04b4\7q\2\2\u04b4"+
"\u04b5\5\u00a4S\2\u04b5\u04b6\7t\2\2\u04b6\u009f\3\2\2\2\u04b7\u04b8\7"+
"r\2\2\u04b8\u04b9\5\u00a4S\2\u04b9\u04ba\7t\2\2\u04ba\u00a1\3\2\2\2\u04bb"+
"\u04bc\7s\2\2\u04bc\u04bd\5\u00a4S\2\u04bd\u04be\7t\2\2\u04be\u00a3\3"+
"\2\2\2\u04bf\u04c0\t\r\2\2\u04c0\u00a5\3\2\2\2\u04c1\u04c2\7\u0086\2\2"+
"\u04c2\u04c6\5\u00aeX\2\u04c3\u04c4\7\u0088\2\2\u04c4\u04c6\7\4\2\2\u04c5"+
"\u04c1\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c6\u00a7\3\2\2\2\u04c7\u04c8\7e"+
"\2\2\u04c8\u04ca\7}\2\2\u04c9\u04cb\5\u00aaV\2\u04ca\u04c9\3\2\2\2\u04ca"+
"\u04cb\3\2\2\2\u04cb\u04cd\3\2\2\2\u04cc\u04ce\5\u00acW\2\u04cd\u04cc"+
"\3\2\2\2\u04cd\u04ce\3\2\2\2\u04ce\u04d0\3\2\2\2\u04cf\u04d1\7\60\2\2"+
"\u04d0\u04cf\3\2\2\2\u04d0\u04d1\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3"+
"\5\u0090I\2\u04d3\u04d4\7~\2\2\u04d4\u0517\3\2\2\2\u04d5\u04d8\t\13\2"+
"\2\u04d6\u04d7\7}\2\2\u04d7\u04d9\7~\2\2\u04d8\u04d6\3\2\2\2\u04d8\u04d9"+
"\3\2\2\2\u04d9\u0517\3\2\2\2\u04da\u04db\7\31\2\2\u04db\u04e1\7}\2\2\u04dc"+
"\u04de\7\"\2\2\u04dd\u04dc\3\2\2\2\u04dd\u04de\3\2\2\2\u04de\u04df\3\2"+
"\2\2\u04df\u04e2\5\u0090I\2\u04e0\u04e2\7\u0083\2\2\u04e1\u04dd\3\2\2"+
"\2\u04e1\u04e0\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3\u04f3\7~\2\2\u04e4\u04e5"+
"\7-\2\2\u04e5\u04e6\7}\2\2\u04e6\u04e7\5\u008eH\2\u04e7\u04e8\7~\2\2\u04e8"+
"\u04ea\3\2\2\2\u04e9\u04e4\3\2\2\2\u04e9\u04ea\3\2\2\2\u04ea\u04eb\3\2"+
"\2\2\u04eb\u04f1\7S\2\2\u04ec\u04f2\5\u00aeX\2\u04ed\u04ee\7}\2\2\u04ee"+
"\u04ef\5v<\2\u04ef\u04f0\7~\2\2\u04f0\u04f2\3\2\2\2\u04f1\u04ec\3\2\2"+
"\2\u04f1\u04ed\3\2\2\2\u04f2\u04f4\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04f4"+
"\3\2\2\2\u04f4\u0517\3\2\2\2\u04f5\u04f6\5\u00aeX\2\u04f6\u04f8\7}\2\2"+
"\u04f7\u04f9\7\"\2\2\u04f8\u04f7\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u0502"+
"\3\2\2\2\u04fa\u04ff\5\u0090I\2\u04fb\u04fc\7{\2\2\u04fc\u04fe\5\u0090"+
"I\2\u04fd\u04fb\3\2\2\2\u04fe\u0501\3\2\2\2\u04ff\u04fd\3\2\2\2\u04ff"+
"\u0500\3\2\2\2\u0500\u0503\3\2\2\2\u0501\u04ff\3\2\2\2\u0502\u04fa\3\2"+
"\2\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u0514\7~\2\2\u0505"+
"\u0506\7-\2\2\u0506\u0507\7}\2\2\u0507\u0508\5\u008eH\2\u0508\u0509\7"+
"~\2\2\u0509\u050b\3\2\2\2\u050a\u0505\3\2\2\2\u050a\u050b\3\2\2\2\u050b"+
"\u050c\3\2\2\2\u050c\u0512\7S\2\2\u050d\u0513\5\u00aeX\2\u050e\u050f\7"+
"}\2\2\u050f\u0510\5v<\2\u0510\u0511\7~\2\2\u0511\u0513\3\2\2\2\u0512\u050d"+
"\3\2\2\2\u0512\u050e\3\2\2\2\u0513\u0515\3\2\2\2\u0514\u050a\3\2\2\2\u0514"+
"\u0515\3\2\2\2\u0515\u0517\3\2\2\2\u0516\u04c7\3\2\2\2\u0516\u04d5\3\2"+
"\2\2\u0516\u04da\3\2\2\2\u0516\u04f5\3\2\2\2\u0517\u00a9\3\2\2\2\u0518"+
"\u0519\t\16\2\2\u0519\u00ab\3\2\2\2\u051a\u051b\t\r\2\2\u051b\u00ad\3"+
"\2\2\2\u051c\u051d\t\17\2\2\u051d\u00af\3\2\2\2\u00a6\u00b2\u00b5\u00c6"+
"\u00d1\u00d7\u00e3\u00f0\u00f8\u00fc\u0104\u0108\u010d\u0110\u0113\u0116"+
"\u011a\u011d\u0120\u0125\u0128\u012c\u0133\u0136\u0139\u013c\u0140\u0147"+
"\u014a\u0157\u015b\u015e\u0167\u016c\u0179\u0181\u018c\u0190\u0194\u0197"+
"\u019a\u019d\u01a0\u01a4\u01a7\u01aa\u01ad\u01b0\u01b8\u01c1\u01c8\u01ca"+
"\u01d1\u01d3\u01d8\u01e9\u01f5\u0202\u020d\u020f\u0217\u0221\u022d\u0232"+
"\u0236\u023c\u0240\u024a\u024d\u0250\u0253\u0256\u0258\u025f\u0266\u026b"+
"\u0272\u0277\u027f\u0284\u0293\u02a2\u02a5\u02ae\u02b1\u02b9\u02ce\u02d5"+
"\u02de\u02e0\u02e9\u02f8\u02fe\u0303\u0305\u0316\u031a\u031d\u0320\u0323"+
"\u032c\u0332\u033a\u033c\u0348\u0356\u0362\u036e\u0372\u037d\u0382\u0386"+
"\u038d\u03a1\u03a5\u03ad\u03b1\u03bb\u03cf\u03d1\u03dc\u03e4\u03e9\u03f0"+
"\u03f7\u03fe\u0403\u040a\u040f\u0416\u041b\u0422\u0427\u042e\u0433\u043a"+
"\u0456\u045d\u0466\u046c\u0470\u0476\u047e\u0480\u0489\u048f\u0495\u04b1"+
"\u04c5\u04ca\u04cd\u04d0\u04d8\u04dd\u04e1\u04e9\u04f1\u04f3\u04f8\u04ff"+
"\u0502\u050a\u0512\u0514\u0516";
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);
}
}
}
