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_predicateOrExpression = 73,
RULE_inList = 74, RULE_entityType = 75, RULE_simpleCaseWhen = 76, RULE_searchedCaseWhen = 77,
RULE_literal = 78, RULE_timestampLiteral = 79, RULE_dateLiteral = 80,
RULE_timeLiteral = 81, RULE_dateTimeLiteralText = 82, RULE_parameter = 83,
RULE_function = 84, RULE_trimSpecification = 85, RULE_trimCharacter = 86,
RULE_identifier = 87;
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", "predicateOrExpression", "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(181);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(176);
match(WITH);
setState(178);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(177);
match(RECURSIVE);
}
break;
}
setState(180);
withQuery();
}
}
setState(183);
simpleStatement();
setState(184);
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(186);
selectExpression();
setState(187);
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(198);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(189);
path();
setState(190);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(192);
outerPath();
setState(193);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(195);
macroPath();
setState(196);
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(200);
expression(0);
setState(201);
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(209);
_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(203);
parameterOrLiteral();
setState(204);
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(206);
entityTypeOrEnumLiteral();
setState(207);
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(215);
_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(211);
parameterOrLiteral();
setState(212);
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(214);
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(217);
predicate(0);
setState(218);
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(220);
entityName();
setState(221);
match(LP);
setState(222);
identifier();
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(223);
match(COMMA);
setState(224);
identifier();
}
}
setState(229);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(230);
match(RP);
setState(231);
match(AS);
setState(232);
match(LP);
setState(233);
simpleStatement();
setState(234);
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(240);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
case LP:
enterOuterAlt(_localctx, 1);
{
setState(236);
selectStatement();
}
break;
case UPDATE:
enterOuterAlt(_localctx, 2);
{
setState(237);
updateStatement();
}
break;
case DELETE:
enterOuterAlt(_localctx, 3);
{
setState(238);
deleteStatement();
}
break;
case INSERT:
enterOuterAlt(_localctx, 4);
{
setState(239);
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(252);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(242);
querySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(243);
match(LP);
setState(244);
selectStatement();
setState(245);
match(RP);
setState(246);
_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(248);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(247);
_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(250);
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(264);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(254);
subQuerySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(255);
match(LP);
setState(256);
subQuery();
setState(257);
match(RP);
setState(258);
_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(260);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(259);
_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(262);
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(266);
subQuerySelectClause();
setState(267);
subQueryFromClause();
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(268);
keysetClause();
}
}
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(271);
whereClause();
}
}
setState(275);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(274);
groupByClause();
}
}
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(277);
havingClause();
}
}
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(280);
_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(282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(281);
_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(284);
subQuery();
}
}
setState(288);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(287);
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(290);
orderByClause();
setState(296);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
{
{
setState(291);
limitClause();
setState(293);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==JUMP || _la==OFFSET) {
{
setState(292);
offsetClause();
}
}
}
}
break;
case JUMP:
case OFFSET:
{
setState(295);
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(298);
match(DELETE);
setState(300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(299);
match(FROM);
}
break;
}
setState(302);
entityName();
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(303);
match(LP);
setState(304);
simpleSubpath();
setState(305);
match(RP);
}
}
setState(310);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(309);
identificationVariable();
}
}
setState(313);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(312);
whereClause();
}
}
setState(316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(315);
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(318);
match(UPDATE);
setState(320);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(319);
match(FROM);
}
break;
}
setState(322);
entityName();
setState(327);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(323);
match(LP);
setState(324);
simpleSubpath();
setState(325);
match(RP);
}
}
setState(330);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(329);
identificationVariable();
}
}
setState(332);
match(SET);
setState(333);
dmlAttributeName();
setState(334);
match(EQUAL);
setState(335);
expression(0);
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(336);
match(COMMA);
setState(337);
dmlAttributeName();
setState(338);
match(EQUAL);
setState(339);
expression(0);
}
}
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(346);
whereClause();
}
}
setState(350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(349);
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(352);
match(INSERT);
setState(353);
match(INTO);
setState(354);
entityName();
setState(359);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(355);
match(LP);
setState(356);
simpleSubpath();
setState(357);
match(RP);
}
break;
}
setState(361);
targetFieldsSpecification();
setState(362);
querySpecification();
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(363);
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(377);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(366);
simpleSubpath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(367);
match(KEY);
setState(368);
match(LP);
setState(369);
path();
setState(370);
match(RP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(372);
match(INDEX);
setState(373);
match(LP);
setState(374);
path();
setState(375);
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(379);
match(LP);
setState(380);
dmlAttributeName();
setState(385);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(381);
match(COMMA);
setState(382);
dmlAttributeName();
}
}
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(388);
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(390);
match(RETURNING);
setState(391);
simpleSubpath();
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(392);
match(COMMA);
setState(393);
simpleSubpath();
}
}
setState(398);
_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(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(399);
selectClause();
}
}
setState(402);
fromClause();
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(403);
keysetClause();
}
}
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(406);
whereClause();
}
}
setState(410);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(409);
groupByClause();
}
}
setState(413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(412);
havingClause();
}
}
setState(416);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WINDOW) {
{
setState(415);
windowClause();
}
}
setState(423);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(418);
_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(420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(419);
_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(422);
querySpecification();
}
}
setState(426);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(425);
orderByClause();
}
break;
}
setState(429);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(428);
limitClause();
}
break;
}
setState(432);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(431);
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(434);
match(FROM);
setState(435);
fromItem();
setState(440);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(436);
match(COMMA);
setState(437);
fromItem();
}
}
setState(442);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class 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(443);
match(FROM);
setState(444);
subQueryFromItem();
setState(449);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(445);
match(COMMA);
setState(446);
subQueryFromItem();
}
}
setState(451);
_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(452);
fromItemElement();
setState(458);
_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(456);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(453);
crossJoin();
}
break;
case COMMA:
{
setState(454);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(455);
qualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(460);
_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(461);
fromItemElement();
setState(467);
_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(465);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(462);
crossJoin();
}
break;
case COMMA:
{
setState(463);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(464);
subQueryQualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(469);
_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(527);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
_localctx = new FromEntityContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(470);
entityName();
setState(472);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(471);
identificationVariable();
}
}
}
break;
case 2:
_localctx = new FromValuesContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(474);
entityName();
setState(475);
match(LP);
setState(476);
match(INTEGER_LITERAL);
setState(477);
match(VALUES);
setState(478);
match(RP);
setState(479);
identificationVariable();
}
break;
case 3:
_localctx = new FromValuesListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(481);
entityName();
setState(482);
match(LP);
setState(483);
match(VALUES);
setState(484);
fromItemValuesItem();
setState(489);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(485);
match(COMMA);
setState(486);
fromItemValuesItem();
}
}
setState(491);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(492);
match(RP);
setState(493);
identificationVariable();
}
break;
case 4:
_localctx = new FromSimpleValuesLikeEntityAttributeContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(495);
identifier();
setState(496);
match(LP);
setState(497);
match(INTEGER_LITERAL);
setState(498);
match(VALUES);
setState(501);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(499);
match(LIKE);
setState(500);
entityName();
}
}
setState(503);
match(RP);
setState(504);
identificationVariable();
}
break;
case 5:
_localctx = new FromSimpleValuesListContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(506);
identifier();
setState(507);
match(LP);
setState(508);
match(VALUES);
setState(509);
fromItemValuesItem();
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(510);
match(COMMA);
setState(511);
fromItemValuesItem();
}
}
setState(516);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(517);
match(RP);
setState(518);
identificationVariable();
}
break;
case 6:
_localctx = new FromOldOrNewContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(520);
_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(521);
match(LP);
setState(522);
entityName();
setState(523);
match(RP);
setState(525);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(524);
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(529);
match(LP);
setState(530);
literal();
setState(535);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(531);
match(COMMA);
setState(532);
literal();
}
}
setState(537);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(538);
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(540);
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(545);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(542);
match(AS);
setState(543);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(544);
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(547);
match(CROSS);
setState(548);
match(JOIN);
setState(549);
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(551);
match(COMMA);
setState(552);
match(IN);
setState(553);
match(LP);
setState(554);
path();
setState(555);
match(RP);
setState(557);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(556);
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(559);
joinTypeQualifier();
setState(560);
match(JOIN);
setState(562);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(561);
match(FETCH);
}
break;
}
setState(564);
joinItemElement();
setState(566);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(565);
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(568);
joinTypeQualifier();
setState(569);
match(JOIN);
setState(570);
joinItemElement();
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(571);
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(576);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(574);
fromItemElement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(575);
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(578);
match(TREAT);
setState(579);
match(LP);
setState(580);
path();
setState(581);
match(AS);
setState(582);
entityName();
setState(583);
match(RP);
setState(586);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(584);
match(DOT);
setState(585);
generalSubpath();
}
}
setState(589);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(588);
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(600);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(592);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(591);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(595);
_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(594);
_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(598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(597);
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(602);
match(ON);
setState(603);
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(605);
match(SELECT);
setState(607);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(606);
match(DISTINCT);
}
break;
}
setState(609);
selectItem();
setState(614);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(610);
match(COMMA);
setState(611);
selectItem();
}
}
setState(616);
_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(617);
match(SELECT);
setState(619);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(618);
match(DISTINCT);
}
break;
}
setState(621);
subQuerySelectItem();
setState(626);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(622);
match(COMMA);
setState(623);
subQuerySelectItem();
}
}
setState(628);
_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(629);
selectExpression();
setState(631);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(630);
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(633);
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(639);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(635);
constructorExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(636);
objectSelectExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(637);
mapEntrySelectExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(638);
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(644);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(641);
match(AS);
setState(642);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(643);
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(646);
match(ENTRY);
setState(647);
match(LP);
setState(648);
path();
setState(649);
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(651);
match(NEW);
setState(652);
simpleSubpath();
setState(653);
match(LP);
setState(654);
constructorItem();
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(655);
match(COMMA);
setState(656);
constructorItem();
}
}
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(662);
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(664);
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(666);
match(OBJECT);
setState(667);
match(LP);
setState(668);
identifier();
setState(669);
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(677);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(671);
qualifiedPath();
setState(674);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(672);
match(DOT);
setState(673);
generalSubpath();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(676);
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(679);
identifier();
setState(680);
match(LP);
setState(689);
_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(681);
expression(0);
setState(686);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(682);
match(COMMA);
setState(683);
expression(0);
}
}
setState(688);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(691);
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(693);
match(OUTER);
setState(694);
match(LP);
setState(697);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(695);
simpleSubpath();
}
break;
case 2:
{
setState(696);
macroPath();
}
break;
}
setState(699);
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(718);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TREAT:
_localctx = new TreatPathContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(701);
match(TREAT);
setState(702);
match(LP);
setState(703);
path();
setState(704);
match(AS);
setState(705);
entityName();
setState(706);
match(RP);
}
break;
case VALUE:
_localctx = new ValuePathContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(708);
match(VALUE);
setState(709);
match(LP);
setState(710);
path();
setState(711);
match(RP);
}
break;
case KEY:
_localctx = new MapKeyPathContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(713);
match(KEY);
setState(714);
match(LP);
setState(715);
path();
setState(716);
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(720);
identifier();
setState(725);
_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(721);
match(DOT);
setState(722);
identifier();
}
}
}
setState(727);
_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 PredicateOrExpressionContext predicateOrExpression() {
return getRuleContext(PredicateOrExpressionContext.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(728);
simpleSubpath();
setState(736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(729);
match(LB);
setState(730);
predicateOrExpression();
setState(731);
match(RB);
setState(734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(732);
match(DOT);
setState(733);
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(738);
match(GROUP);
setState(739);
match(BY);
setState(740);
groupingValue();
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(741);
match(COMMA);
setState(742);
groupingValue();
}
}
setState(747);
_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(748);
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(750);
match(HAVING);
setState(751);
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(753);
match(ORDER);
setState(754);
match(BY);
setState(755);
orderByItem();
setState(760);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(756);
match(COMMA);
setState(757);
orderByItem();
}
}
setState(762);
_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(763);
expression(0);
setState(766);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE) {
{
setState(764);
match(COLLATE);
setState(765);
match(STRING_LITERAL);
}
}
setState(773);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(768);
_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(771);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(769);
match(NULLS);
setState(770);
_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(775);
match(WINDOW);
setState(776);
identifier();
setState(777);
match(AS);
setState(778);
match(LP);
setState(779);
windowDefinition();
setState(780);
match(RP);
setState(790);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(781);
match(COMMA);
setState(782);
identifier();
setState(783);
match(AS);
setState(784);
match(LP);
setState(785);
windowDefinition();
setState(786);
match(RP);
}
}
setState(792);
_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(794);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(793);
identifier();
}
break;
}
setState(797);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(796);
partitionByClause();
}
}
setState(800);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(799);
orderByClause();
}
}
setState(803);
_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(802);
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(805);
match(PARTITION);
setState(806);
match(BY);
setState(807);
groupingValue();
setState(812);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(808);
match(COMMA);
setState(809);
groupingValue();
}
}
setState(814);
_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(828);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(815);
((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(816);
frameStart();
setState(818);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(817);
frameExclusionClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(820);
((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(821);
match(BETWEEN);
setState(822);
frameStart();
setState(823);
match(AND);
setState(824);
frameEnd();
setState(826);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(825);
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(840);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(830);
match(UNBOUNDED);
setState(831);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(832);
parameterOrNumberLiteral();
setState(833);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(835);
match(CURRENT);
setState(836);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(837);
parameterOrNumberLiteral();
setState(838);
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(854);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(842);
match(UNBOUNDED);
setState(843);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(844);
parameterOrNumberLiteral();
setState(845);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(847);
match(CURRENT);
setState(848);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(849);
parameterOrNumberLiteral();
setState(850);
match(FOLLOWING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(852);
match(UNBOUNDED);
setState(853);
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(866);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(856);
match(EXCLUDE);
setState(857);
match(CURRENT);
setState(858);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(859);
match(EXCLUDE);
setState(860);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(861);
match(EXCLUDE);
setState(862);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(863);
match(EXCLUDE);
setState(864);
match(NO);
setState(865);
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(868);
match(LIMIT);
setState(869);
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(878);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OFFSET:
enterOuterAlt(_localctx, 1);
{
setState(871);
match(OFFSET);
setState(872);
parameterOrNumberLiteral();
}
break;
case JUMP:
enterOuterAlt(_localctx, 2);
{
setState(873);
match(JUMP);
setState(874);
match(TO);
setState(875);
match(PAGE);
setState(876);
match(CONTAINING);
setState(877);
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(882);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(880);
parameter();
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(881);
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(898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
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);
parameterOrLiteral();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(886);
_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(887);
match(LP);
setState(888);
parameterOrLiteral();
setState(893);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(889);
match(COMMA);
setState(890);
parameterOrLiteral();
}
}
setState(895);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(896);
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(902);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(900);
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(901);
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(904);
identifier();
setState(909);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==DOLLAR) {
{
{
setState(905);
_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(906);
identifier();
}
}
setState(911);
_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(912);
match(WHERE);
setState(913);
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(955);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
_localctx = new GroupedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(916);
match(LP);
setState(917);
expression(0);
setState(918);
match(RP);
}
break;
case 2:
{
_localctx = new UnaryMinusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(920);
match(MINUS);
setState(921);
expression(10);
}
break;
case 3:
{
_localctx = new UnaryPlusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(922);
match(PLUS);
setState(923);
expression(9);
}
break;
case 4:
{
_localctx = new SimpleCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(924);
match(CASE);
setState(925);
((SimpleCaseExpressionContext)_localctx).operand = expression(0);
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(926);
simpleCaseWhen();
}
}
setState(929);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(933);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(931);
match(ELSE);
setState(932);
((SimpleCaseExpressionContext)_localctx).otherwise = expression(0);
}
}
setState(935);
match(END);
}
break;
case 5:
{
_localctx = new GeneralCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(937);
match(CASE);
setState(939);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(938);
searchedCaseWhen();
}
}
setState(941);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(945);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(943);
match(ELSE);
setState(944);
expression(0);
}
}
setState(947);
match(END);
}
break;
case 6:
{
_localctx = new LiteralExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(949);
literal();
}
break;
case 7:
{
_localctx = new ParameterExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(950);
parameter();
}
break;
case 8:
{
_localctx = new EntityTypeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(951);
entityType();
}
break;
case 9:
{
_localctx = new TemporalFunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(952);
((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(953);
path();
}
break;
case 11:
{
_localctx = new FunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(954);
function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(977);
_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(975);
_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(957);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(958);
match(ASTERISK);
setState(959);
((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(960);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(961);
match(SLASH);
setState(962);
((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(963);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(964);
match(PERCENT);
setState(965);
((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(966);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(967);
match(DOUBLE_PIPE);
setState(968);
((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(969);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(970);
match(PLUS);
setState(971);
((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(972);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(973);
match(MINUS);
setState(974);
((SubtractionExpressionContext)_localctx).rhs = expression(12);
}
break;
}
}
}
setState(979);
_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(1142);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
_localctx = new GroupedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(981);
match(LP);
setState(982);
predicate(0);
setState(983);
match(RP);
}
break;
case 2:
{
_localctx = new NegatedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(985);
match(NOT);
setState(986);
predicate(22);
}
break;
case 3:
{
_localctx = new ExistsSimplePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(988);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(987);
match(NOT);
}
}
setState(990);
match(EXISTS);
setState(996);
_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(991);
identifier();
}
break;
case LP:
{
setState(992);
match(LP);
setState(993);
identifier();
setState(994);
match(RP);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
{
_localctx = new IsNullPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(998);
expression(0);
setState(999);
match(IS);
setState(1001);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1000);
match(NOT);
}
}
setState(1003);
match(NULL);
}
break;
case 5:
{
_localctx = new IsEmptyPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1005);
expression(0);
setState(1006);
match(IS);
setState(1008);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1007);
match(NOT);
}
}
setState(1010);
match(EMPTY);
}
break;
case 6:
{
_localctx = new QuantifiedSimpleEqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1012);
expression(0);
setState(1013);
match(EQUAL);
setState(1015);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1014);
((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(1022);
_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(1017);
identifier();
}
break;
case LP:
{
{
setState(1018);
match(LP);
setState(1019);
identifier();
setState(1020);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
{
_localctx = new QuantifiedSimpleInequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1024);
expression(0);
setState(1025);
match(NOT_EQUAL);
setState(1027);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1026);
((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(1034);
_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(1029);
identifier();
}
break;
case LP:
{
{
setState(1030);
match(LP);
setState(1031);
identifier();
setState(1032);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
{
_localctx = new QuantifiedSimpleGreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1036);
expression(0);
setState(1037);
match(GREATER);
setState(1039);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1038);
((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(1046);
_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(1041);
identifier();
}
break;
case LP:
{
{
setState(1042);
match(LP);
setState(1043);
identifier();
setState(1044);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
_localctx = new QuantifiedSimpleGreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1048);
expression(0);
setState(1049);
match(GREATER_EQUAL);
setState(1051);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1050);
((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(1058);
_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(1053);
identifier();
}
break;
case LP:
{
{
setState(1054);
match(LP);
setState(1055);
identifier();
setState(1056);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 10:
{
_localctx = new QuantifiedSimpleLessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1060);
expression(0);
setState(1061);
match(LESS);
setState(1063);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1062);
((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(1070);
_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(1065);
identifier();
}
break;
case LP:
{
{
setState(1066);
match(LP);
setState(1067);
identifier();
setState(1068);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 11:
{
_localctx = new QuantifiedSimpleLessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1072);
expression(0);
setState(1073);
match(LESS_EQUAL);
setState(1075);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1074);
((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(1082);
_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(1077);
identifier();
}
break;
case LP:
{
{
setState(1078);
match(LP);
setState(1079);
identifier();
setState(1080);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 12:
{
_localctx = new EqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1084);
((EqualityPredicateContext)_localctx).lhs = expression(0);
setState(1085);
match(EQUAL);
setState(1086);
((EqualityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 13:
{
_localctx = new InequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1088);
((InequalityPredicateContext)_localctx).lhs = expression(0);
setState(1089);
match(NOT_EQUAL);
setState(1090);
((InequalityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 14:
{
_localctx = new GreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1092);
((GreaterThanPredicateContext)_localctx).lhs = expression(0);
setState(1093);
match(GREATER);
setState(1094);
((GreaterThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 15:
{
_localctx = new GreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1096);
((GreaterThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1097);
match(GREATER_EQUAL);
setState(1098);
((GreaterThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 16:
{
_localctx = new LessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1100);
((LessThanPredicateContext)_localctx).lhs = expression(0);
setState(1101);
match(LESS);
setState(1102);
((LessThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 17:
{
_localctx = new LessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1104);
((LessThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1105);
match(LESS_EQUAL);
setState(1106);
((LessThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 18:
{
_localctx = new InPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1108);
expression(0);
setState(1110);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1109);
match(NOT);
}
}
setState(1112);
match(IN);
setState(1113);
inList();
}
break;
case 19:
{
_localctx = new BetweenPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1115);
((BetweenPredicateContext)_localctx).lhs = expression(0);
setState(1117);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1116);
match(NOT);
}
}
setState(1119);
match(BETWEEN);
setState(1120);
((BetweenPredicateContext)_localctx).start = expression(0);
setState(1121);
match(AND);
setState(1122);
((BetweenPredicateContext)_localctx).end = expression(0);
}
break;
case 20:
{
_localctx = new LikePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1124);
((LikePredicateContext)_localctx).lhs = expression(0);
setState(1126);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1125);
match(NOT);
}
}
setState(1128);
match(LIKE);
setState(1129);
((LikePredicateContext)_localctx).like = expression(0);
setState(1132);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1130);
match(ESCAPE);
setState(1131);
((LikePredicateContext)_localctx).escape = expression(0);
}
break;
}
}
break;
case 21:
{
_localctx = new MemberOfPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1134);
expression(0);
setState(1136);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1135);
match(NOT);
}
}
setState(1138);
match(MEMBER);
setState(1139);
match(OF);
setState(1140);
path();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1152);
_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(1150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
{
_localctx = new AndPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1144);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1145);
match(AND);
setState(1146);
predicate(22);
}
break;
case 2:
{
_localctx = new OrPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1147);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1148);
match(OR);
setState(1149);
predicate(21);
}
break;
}
}
}
setState(1154);
_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 PredicateOrExpressionContext extends ParserRuleContext {
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PredicateOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicateOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPredicateOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPredicateOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPredicateOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final PredicateOrExpressionContext predicateOrExpression() throws RecognitionException {
PredicateOrExpressionContext _localctx = new PredicateOrExpressionContext(_ctx, getState());
enterRule(_localctx, 146, RULE_predicateOrExpression);
try {
setState(1157);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1155);
predicate(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1156);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
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, 148, RULE_inList);
int _la;
try {
setState(1171);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1159);
match(LP);
setState(1160);
expression(0);
setState(1165);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1161);
match(COMMA);
setState(1162);
expression(0);
}
}
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1168);
match(RP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1170);
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, 150, RULE_entityType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1173);
match(TYPE);
setState(1174);
match(LP);
setState(1177);
_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(1175);
path();
}
break;
case COLON:
case QUESTION_MARK:
{
setState(1176);
parameter();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1179);
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, 152, RULE_simpleCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1181);
match(WHEN);
setState(1182);
((SimpleCaseWhenContext)_localctx).when = expression(0);
setState(1183);
match(THEN);
setState(1184);
((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, 154, RULE_searchedCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1186);
match(WHEN);
setState(1187);
predicate(0);
setState(1188);
match(THEN);
setState(1189);
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, 156, RULE_literal);
try {
setState(1205);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1191);
match(STRING_LITERAL);
}
break;
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1192);
match(CHARACTER_LITERAL);
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1193);
match(INTEGER_LITERAL);
}
break;
case LONG_LITERAL:
enterOuterAlt(_localctx, 4);
{
setState(1194);
match(LONG_LITERAL);
}
break;
case BIG_INTEGER_LITERAL:
enterOuterAlt(_localctx, 5);
{
setState(1195);
match(BIG_INTEGER_LITERAL);
}
break;
case FLOAT_LITERAL:
enterOuterAlt(_localctx, 6);
{
setState(1196);
match(FLOAT_LITERAL);
}
break;
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 7);
{
setState(1197);
match(DOUBLE_LITERAL);
}
break;
case BIG_DECIMAL_LITERAL:
enterOuterAlt(_localctx, 8);
{
setState(1198);
match(BIG_DECIMAL_LITERAL);
}
break;
case NULL:
enterOuterAlt(_localctx, 9);
{
setState(1199);
match(NULL);
}
break;
case TRUE:
enterOuterAlt(_localctx, 10);
{
setState(1200);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 11);
{
setState(1201);
match(FALSE);
}
break;
case TIMESTAMP_ESCAPE_START:
enterOuterAlt(_localctx, 12);
{
setState(1202);
timestampLiteral();
}
break;
case DATE_ESCAPE_START:
enterOuterAlt(_localctx, 13);
{
setState(1203);
dateLiteral();
}
break;
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 14);
{
setState(1204);
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, 158, RULE_timestampLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1207);
match(TIMESTAMP_ESCAPE_START);
setState(1208);
dateTimeLiteralText();
setState(1209);
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, 160, RULE_dateLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1211);
match(DATE_ESCAPE_START);
setState(1212);
dateTimeLiteralText();
setState(1213);
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, 162, RULE_timeLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1215);
match(TIME_ESCAPE_START);
setState(1216);
dateTimeLiteralText();
setState(1217);
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, 164, RULE_dateTimeLiteralText);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1219);
_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, 166, RULE_parameter);
try {
setState(1225);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
_localctx = new NamedParameterContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1221);
match(COLON);
setState(1222);
identifier();
}
break;
case QUESTION_MARK:
_localctx = new PositionalParameterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1223);
match(QUESTION_MARK);
setState(1224);
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 TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 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 FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
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 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, 168, RULE_function);
int _la;
try {
setState(1306);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
_localctx = new TrimFunctionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1227);
match(TRIM);
setState(1228);
match(LP);
setState(1230);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(1229);
trimSpecification();
}
break;
}
setState(1233);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1232);
trimCharacter();
}
break;
}
setState(1236);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1235);
match(FROM);
}
break;
}
setState(1238);
expression(0);
setState(1239);
match(RP);
}
break;
case 2:
_localctx = new TemporalFunctionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1241);
((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(1244);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1242);
match(LP);
setState(1243);
match(RP);
}
break;
}
}
break;
case 3:
_localctx = new CountFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1246);
match(COUNT);
setState(1247);
match(LP);
setState(1253);
_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(1249);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
{
setState(1248);
match(DISTINCT);
}
break;
}
setState(1251);
expression(0);
}
}
break;
case ASTERISK:
{
setState(1252);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1255);
match(RP);
setState(1261);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
{
setState(1256);
match(FILTER);
setState(1257);
match(LP);
setState(1258);
whereClause();
setState(1259);
match(RP);
}
break;
}
setState(1271);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
{
setState(1263);
match(OVER);
setState(1269);
_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(1264);
((CountFunctionContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1265);
match(LP);
setState(1266);
windowDefinition();
setState(1267);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
case 4:
_localctx = new GenericFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1273);
((GenericFunctionInvocationContext)_localctx).name = identifier();
setState(1274);
match(LP);
setState(1276);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
{
setState(1275);
match(DISTINCT);
}
break;
}
setState(1286);
_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(1278);
expression(0);
setState(1283);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1279);
match(COMMA);
setState(1280);
expression(0);
}
}
setState(1285);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1288);
match(RP);
setState(1294);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1289);
match(FILTER);
setState(1290);
match(LP);
setState(1291);
whereClause();
setState(1292);
match(RP);
}
break;
}
setState(1304);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
setState(1296);
match(OVER);
setState(1302);
_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(1297);
((GenericFunctionInvocationContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1298);
match(LP);
setState(1299);
windowDefinition();
setState(1300);
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, 170, RULE_trimSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1308);
_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, 172, RULE_trimCharacter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1310);
_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, 174, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1312);
_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\u0525\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\4Y\tY\3\2\3\2\5\2\u00b5\n\2\3\2\5\2\u00b8\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\u00c9"+
"\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00d4\n\6\3\7\3\7\3\7\3\7"+
"\5\7\u00da\n\7\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7\t\u00e4\n\t\f\t\16\t"+
"\u00e7\13\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u00f3\n\n\3\13"+
"\3\13\3\13\3\13\3\13\3\13\5\13\u00fb\n\13\3\13\3\13\5\13\u00ff\n\13\3"+
"\f\3\f\3\f\3\f\3\f\3\f\5\f\u0107\n\f\3\f\3\f\5\f\u010b\n\f\3\r\3\r\3\r"+
"\5\r\u0110\n\r\3\r\5\r\u0113\n\r\3\r\5\r\u0116\n\r\3\r\5\r\u0119\n\r\3"+
"\r\3\r\5\r\u011d\n\r\3\r\5\r\u0120\n\r\3\r\5\r\u0123\n\r\3\16\3\16\3\16"+
"\5\16\u0128\n\16\3\16\5\16\u012b\n\16\3\17\3\17\5\17\u012f\n\17\3\17\3"+
"\17\3\17\3\17\3\17\5\17\u0136\n\17\3\17\5\17\u0139\n\17\3\17\5\17\u013c"+
"\n\17\3\17\5\17\u013f\n\17\3\20\3\20\5\20\u0143\n\20\3\20\3\20\3\20\3"+
"\20\3\20\5\20\u014a\n\20\3\20\5\20\u014d\n\20\3\20\3\20\3\20\3\20\3\20"+
"\3\20\3\20\3\20\3\20\7\20\u0158\n\20\f\20\16\20\u015b\13\20\3\20\5\20"+
"\u015e\n\20\3\20\5\20\u0161\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5"+
"\21\u016a\n\21\3\21\3\21\3\21\5\21\u016f\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\u017c\n\22\3\23\3\23\3\23\3\23\7\23"+
"\u0182\n\23\f\23\16\23\u0185\13\23\3\23\3\23\3\24\3\24\3\24\3\24\7\24"+
"\u018d\n\24\f\24\16\24\u0190\13\24\3\25\5\25\u0193\n\25\3\25\3\25\5\25"+
"\u0197\n\25\3\25\5\25\u019a\n\25\3\25\5\25\u019d\n\25\3\25\5\25\u01a0"+
"\n\25\3\25\5\25\u01a3\n\25\3\25\3\25\5\25\u01a7\n\25\3\25\5\25\u01aa\n"+
"\25\3\25\5\25\u01ad\n\25\3\25\5\25\u01b0\n\25\3\25\5\25\u01b3\n\25\3\26"+
"\3\26\3\26\3\26\7\26\u01b9\n\26\f\26\16\26\u01bc\13\26\3\27\3\27\3\27"+
"\3\27\7\27\u01c2\n\27\f\27\16\27\u01c5\13\27\3\30\3\30\3\30\3\30\7\30"+
"\u01cb\n\30\f\30\16\30\u01ce\13\30\3\31\3\31\3\31\3\31\7\31\u01d4\n\31"+
"\f\31\16\31\u01d7\13\31\3\32\3\32\5\32\u01db\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\u01ea\n\32\f\32\16"+
"\32\u01ed\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u01f8"+
"\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u0203\n\32\f\32"+
"\16\32\u0206\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u0210"+
"\n\32\5\32\u0212\n\32\3\33\3\33\3\33\3\33\7\33\u0218\n\33\f\33\16\33\u021b"+
"\13\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\5\35\u0224\n\35\3\36\3\36\3"+
"\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0230\n\37\3 \3 \3 \5 \u0235"+
"\n \3 \3 \5 \u0239\n \3!\3!\3!\3!\5!\u023f\n!\3\"\3\"\5\"\u0243\n\"\3"+
"#\3#\3#\3#\3#\3#\3#\3#\5#\u024d\n#\3#\5#\u0250\n#\3$\5$\u0253\n$\3$\5"+
"$\u0256\n$\3$\5$\u0259\n$\5$\u025b\n$\3%\3%\3%\3&\3&\5&\u0262\n&\3&\3"+
"&\3&\7&\u0267\n&\f&\16&\u026a\13&\3\'\3\'\5\'\u026e\n\'\3\'\3\'\3\'\7"+
"\'\u0273\n\'\f\'\16\'\u0276\13\'\3(\3(\5(\u027a\n(\3)\3)\3*\3*\3*\3*\5"+
"*\u0282\n*\3+\3+\3+\5+\u0287\n+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\7-\u0294"+
"\n-\f-\16-\u0297\13-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u02a5"+
"\n\60\3\60\5\60\u02a8\n\60\3\61\3\61\3\61\3\61\3\61\7\61\u02af\n\61\f"+
"\61\16\61\u02b2\13\61\5\61\u02b4\n\61\3\61\3\61\3\62\3\62\3\62\3\62\5"+
"\62\u02bc\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\u02d1\n\63\3\64\3\64\3\64"+
"\7\64\u02d6\n\64\f\64\16\64\u02d9\13\64\3\65\3\65\3\65\3\65\3\65\3\65"+
"\5\65\u02e1\n\65\5\65\u02e3\n\65\3\66\3\66\3\66\3\66\3\66\7\66\u02ea\n"+
"\66\f\66\16\66\u02ed\13\66\3\67\3\67\38\38\38\39\39\39\39\39\79\u02f9"+
"\n9\f9\169\u02fc\139\3:\3:\3:\5:\u0301\n:\3:\3:\3:\5:\u0306\n:\5:\u0308"+
"\n:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\7;\u0317\n;\f;\16;\u031a\13"+
";\3<\5<\u031d\n<\3<\5<\u0320\n<\3<\5<\u0323\n<\3<\5<\u0326\n<\3=\3=\3"+
"=\3=\3=\7=\u032d\n=\f=\16=\u0330\13=\3>\3>\3>\5>\u0335\n>\3>\3>\3>\3>"+
"\3>\3>\5>\u033d\n>\5>\u033f\n>\3?\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u034b"+
"\n?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u0359\n@\3A\3A\3A\3A\3A\3A"+
"\3A\3A\3A\3A\5A\u0365\nA\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\5C\u0371\nC\3D"+
"\3D\5D\u0375\nD\3E\3E\3E\3E\3E\3E\3E\7E\u037e\nE\fE\16E\u0381\13E\3E\3"+
"E\5E\u0385\nE\3F\3F\5F\u0389\nF\3G\3G\3G\7G\u038e\nG\fG\16G\u0391\13G"+
"\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\6I\u03a2\nI\rI\16I\u03a3"+
"\3I\3I\5I\u03a8\nI\3I\3I\3I\3I\6I\u03ae\nI\rI\16I\u03af\3I\3I\5I\u03b4"+
"\nI\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03be\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I"+
"\3I\3I\3I\3I\3I\3I\3I\3I\7I\u03d2\nI\fI\16I\u03d5\13I\3J\3J\3J\3J\3J\3"+
"J\3J\3J\5J\u03df\nJ\3J\3J\3J\3J\3J\3J\5J\u03e7\nJ\3J\3J\3J\5J\u03ec\n"+
"J\3J\3J\3J\3J\3J\5J\u03f3\nJ\3J\3J\3J\3J\3J\5J\u03fa\nJ\3J\3J\3J\3J\3"+
"J\5J\u0401\nJ\3J\3J\3J\5J\u0406\nJ\3J\3J\3J\3J\3J\5J\u040d\nJ\3J\3J\3"+
"J\5J\u0412\nJ\3J\3J\3J\3J\3J\5J\u0419\nJ\3J\3J\3J\5J\u041e\nJ\3J\3J\3"+
"J\3J\3J\5J\u0425\nJ\3J\3J\3J\5J\u042a\nJ\3J\3J\3J\3J\3J\5J\u0431\nJ\3"+
"J\3J\3J\5J\u0436\nJ\3J\3J\3J\3J\3J\5J\u043d\nJ\3J\3J\3J\3J\3J\3J\3J\3"+
"J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u0459\nJ\3"+
"J\3J\3J\3J\3J\5J\u0460\nJ\3J\3J\3J\3J\3J\3J\3J\5J\u0469\nJ\3J\3J\3J\3"+
"J\5J\u046f\nJ\3J\3J\5J\u0473\nJ\3J\3J\3J\3J\5J\u0479\nJ\3J\3J\3J\3J\3"+
"J\3J\7J\u0481\nJ\fJ\16J\u0484\13J\3K\3K\5K\u0488\nK\3L\3L\3L\3L\7L\u048e"+
"\nL\fL\16L\u0491\13L\3L\3L\3L\5L\u0496\nL\3M\3M\3M\3M\5M\u049c\nM\3M\3"+
"M\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3"+
"P\3P\5P\u04b8\nP\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3S\3S\3S\3S\3T\3T\3U\3U\3U\3"+
"U\5U\u04cc\nU\3V\3V\3V\5V\u04d1\nV\3V\5V\u04d4\nV\3V\5V\u04d7\nV\3V\3"+
"V\3V\3V\3V\3V\5V\u04df\nV\3V\3V\3V\5V\u04e4\nV\3V\3V\5V\u04e8\nV\3V\3"+
"V\3V\3V\3V\3V\5V\u04f0\nV\3V\3V\3V\3V\3V\3V\5V\u04f8\nV\5V\u04fa\nV\3"+
"V\3V\3V\5V\u04ff\nV\3V\3V\3V\7V\u0504\nV\fV\16V\u0507\13V\5V\u0509\nV"+
"\3V\3V\3V\3V\3V\3V\5V\u0511\nV\3V\3V\3V\3V\3V\3V\5V\u0519\nV\5V\u051b"+
"\nV\5V\u051d\nV\3W\3W\3X\3X\3Y\3Y\3Y\2\4\u0090\u0092Z\2\4\6\b\n\f\16\20"+
"\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhj"+
"lnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092"+
"\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa"+
"\u00ac\u00ae\u00b0\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@@cc\t\2\f\33 *,GILNegp\u008a"+
"\u008a\2\u05b3\2\u00b7\3\2\2\2\4\u00bc\3\2\2\2\6\u00c8\3\2\2\2\b\u00ca"+
"\3\2\2\2\n\u00d3\3\2\2\2\f\u00d9\3\2\2\2\16\u00db\3\2\2\2\20\u00de\3\2"+
"\2\2\22\u00f2\3\2\2\2\24\u00fe\3\2\2\2\26\u010a\3\2\2\2\30\u010c\3\2\2"+
"\2\32\u0124\3\2\2\2\34\u012c\3\2\2\2\36\u0140\3\2\2\2 \u0162\3\2\2\2\""+
"\u017b\3\2\2\2$\u017d\3\2\2\2&\u0188\3\2\2\2(\u0192\3\2\2\2*\u01b4\3\2"+
"\2\2,\u01bd\3\2\2\2.\u01c6\3\2\2\2\60\u01cf\3\2\2\2\62\u0211\3\2\2\2\64"+
"\u0213\3\2\2\2\66\u021e\3\2\2\28\u0223\3\2\2\2:\u0225\3\2\2\2<\u0229\3"+
"\2\2\2>\u0231\3\2\2\2@\u023a\3\2\2\2B\u0242\3\2\2\2D\u0244\3\2\2\2F\u025a"+
"\3\2\2\2H\u025c\3\2\2\2J\u025f\3\2\2\2L\u026b\3\2\2\2N\u0277\3\2\2\2P"+
"\u027b\3\2\2\2R\u0281\3\2\2\2T\u0286\3\2\2\2V\u0288\3\2\2\2X\u028d\3\2"+
"\2\2Z\u029a\3\2\2\2\\\u029c\3\2\2\2^\u02a7\3\2\2\2`\u02a9\3\2\2\2b\u02b7"+
"\3\2\2\2d\u02d0\3\2\2\2f\u02d2\3\2\2\2h\u02da\3\2\2\2j\u02e4\3\2\2\2l"+
"\u02ee\3\2\2\2n\u02f0\3\2\2\2p\u02f3\3\2\2\2r\u02fd\3\2\2\2t\u0309\3\2"+
"\2\2v\u031c\3\2\2\2x\u0327\3\2\2\2z\u033e\3\2\2\2|\u034a\3\2\2\2~\u0358"+
"\3\2\2\2\u0080\u0364\3\2\2\2\u0082\u0366\3\2\2\2\u0084\u0370\3\2\2\2\u0086"+
"\u0374\3\2\2\2\u0088\u0384\3\2\2\2\u008a\u0388\3\2\2\2\u008c\u038a\3\2"+
"\2\2\u008e\u0392\3\2\2\2\u0090\u03bd\3\2\2\2\u0092\u0478\3\2\2\2\u0094"+
"\u0487\3\2\2\2\u0096\u0495\3\2\2\2\u0098\u0497\3\2\2\2\u009a\u049f\3\2"+
"\2\2\u009c\u04a4\3\2\2\2\u009e\u04b7\3\2\2\2\u00a0\u04b9\3\2\2\2\u00a2"+
"\u04bd\3\2\2\2\u00a4\u04c1\3\2\2\2\u00a6\u04c5\3\2\2\2\u00a8\u04cb\3\2"+
"\2\2\u00aa\u051c\3\2\2\2\u00ac\u051e\3\2\2\2\u00ae\u0520\3\2\2\2\u00b0"+
"\u0522\3\2\2\2\u00b2\u00b4\7p\2\2\u00b3\u00b5\7X\2\2\u00b4\u00b3\3\2\2"+
"\2\u00b4\u00b5\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b8\5\20\t\2\u00b7"+
"\u00b2\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00ba\5\22"+
"\n\2\u00ba\u00bb\7\2\2\3\u00bb\3\3\2\2\2\u00bc\u00bd\5R*\2\u00bd\u00be"+
"\7\2\2\3\u00be\5\3\2\2\2\u00bf\u00c0\5^\60\2\u00c0\u00c1\7\2\2\3\u00c1"+
"\u00c9\3\2\2\2\u00c2\u00c3\5b\62\2\u00c3\u00c4\7\2\2\3\u00c4\u00c9\3\2"+
"\2\2\u00c5\u00c6\5`\61\2\u00c6\u00c7\7\2\2\3\u00c7\u00c9\3\2\2\2\u00c8"+
"\u00bf\3\2\2\2\u00c8\u00c2\3\2\2\2\u00c8\u00c5\3\2\2\2\u00c9\7\3\2\2\2"+
"\u00ca\u00cb\5\u0090I\2\u00cb\u00cc\7\2\2\3\u00cc\t\3\2\2\2\u00cd\u00ce"+
"\5\u008aF\2\u00ce\u00cf\7\2\2\3\u00cf\u00d4\3\2\2\2\u00d0\u00d1\5\u008c"+
"G\2\u00d1\u00d2\7\2\2\3\u00d2\u00d4\3\2\2\2\u00d3\u00cd\3\2\2\2\u00d3"+
"\u00d0\3\2\2\2\u00d4\13\3\2\2\2\u00d5\u00d6\5\u008aF\2\u00d6\u00d7\7\2"+
"\2\3\u00d7\u00da\3\2\2\2\u00d8\u00da\5\6\4\2\u00d9\u00d5\3\2\2\2\u00d9"+
"\u00d8\3\2\2\2\u00da\r\3\2\2\2\u00db\u00dc\5\u0092J\2\u00dc\u00dd\7\2"+
"\2\3\u00dd\17\3\2\2\2\u00de\u00df\5\66\34\2\u00df\u00e0\7}\2\2\u00e0\u00e5"+
"\5\u00b0Y\2\u00e1\u00e2\7{\2\2\u00e2\u00e4\5\u00b0Y\2\u00e3\u00e1\3\2"+
"\2\2\u00e4\u00e7\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6"+
"\u00e8\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00e9\7~\2\2\u00e9\u00ea\7\20"+
"\2\2\u00ea\u00eb\7}\2\2\u00eb\u00ec\5\22\n\2\u00ec\u00ed\7~\2\2\u00ed"+
"\21\3\2\2\2\u00ee\u00f3\5\24\13\2\u00ef\u00f3\5\36\20\2\u00f0\u00f3\5"+
"\34\17\2\u00f1\u00f3\5 \21\2\u00f2\u00ee\3\2\2\2\u00f2\u00ef\3\2\2\2\u00f2"+
"\u00f0\3\2\2\2\u00f2\u00f1\3\2\2\2\u00f3\23\3\2\2\2\u00f4\u00ff\5(\25"+
"\2\u00f5\u00f6\7}\2\2\u00f6\u00f7\5\24\13\2\u00f7\u00f8\7~\2\2\u00f8\u00fa"+
"\t\2\2\2\u00f9\u00fb\t\3\2\2\u00fa\u00f9\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+
"\u00fc\3\2\2\2\u00fc\u00fd\5\24\13\2\u00fd\u00ff\3\2\2\2\u00fe\u00f4\3"+
"\2\2\2\u00fe\u00f5\3\2\2\2\u00ff\25\3\2\2\2\u0100\u010b\5\30\r\2\u0101"+
"\u0102\7}\2\2\u0102\u0103\5\26\f\2\u0103\u0104\7~\2\2\u0104\u0106\t\2"+
"\2\2\u0105\u0107\t\3\2\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107"+
"\u0108\3\2\2\2\u0108\u0109\5\26\f\2\u0109\u010b\3\2\2\2\u010a\u0100\3"+
"\2\2\2\u010a\u0101\3\2\2\2\u010b\27\3\2\2\2\u010c\u010d\5L\'\2\u010d\u010f"+
"\5,\27\2\u010e\u0110\5\u0088E\2\u010f\u010e\3\2\2\2\u010f\u0110\3\2\2"+
"\2\u0110\u0112\3\2\2\2\u0111\u0113\5\u008eH\2\u0112\u0111\3\2\2\2\u0112"+
"\u0113\3\2\2\2\u0113\u0115\3\2\2\2\u0114\u0116\5j\66\2\u0115\u0114\3\2"+
"\2\2\u0115\u0116\3\2\2\2\u0116\u0118\3\2\2\2\u0117\u0119\5n8\2\u0118\u0117"+
"\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011f\3\2\2\2\u011a\u011c\t\2\2\2\u011b"+
"\u011d\t\3\2\2\u011c\u011b\3\2\2\2\u011c\u011d\3\2\2\2\u011d\u011e\3\2"+
"\2\2\u011e\u0120\5\26\f\2\u011f\u011a\3\2\2\2\u011f\u0120\3\2\2\2\u0120"+
"\u0122\3\2\2\2\u0121\u0123\5\32\16\2\u0122\u0121\3\2\2\2\u0122\u0123\3"+
"\2\2\2\u0123\31\3\2\2\2\u0124\u012a\5p9\2\u0125\u0127\5\u0082B\2\u0126"+
"\u0128\5\u0084C\2\u0127\u0126\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012b"+
"\3\2\2\2\u0129\u012b\5\u0084C\2\u012a\u0125\3\2\2\2\u012a\u0129\3\2\2"+
"\2\u012b\33\3\2\2\2\u012c\u012e\7 \2\2\u012d\u012f\7\60\2\2\u012e\u012d"+
"\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0135\5\66\34\2"+
"\u0131\u0132\7}\2\2\u0132\u0133\5f\64\2\u0133\u0134\7~\2\2\u0134\u0136"+
"\3\2\2\2\u0135\u0131\3\2\2\2\u0135\u0136\3\2\2\2\u0136\u0138\3\2\2\2\u0137"+
"\u0139\58\35\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2"+
"\2\2\u013a\u013c\5\u008eH\2\u013b\u013a\3\2\2\2\u013b\u013c\3\2\2\2\u013c"+
"\u013e\3\2\2\2\u013d\u013f\5&\24\2\u013e\u013d\3\2\2\2\u013e\u013f\3\2"+
"\2\2\u013f\35\3\2\2\2\u0140\u0142\7j\2\2\u0141\u0143\7\60\2\2\u0142\u0141"+
"\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0149\5\66\34\2"+
"\u0145\u0146\7}\2\2\u0146\u0147\5f\64\2\u0147\u0148\7~\2\2\u0148\u014a"+
"\3\2\2\2\u0149\u0145\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014c\3\2\2\2\u014b"+
"\u014d\58\35\2\u014c\u014b\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u014e\3\2"+
"\2\2\u014e\u014f\7^\2\2\u014f\u0150\5\"\22\2\u0150\u0151\7u\2\2\u0151"+
"\u0159\5\u0090I\2\u0152\u0153\7{\2\2\u0153\u0154\5\"\22\2\u0154\u0155"+
"\7u\2\2\u0155\u0156\5\u0090I\2\u0156\u0158\3\2\2\2\u0157\u0152\3\2\2\2"+
"\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015d"+
"\3\2\2\2\u015b\u0159\3\2\2\2\u015c\u015e\5\u008eH\2\u015d\u015c\3\2\2"+
"\2\u015d\u015e\3\2\2\2\u015e\u0160\3\2\2\2\u015f\u0161\5&\24\2\u0160\u015f"+
"\3\2\2\2\u0160\u0161\3\2\2\2\u0161\37\3\2\2\2\u0162\u0163\78\2\2\u0163"+
"\u0164\7:\2\2\u0164\u0169\5\66\34\2\u0165\u0166\7}\2\2\u0166\u0167\5f"+
"\64\2\u0167\u0168\7~\2\2\u0168\u016a\3\2\2\2\u0169\u0165\3\2\2\2\u0169"+
"\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c\5$\23\2\u016c\u016e\5("+
"\25\2\u016d\u016f\5&\24\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2\2\2\u016f"+
"!\3\2\2\2\u0170\u017c\5f\64\2\u0171\u0172\7>\2\2\u0172\u0173\7}\2\2\u0173"+
"\u0174\5^\60\2\u0174\u0175\7~\2\2\u0175\u017c\3\2\2\2\u0176\u0177\7\66"+
"\2\2\u0177\u0178\7}\2\2\u0178\u0179\5^\60\2\u0179\u017a\7~\2\2\u017a\u017c"+
"\3\2\2\2\u017b\u0170\3\2\2\2\u017b\u0171\3\2\2\2\u017b\u0176\3\2\2\2\u017c"+
"#\3\2\2\2\u017d\u017e\7}\2\2\u017e\u0183\5\"\22\2\u017f\u0180\7{\2\2\u0180"+
"\u0182\5\"\22\2\u0181\u017f\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0181\3"+
"\2\2\2\u0183\u0184\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0183\3\2\2\2\u0186"+
"\u0187\7~\2\2\u0187%\3\2\2\2\u0188\u0189\7Y\2\2\u0189\u018e\5f\64\2\u018a"+
"\u018b\7{\2\2\u018b\u018d\5f\64\2\u018c\u018a\3\2\2\2\u018d\u0190\3\2"+
"\2\2\u018e\u018c\3\2\2\2\u018e\u018f\3\2\2\2\u018f\'\3\2\2\2\u0190\u018e"+
"\3\2\2\2\u0191\u0193\5J&\2\u0192\u0191\3\2\2\2\u0192\u0193\3\2\2\2\u0193"+
"\u0194\3\2\2\2\u0194\u0196\5*\26\2\u0195\u0197\5\u0088E\2\u0196\u0195"+
"\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0199\3\2\2\2\u0198\u019a\5\u008eH"+
"\2\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019c\3\2\2\2\u019b\u019d"+
"\5j\66\2\u019c\u019b\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e"+
"\u01a0\5n8\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2"+
"\2\u01a1\u01a3\5t;\2\u01a2\u01a1\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01a9"+
"\3\2\2\2\u01a4\u01a6\t\2\2\2\u01a5\u01a7\t\3\2\2\u01a6\u01a5\3\2\2\2\u01a6"+
"\u01a7\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8\u01aa\5(\25\2\u01a9\u01a4\3\2"+
"\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ac\3\2\2\2\u01ab\u01ad\5p9\2\u01ac\u01ab"+
"\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01af\3\2\2\2\u01ae\u01b0\5\u0082B"+
"\2\u01af\u01ae\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01b3"+
"\5\u0084C\2\u01b2\u01b1\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3)\3\2\2\2\u01b4"+
"\u01b5\7\60\2\2\u01b5\u01ba\5.\30\2\u01b6\u01b7\7{\2\2\u01b7\u01b9\5."+
"\30\2\u01b8\u01b6\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba"+
"\u01bb\3\2\2\2\u01bb+\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bd\u01be\7\60\2\2"+
"\u01be\u01c3\5\60\31\2\u01bf\u01c0\7{\2\2\u01c0\u01c2\5\60\31\2\u01c1"+
"\u01bf\3\2\2\2\u01c2\u01c5\3\2\2\2\u01c3\u01c1\3\2\2\2\u01c3\u01c4\3\2"+
"\2\2\u01c4-\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c6\u01cc\5\62\32\2\u01c7\u01cb"+
"\5:\36\2\u01c8\u01cb\5<\37\2\u01c9\u01cb\5> \2\u01ca\u01c7\3\2\2\2\u01ca"+
"\u01c8\3\2\2\2\u01ca\u01c9\3\2\2\2\u01cb\u01ce\3\2\2\2\u01cc\u01ca\3\2"+
"\2\2\u01cc\u01cd\3\2\2\2\u01cd/\3\2\2\2\u01ce\u01cc\3\2\2\2\u01cf\u01d5"+
"\5\62\32\2\u01d0\u01d4\5:\36\2\u01d1\u01d4\5<\37\2\u01d2\u01d4\5@!\2\u01d3"+
"\u01d0\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2\3\2\2\2\u01d4\u01d7\3\2"+
"\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\61\3\2\2\2\u01d7\u01d5"+
"\3\2\2\2\u01d8\u01da\5\66\34\2\u01d9\u01db\58\35\2\u01da\u01d9\3\2\2\2"+
"\u01da\u01db\3\2\2\2\u01db\u0212\3\2\2\2\u01dc\u01dd\5\66\34\2\u01dd\u01de"+
"\7}\2\2\u01de\u01df\7\4\2\2\u01df\u01e0\7l\2\2\u01e0\u01e1\7~\2\2\u01e1"+
"\u01e2\58\35\2\u01e2\u0212\3\2\2\2\u01e3\u01e4\5\66\34\2\u01e4\u01e5\7"+
"}\2\2\u01e5\u01e6\7l\2\2\u01e6\u01eb\5\64\33\2\u01e7\u01e8\7{\2\2\u01e8"+
"\u01ea\5\64\33\2\u01e9\u01e7\3\2\2\2\u01ea\u01ed\3\2\2\2\u01eb\u01e9\3"+
"\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ee\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ee"+
"\u01ef\7~\2\2\u01ef\u01f0\58\35\2\u01f0\u0212\3\2\2\2\u01f1\u01f2\5\u00b0"+
"Y\2\u01f2\u01f3\7}\2\2\u01f3\u01f4\7\4\2\2\u01f4\u01f7\7l\2\2\u01f5\u01f6"+
"\7B\2\2\u01f6\u01f8\5\66\34\2\u01f7\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2"+
"\u01f8\u01f9\3\2\2\2\u01f9\u01fa\7~\2\2\u01fa\u01fb\58\35\2\u01fb\u0212"+
"\3\2\2\2\u01fc\u01fd\5\u00b0Y\2\u01fd\u01fe\7}\2\2\u01fe\u01ff\7l\2\2"+
"\u01ff\u0204\5\64\33\2\u0200\u0201\7{\2\2\u0201\u0203\5\64\33\2\u0202"+
"\u0200\3\2\2\2\u0203\u0206\3\2\2\2\u0204\u0202\3\2\2\2\u0204\u0205\3\2"+
"\2\2\u0205\u0207\3\2\2\2\u0206\u0204\3\2\2\2\u0207\u0208\7~\2\2\u0208"+
"\u0209\58\35\2\u0209\u0212\3\2\2\2\u020a\u020b\t\4\2\2\u020b\u020c\7}"+
"\2\2\u020c\u020d\5\66\34\2\u020d\u020f\7~\2\2\u020e\u0210\58\35\2\u020f"+
"\u020e\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0212\3\2\2\2\u0211\u01d8\3\2"+
"\2\2\u0211\u01dc\3\2\2\2\u0211\u01e3\3\2\2\2\u0211\u01f1\3\2\2\2\u0211"+
"\u01fc\3\2\2\2\u0211\u020a\3\2\2\2\u0212\63\3\2\2\2\u0213\u0214\7}\2\2"+
"\u0214\u0219\5\u009eP\2\u0215\u0216\7{\2\2\u0216\u0218\5\u009eP\2\u0217"+
"\u0215\3\2\2\2\u0218\u021b\3\2\2\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2"+
"\2\2\u021a\u021c\3\2\2\2\u021b\u0219\3\2\2\2\u021c\u021d\7~\2\2\u021d"+
"\65\3\2\2\2\u021e\u021f\5f\64\2\u021f\67\3\2\2\2\u0220\u0221\7\20\2\2"+
"\u0221\u0224\5\u00b0Y\2\u0222\u0224\7\u008a\2\2\u0223\u0220\3\2\2\2\u0223"+
"\u0222\3\2\2\2\u02249\3\2\2\2\u0225\u0226\7\32\2\2\u0226\u0227\7<\2\2"+
"\u0227\u0228\5\62\32\2\u0228;\3\2\2\2\u0229\u022a\7{\2\2\u022a\u022b\7"+
"\65\2\2\u022b\u022c\7}\2\2\u022c\u022d\5^\60\2\u022d\u022f\7~\2\2\u022e"+
"\u0230\58\35\2\u022f\u022e\3\2\2\2\u022f\u0230\3\2\2\2\u0230=\3\2\2\2"+
"\u0231\u0232\5F$\2\u0232\u0234\7<\2\2\u0233\u0235\7,\2\2\u0234\u0233\3"+
"\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0238\5B\"\2\u0237"+
"\u0239\5H%\2\u0238\u0237\3\2\2\2\u0238\u0239\3\2\2\2\u0239?\3\2\2\2\u023a"+
"\u023b\5F$\2\u023b\u023c\7<\2\2\u023c\u023e\5B\"\2\u023d\u023f\5H%\2\u023e"+
"\u023d\3\2\2\2\u023e\u023f\3\2\2\2\u023fA\3\2\2\2\u0240\u0243\5\62\32"+
"\2\u0241\u0243\5D#\2\u0242\u0240\3\2\2\2\u0242\u0241\3\2\2\2\u0243C\3"+
"\2\2\2\u0244\u0245\7d\2\2\u0245\u0246\7}\2\2\u0246\u0247\5^\60\2\u0247"+
"\u0248\7\20\2\2\u0248\u0249\5\66\34\2\u0249\u024c\7~\2\2\u024a\u024b\7"+
"|\2\2\u024b\u024d\5h\65\2\u024c\u024a\3\2\2\2\u024c\u024d\3\2\2\2\u024d"+
"\u024f\3\2\2\2\u024e\u0250\58\35\2\u024f\u024e\3\2\2\2\u024f\u0250\3\2"+
"\2\2\u0250E\3\2\2\2\u0251\u0253\7\67\2\2\u0252\u0251\3\2\2\2\u0252\u0253"+
"\3\2\2\2\u0253\u025b\3\2\2\2\u0254\u0256\t\5\2\2\u0255\u0254\3\2\2\2\u0255"+
"\u0256\3\2\2\2\u0256\u0258\3\2\2\2\u0257\u0259\7R\2\2\u0258\u0257\3\2"+
"\2\2\u0258\u0259\3\2\2\2\u0259\u025b\3\2\2\2\u025a\u0252\3\2\2\2\u025a"+
"\u0255\3\2\2\2\u025bG\3\2\2\2\u025c\u025d\7N\2\2\u025d\u025e\5\u0092J"+
"\2\u025eI\3\2\2\2\u025f\u0261\7]\2\2\u0260\u0262\7\"\2\2\u0261\u0260\3"+
"\2\2\2\u0261\u0262\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0268\5N(\2\u0264"+
"\u0265\7{\2\2\u0265\u0267\5N(\2\u0266\u0264\3\2\2\2\u0267\u026a\3\2\2"+
"\2\u0268\u0266\3\2\2\2\u0268\u0269\3\2\2\2\u0269K\3\2\2\2\u026a\u0268"+
"\3\2\2\2\u026b\u026d\7]\2\2\u026c\u026e\7\"\2\2\u026d\u026c\3\2\2\2\u026d"+
"\u026e\3\2\2\2\u026e\u026f\3\2\2\2\u026f\u0274\5P)\2\u0270\u0271\7{\2"+
"\2\u0271\u0273\5P)\2\u0272\u0270\3\2\2\2\u0273\u0276\3\2\2\2\u0274\u0272"+
"\3\2\2\2\u0274\u0275\3\2\2\2\u0275M\3\2\2\2\u0276\u0274\3\2\2\2\u0277"+
"\u0279\5R*\2\u0278\u027a\5T+\2\u0279\u0278\3\2\2\2\u0279\u027a\3\2\2\2"+
"\u027aO\3\2\2\2\u027b\u027c\5\u0090I\2\u027cQ\3\2\2\2\u027d\u0282\5X-"+
"\2\u027e\u0282\5\\/\2\u027f\u0282\5V,\2\u0280\u0282\5\u0090I\2\u0281\u027d"+
"\3\2\2\2\u0281\u027e\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0280\3\2\2\2\u0282"+
"S\3\2\2\2\u0283\u0284\7\20\2\2\u0284\u0287\5\u00b0Y\2\u0285\u0287\7\u008a"+
"\2\2\u0286\u0283\3\2\2\2\u0286\u0285\3\2\2\2\u0287U\3\2\2\2\u0288\u0289"+
"\7&\2\2\u0289\u028a\7}\2\2\u028a\u028b\5^\60\2\u028b\u028c\7~\2\2\u028c"+
"W\3\2\2\2\u028d\u028e\7E\2\2\u028e\u028f\5f\64\2\u028f\u0290\7}\2\2\u0290"+
"\u0295\5Z.\2\u0291\u0292\7{\2\2\u0292\u0294\5Z.\2\u0293\u0291\3\2\2\2"+
"\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0298"+
"\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\7~\2\2\u0299Y\3\2\2\2\u029a\u029b"+
"\5\u0090I\2\u029b[\3\2\2\2\u029c\u029d\7J\2\2\u029d\u029e\7}\2\2\u029e"+
"\u029f\5\u00b0Y\2\u029f\u02a0\7~\2\2\u02a0]\3\2\2\2\u02a1\u02a4\5d\63"+
"\2\u02a2\u02a3\7|\2\2\u02a3\u02a5\5h\65\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5"+
"\3\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a8\5h\65\2\u02a7\u02a1\3\2\2\2\u02a7"+
"\u02a6\3\2\2\2\u02a8_\3\2\2\2\u02a9\u02aa\5\u00b0Y\2\u02aa\u02b3\7}\2"+
"\2\u02ab\u02b0\5\u0090I\2\u02ac\u02ad\7{\2\2\u02ad\u02af\5\u0090I\2\u02ae"+
"\u02ac\3\2\2\2\u02af\u02b2\3\2\2\2\u02b0\u02ae\3\2\2\2\u02b0\u02b1\3\2"+
"\2\2\u02b1\u02b4\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b3\u02ab\3\2\2\2\u02b3"+
"\u02b4\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5\u02b6\7~\2\2\u02b6a\3\2\2\2\u02b7"+
"\u02b8\7R\2\2\u02b8\u02bb\7}\2\2\u02b9\u02bc\5f\64\2\u02ba\u02bc\5`\61"+
"\2\u02bb\u02b9\3\2\2\2\u02bb\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02be"+
"\7~\2\2\u02bec\3\2\2\2\u02bf\u02c0\7d\2\2\u02c0\u02c1\7}\2\2\u02c1\u02c2"+
"\5^\60\2\u02c2\u02c3\7\20\2\2\u02c3\u02c4\5\66\34\2\u02c4\u02c5\7~\2\2"+
"\u02c5\u02d1\3\2\2\2\u02c6\u02c7\7k\2\2\u02c7\u02c8\7}\2\2\u02c8\u02c9"+
"\5^\60\2\u02c9\u02ca\7~\2\2\u02ca\u02d1\3\2\2\2\u02cb\u02cc\7>\2\2\u02cc"+
"\u02cd\7}\2\2\u02cd\u02ce\5^\60\2\u02ce\u02cf\7~\2\2\u02cf\u02d1\3\2\2"+
"\2\u02d0\u02bf\3\2\2\2\u02d0\u02c6\3\2\2\2\u02d0\u02cb\3\2\2\2\u02d1e"+
"\3\2\2\2\u02d2\u02d7\5\u00b0Y\2\u02d3\u02d4\7|\2\2\u02d4\u02d6\5\u00b0"+
"Y\2\u02d5\u02d3\3\2\2\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7"+
"\u02d8\3\2\2\2\u02d8g\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02e2\5f\64\2"+
"\u02db\u02dc\7\177\2\2\u02dc\u02dd\5\u0094K\2\u02dd\u02e0\7\u0080\2\2"+
"\u02de\u02df\7|\2\2\u02df\u02e1\5h\65\2\u02e0\u02de\3\2\2\2\u02e0\u02e1"+
"\3\2\2\2\u02e1\u02e3\3\2\2\2\u02e2\u02db\3\2\2\2\u02e2\u02e3\3\2\2\2\u02e3"+
"i\3\2\2\2\u02e4\u02e5\7\62\2\2\u02e5\u02e6\7\25\2\2\u02e6\u02eb\5l\67"+
"\2\u02e7\u02e8\7{\2\2\u02e8\u02ea\5l\67\2\u02e9\u02e7\3\2\2\2\u02ea\u02ed"+
"\3\2\2\2\u02eb\u02e9\3\2\2\2\u02eb\u02ec\3\2\2\2\u02eck\3\2\2\2\u02ed"+
"\u02eb\3\2\2\2\u02ee\u02ef\5\u0090I\2\u02efm\3\2\2\2\u02f0\u02f1\7\64"+
"\2\2\u02f1\u02f2\5\u0092J\2\u02f2o\3\2\2\2\u02f3\u02f4\7P\2\2\u02f4\u02f5"+
"\7\25\2\2\u02f5\u02fa\5r:\2\u02f6\u02f7\7{\2\2\u02f7\u02f9\5r:\2\u02f8"+
"\u02f6\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2"+
"\2\2\u02fbq\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd\u0300\5\u0090I\2\u02fe\u02ff"+
"\7\27\2\2\u02ff\u0301\7\13\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2\2\2"+
"\u0301\u0307\3\2\2\2\u0302\u0305\t\6\2\2\u0303\u0304\7I\2\2\u0304\u0306"+
"\t\7\2\2\u0305\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u0308\3\2\2\2\u0307"+
"\u0302\3\2\2\2\u0307\u0308\3\2\2\2\u0308s\3\2\2\2\u0309\u030a\7o\2\2\u030a"+
"\u030b\5\u00b0Y\2\u030b\u030c\7\20\2\2\u030c\u030d\7}\2\2\u030d\u030e"+
"\5v<\2\u030e\u0318\7~\2\2\u030f\u0310\7{\2\2\u0310\u0311\5\u00b0Y\2\u0311"+
"\u0312\7\20\2\2\u0312\u0313\7}\2\2\u0313\u0314\5v<\2\u0314\u0315\7~\2"+
"\2\u0315\u0317\3\2\2\2\u0316\u030f\3\2\2\2\u0317\u031a\3\2\2\2\u0318\u0316"+
"\3\2\2\2\u0318\u0319\3\2\2\2\u0319u\3\2\2\2\u031a\u0318\3\2\2\2\u031b"+
"\u031d\5\u00b0Y\2\u031c\u031b\3\2\2\2\u031c\u031d\3\2\2\2\u031d\u031f"+
"\3\2\2\2\u031e\u0320\5x=\2\u031f\u031e\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+
"\u0322\3\2\2\2\u0321\u0323\5p9\2\u0322\u0321\3\2\2\2\u0322\u0323\3\2\2"+
"\2\u0323\u0325\3\2\2\2\u0324\u0326\5z>\2\u0325\u0324\3\2\2\2\u0325\u0326"+
"\3\2\2\2\u0326w\3\2\2\2\u0327\u0328\7U\2\2\u0328\u0329\7\25\2\2\u0329"+
"\u032e\5l\67\2\u032a\u032b\7{\2\2\u032b\u032d\5l\67\2\u032c\u032a\3\2"+
"\2\2\u032d\u0330\3\2\2\2\u032e\u032c\3\2\2\2\u032e\u032f\3\2\2\2\u032f"+
"y\3\2\2\2\u0330\u032e\3\2\2\2\u0331\u0332\t\b\2\2\u0332\u0334\5|?\2\u0333"+
"\u0335\5\u0080A\2\u0334\u0333\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u033f"+
"\3\2\2\2\u0336\u0337\t\b\2\2\u0337\u0338\7\23\2\2\u0338\u0339\5|?\2\u0339"+
"\u033a\7\16\2\2\u033a\u033c\5~@\2\u033b\u033d\5\u0080A\2\u033c\u033b\3"+
"\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e\u0331\3\2\2\2\u033e"+
"\u0336\3\2\2\2\u033f{\3\2\2\2\u0340\u0341\7h\2\2\u0341\u034b\7V\2\2\u0342"+
"\u0343\5\u0086D\2\u0343\u0344\7V\2\2\u0344\u034b\3\2\2\2\u0345\u0346\7"+
"\33\2\2\u0346\u034b\7[\2\2\u0347\u0348\5\u0086D\2\u0348\u0349\7/\2\2\u0349"+
"\u034b\3\2\2\2\u034a\u0340\3\2\2\2\u034a\u0342\3\2\2\2\u034a\u0345\3\2"+
"\2\2\u034a\u0347\3\2\2\2\u034b}\3\2\2\2\u034c\u034d\7h\2\2\u034d\u0359"+
"\7V\2\2\u034e\u034f\5\u0086D\2\u034f\u0350\7V\2\2\u0350\u0359\3\2\2\2"+
"\u0351\u0352\7\33\2\2\u0352\u0359\7[\2\2\u0353\u0354\5\u0086D\2\u0354"+
"\u0355\7/\2\2\u0355\u0359\3\2\2\2\u0356\u0357\7h\2\2\u0357\u0359\7/\2"+
"\2\u0358\u034c\3\2\2\2\u0358\u034e\3\2\2\2\u0358\u0351\3\2\2\2\u0358\u0353"+
"\3\2\2\2\u0358\u0356\3\2\2\2\u0359\177\3\2\2\2\u035a\u035b\7)\2\2\u035b"+
"\u035c\7\33\2\2\u035c\u0365\7[\2\2\u035d\u035e\7)\2\2\u035e\u0365\7\62"+
"\2\2\u035f\u0360\7)\2\2\u0360\u0365\7a\2\2\u0361\u0362\7)\2\2\u0362\u0363"+
"\7F\2\2\u0363\u0365\7Q\2\2\u0364\u035a\3\2\2\2\u0364\u035d\3\2\2\2\u0364"+
"\u035f\3\2\2\2\u0364\u0361\3\2\2\2\u0365\u0081\3\2\2\2\u0366\u0367\7C"+
"\2\2\u0367\u0368\5\u0086D\2\u0368\u0083\3\2\2\2\u0369\u036a\7L\2\2\u036a"+
"\u0371\5\u0086D\2\u036b\u036c\7=\2\2\u036c\u036d\7b\2\2\u036d\u036e\7"+
"T\2\2\u036e\u036f\7\30\2\2\u036f\u0371\5\u00a8U\2\u0370\u0369\3\2\2\2"+
"\u0370\u036b\3\2\2\2\u0371\u0085\3\2\2\2\u0372\u0375\5\u00a8U\2\u0373"+
"\u0375\7\4\2\2\u0374\u0372\3\2\2\2\u0374\u0373\3\2\2\2\u0375\u0087\3\2"+
"\2\2\u0376\u0377\t\t\2\2\u0377\u0385\5\u008aF\2\u0378\u0379\t\t\2\2\u0379"+
"\u037a\7}\2\2\u037a\u037f\5\u008aF\2\u037b\u037c\7{\2\2\u037c\u037e\5"+
"\u008aF\2\u037d\u037b\3\2\2\2\u037e\u0381\3\2\2\2\u037f\u037d\3\2\2\2"+
"\u037f\u0380\3\2\2\2\u0380\u0382\3\2\2\2\u0381\u037f\3\2\2\2\u0382\u0383"+
"\7~\2\2\u0383\u0385\3\2\2\2\u0384\u0376\3\2\2\2\u0384\u0378\3\2\2\2\u0385"+
"\u0089\3\2\2\2\u0386\u0389\5\u00a8U\2\u0387\u0389\5\u009eP\2\u0388\u0386"+
"\3\2\2\2\u0388\u0387\3\2\2\2\u0389\u008b\3\2\2\2\u038a\u038f\5\u00b0Y"+
"\2\u038b\u038c\t\n\2\2\u038c\u038e\5\u00b0Y\2\u038d\u038b\3\2\2\2\u038e"+
"\u0391\3\2\2\2\u038f\u038d\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u008d\3\2"+
"\2\2\u0391\u038f\3\2\2\2\u0392\u0393\7n\2\2\u0393\u0394\5\u0092J\2\u0394"+
"\u008f\3\2\2\2\u0395\u0396\bI\1\2\u0396\u0397\7}\2\2\u0397\u0398\5\u0090"+
"I\2\u0398\u0399\7~\2\2\u0399\u03be\3\2\2\2\u039a\u039b\7\u0082\2\2\u039b"+
"\u03be\5\u0090I\f\u039c\u039d\7\u0081\2\2\u039d\u03be\5\u0090I\13\u039e"+
"\u039f\7\26\2\2\u039f\u03a1\5\u0090I\2\u03a0\u03a2\5\u009aN\2\u03a1\u03a0"+
"\3\2\2\2\u03a2\u03a3\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4"+
"\u03a7\3\2\2\2\u03a5\u03a6\7#\2\2\u03a6\u03a8\5\u0090I\2\u03a7\u03a5\3"+
"\2\2\2\u03a7\u03a8\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03aa\7%\2\2\u03aa"+
"\u03be\3\2\2\2\u03ab\u03ad\7\26\2\2\u03ac\u03ae\5\u009cO\2\u03ad\u03ac"+
"\3\2\2\2\u03ae\u03af\3\2\2\2\u03af\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0"+
"\u03b3\3\2\2\2\u03b1\u03b2\7#\2\2\u03b2\u03b4\5\u0090I\2\u03b3\u03b1\3"+
"\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5\u03b6\7%\2\2\u03b6"+
"\u03be\3\2\2\2\u03b7\u03be\5\u009eP\2\u03b8\u03be\5\u00a8U\2\u03b9\u03be"+
"\5\u0098M\2\u03ba\u03be\t\13\2\2\u03bb\u03be\5^\60\2\u03bc\u03be\5\u00aa"+
"V\2\u03bd\u0395\3\2\2\2\u03bd\u039a\3\2\2\2\u03bd\u039c\3\2\2\2\u03bd"+
"\u039e\3\2\2\2\u03bd\u03ab\3\2\2\2\u03bd\u03b7\3\2\2\2\u03bd\u03b8\3\2"+
"\2\2\u03bd\u03b9\3\2\2\2\u03bd\u03ba\3\2\2\2\u03bd\u03bb\3\2\2\2\u03bd"+
"\u03bc\3\2\2\2\u03be\u03d3\3\2\2\2\u03bf\u03c0\f\22\2\2\u03c0\u03c1\7"+
"\u0083\2\2\u03c1\u03d2\5\u0090I\23\u03c2\u03c3\f\21\2\2\u03c3\u03c4\7"+
"\u0084\2\2\u03c4\u03d2\5\u0090I\22\u03c5\u03c6\f\20\2\2\u03c6\u03c7\7"+
"\u0085\2\2\u03c7\u03d2\5\u0090I\21\u03c8\u03c9\f\17\2\2\u03c9\u03ca\7"+
"\u0087\2\2\u03ca\u03d2\5\u0090I\20\u03cb\u03cc\f\16\2\2\u03cc\u03cd\7"+
"\u0081\2\2\u03cd\u03d2\5\u0090I\17\u03ce\u03cf\f\r\2\2\u03cf\u03d0\7\u0082"+
"\2\2\u03d0\u03d2\5\u0090I\16\u03d1\u03bf\3\2\2\2\u03d1\u03c2\3\2\2\2\u03d1"+
"\u03c5\3\2\2\2\u03d1\u03c8\3\2\2\2\u03d1\u03cb\3\2\2\2\u03d1\u03ce\3\2"+
"\2\2\u03d2\u03d5\3\2\2\2\u03d3\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4"+
"\u0091\3\2\2\2\u03d5\u03d3\3\2\2\2\u03d6\u03d7\bJ\1\2\u03d7\u03d8\7}\2"+
"\2\u03d8\u03d9\5\u0092J\2\u03d9\u03da\7~\2\2\u03da\u0479\3\2\2\2\u03db"+
"\u03dc\7G\2\2\u03dc\u0479\5\u0092J\30\u03dd\u03df\7G\2\2\u03de\u03dd\3"+
"\2\2\2\u03de\u03df\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e6\7*\2\2\u03e1"+
"\u03e7\5\u00b0Y\2\u03e2\u03e3\7}\2\2\u03e3\u03e4\5\u00b0Y\2\u03e4\u03e5"+
"\7~\2\2\u03e5\u03e7\3\2\2\2\u03e6\u03e1\3\2\2\2\u03e6\u03e2\3\2\2\2\u03e7"+
"\u0479\3\2\2\2\u03e8\u03e9\5\u0090I\2\u03e9\u03eb\7;\2\2\u03ea\u03ec\7"+
"G\2\2\u03eb\u03ea\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed"+
"\u03ee\7H\2\2\u03ee\u0479\3\2\2\2\u03ef\u03f0\5\u0090I\2\u03f0\u03f2\7"+
";\2\2\u03f1\u03f3\7G\2\2\u03f2\u03f1\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3"+
"\u03f4\3\2\2\2\u03f4\u03f5\7$\2\2\u03f5\u0479\3\2\2\2\u03f6\u03f7\5\u0090"+
"I\2\u03f7\u03f9\7u\2\2\u03f8\u03fa\t\f\2\2\u03f9\u03f8\3\2\2\2\u03f9\u03fa"+
"\3\2\2\2\u03fa\u0400\3\2\2\2\u03fb\u0401\5\u00b0Y\2\u03fc\u03fd\7}\2\2"+
"\u03fd\u03fe\5\u00b0Y\2\u03fe\u03ff\7~\2\2\u03ff\u0401\3\2\2\2\u0400\u03fb"+
"\3\2\2\2\u0400\u03fc\3\2\2\2\u0401\u0479\3\2\2\2\u0402\u0403\5\u0090I"+
"\2\u0403\u0405\7v\2\2\u0404\u0406\t\f\2\2\u0405\u0404\3\2\2\2\u0405\u0406"+
"\3\2\2\2\u0406\u040c\3\2\2\2\u0407\u040d\5\u00b0Y\2\u0408\u0409\7}\2\2"+
"\u0409\u040a\5\u00b0Y\2\u040a\u040b\7~\2\2\u040b\u040d\3\2\2\2\u040c\u0407"+
"\3\2\2\2\u040c\u0408\3\2\2\2\u040d\u0479\3\2\2\2\u040e\u040f\5\u0090I"+
"\2\u040f\u0411\7w\2\2\u0410\u0412\t\f\2\2\u0411\u0410\3\2\2\2\u0411\u0412"+
"\3\2\2\2\u0412\u0418\3\2\2\2\u0413\u0419\5\u00b0Y\2\u0414\u0415\7}\2\2"+
"\u0415\u0416\5\u00b0Y\2\u0416\u0417\7~\2\2\u0417\u0419\3\2\2\2\u0418\u0413"+
"\3\2\2\2\u0418\u0414\3\2\2\2\u0419\u0479\3\2\2\2\u041a\u041b\5\u0090I"+
"\2\u041b\u041d\7x\2\2\u041c\u041e\t\f\2\2\u041d\u041c\3\2\2\2\u041d\u041e"+
"\3\2\2\2\u041e\u0424\3\2\2\2\u041f\u0425\5\u00b0Y\2\u0420\u0421\7}\2\2"+
"\u0421\u0422\5\u00b0Y\2\u0422\u0423\7~\2\2\u0423\u0425\3\2\2\2\u0424\u041f"+
"\3\2\2\2\u0424\u0420\3\2\2\2\u0425\u0479\3\2\2\2\u0426\u0427\5\u0090I"+
"\2\u0427\u0429\7y\2\2\u0428\u042a\t\f\2\2\u0429\u0428\3\2\2\2\u0429\u042a"+
"\3\2\2\2\u042a\u0430\3\2\2\2\u042b\u0431\5\u00b0Y\2\u042c\u042d\7}\2\2"+
"\u042d\u042e\5\u00b0Y\2\u042e\u042f\7~\2\2\u042f\u0431\3\2\2\2\u0430\u042b"+
"\3\2\2\2\u0430\u042c\3\2\2\2\u0431\u0479\3\2\2\2\u0432\u0433\5\u0090I"+
"\2\u0433\u0435\7z\2\2\u0434\u0436\t\f\2\2\u0435\u0434\3\2\2\2\u0435\u0436"+
"\3\2\2\2\u0436\u043c\3\2\2\2\u0437\u043d\5\u00b0Y\2\u0438\u0439\7}\2\2"+
"\u0439\u043a\5\u00b0Y\2\u043a\u043b\7~\2\2\u043b\u043d\3\2\2\2\u043c\u0437"+
"\3\2\2\2\u043c\u0438\3\2\2\2\u043d\u0479\3\2\2\2\u043e\u043f\5\u0090I"+
"\2\u043f\u0440\7u\2\2\u0440\u0441\5\u0090I\2\u0441\u0479\3\2\2\2\u0442"+
"\u0443\5\u0090I\2\u0443\u0444\7v\2\2\u0444\u0445\5\u0090I\2\u0445\u0479"+
"\3\2\2\2\u0446\u0447\5\u0090I\2\u0447\u0448\7w\2\2\u0448\u0449\5\u0090"+
"I\2\u0449\u0479\3\2\2\2\u044a\u044b\5\u0090I\2\u044b\u044c\7x\2\2\u044c"+
"\u044d\5\u0090I\2\u044d\u0479\3\2\2\2\u044e\u044f\5\u0090I\2\u044f\u0450"+
"\7y\2\2\u0450\u0451\5\u0090I\2\u0451\u0479\3\2\2\2\u0452\u0453\5\u0090"+
"I\2\u0453\u0454\7z\2\2\u0454\u0455\5\u0090I\2\u0455\u0479\3\2\2\2\u0456"+
"\u0458\5\u0090I\2\u0457\u0459\7G\2\2\u0458\u0457\3\2\2\2\u0458\u0459\3"+
"\2\2\2\u0459\u045a\3\2\2\2\u045a\u045b\7\65\2\2\u045b\u045c\5\u0096L\2"+
"\u045c\u0479\3\2\2\2\u045d\u045f\5\u0090I\2\u045e\u0460\7G\2\2\u045f\u045e"+
"\3\2\2\2\u045f\u0460\3\2\2\2\u0460\u0461\3\2\2\2\u0461\u0462\7\23\2\2"+
"\u0462\u0463\5\u0090I\2\u0463\u0464\7\16\2\2\u0464\u0465\5\u0090I\2\u0465"+
"\u0479\3\2\2\2\u0466\u0468\5\u0090I\2\u0467\u0469\7G\2\2\u0468\u0467\3"+
"\2\2\2\u0468\u0469\3\2\2\2\u0469\u046a\3\2\2\2\u046a\u046b\7B\2\2\u046b"+
"\u046e\5\u0090I\2\u046c\u046d\7\'\2\2\u046d\u046f\5\u0090I\2\u046e\u046c"+
"\3\2\2\2\u046e\u046f\3\2\2\2\u046f\u0479\3\2\2\2\u0470\u0472\5\u0090I"+
"\2\u0471\u0473\7G\2\2\u0472\u0471\3\2\2\2\u0472\u0473\3\2\2\2\u0473\u0474"+
"\3\2\2\2\u0474\u0475\7D\2\2\u0475\u0476\7K\2\2\u0476\u0477\5^\60\2\u0477"+
"\u0479\3\2\2\2\u0478\u03d6\3\2\2\2\u0478\u03db\3\2\2\2\u0478\u03de\3\2"+
"\2\2\u0478\u03e8\3\2\2\2\u0478\u03ef\3\2\2\2\u0478\u03f6\3\2\2\2\u0478"+
"\u0402\3\2\2\2\u0478\u040e\3\2\2\2\u0478\u041a\3\2\2\2\u0478\u0426\3\2"+
"\2\2\u0478\u0432\3\2\2\2\u0478\u043e\3\2\2\2\u0478\u0442\3\2\2\2\u0478"+
"\u0446\3\2\2\2\u0478\u044a\3\2\2\2\u0478\u044e\3\2\2\2\u0478\u0452\3\2"+
"\2\2\u0478\u0456\3\2\2\2\u0478\u045d\3\2\2\2\u0478\u0466\3\2\2\2\u0478"+
"\u0470\3\2\2\2\u0479\u0482\3\2\2\2\u047a\u047b\f\27\2\2\u047b\u047c\7"+
"\16\2\2\u047c\u0481\5\u0092J\30\u047d\u047e\f\26\2\2\u047e\u047f\7O\2"+
"\2\u047f\u0481\5\u0092J\27\u0480\u047a\3\2\2\2\u0480\u047d\3\2\2\2\u0481"+
"\u0484\3\2\2\2\u0482\u0480\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u0093\3\2"+
"\2\2\u0484\u0482\3\2\2\2\u0485\u0488\5\u0092J\2\u0486\u0488\5\u0090I\2"+
"\u0487\u0485\3\2\2\2\u0487\u0486\3\2\2\2\u0488\u0095\3\2\2\2\u0489\u048a"+
"\7}\2\2\u048a\u048f\5\u0090I\2\u048b\u048c\7{\2\2\u048c\u048e\5\u0090"+
"I\2\u048d\u048b\3\2\2\2\u048e\u0491\3\2\2\2\u048f\u048d\3\2\2\2\u048f"+
"\u0490\3\2\2\2\u0490\u0492\3\2\2\2\u0491\u048f\3\2\2\2\u0492\u0493\7~"+
"\2\2\u0493\u0496\3\2\2\2\u0494\u0496\5\u0090I\2\u0495\u0489\3\2\2\2\u0495"+
"\u0494\3\2\2\2\u0496\u0097\3\2\2\2\u0497\u0498\7g\2\2\u0498\u049b\7}\2"+
"\2\u0499\u049c\5^\60\2\u049a\u049c\5\u00a8U\2\u049b\u0499\3\2\2\2\u049b"+
"\u049a\3\2\2\2\u049c\u049d\3\2\2\2\u049d\u049e\7~\2\2\u049e\u0099\3\2"+
"\2\2\u049f\u04a0\7m\2\2\u04a0\u04a1\5\u0090I\2\u04a1\u04a2\7`\2\2\u04a2"+
"\u04a3\5\u0090I\2\u04a3\u009b\3\2\2\2\u04a4\u04a5\7m\2\2\u04a5\u04a6\5"+
"\u0092J\2\u04a6\u04a7\7`\2\2\u04a7\u04a8\5\u0090I\2\u04a8\u009d\3\2\2"+
"\2\u04a9\u04b8\7\13\2\2\u04aa\u04b8\7\n\2\2\u04ab\u04b8\7\4\2\2\u04ac"+
"\u04b8\7\6\2\2\u04ad\u04b8\7\5\2\2\u04ae\u04b8\7\7\2\2\u04af\u04b8\7\b"+
"\2\2\u04b0\u04b8\7\t\2\2\u04b1\u04b8\7H\2\2\u04b2\u04b8\7f\2\2\u04b3\u04b8"+
"\7+\2\2\u04b4\u04b8\5\u00a0Q\2\u04b5\u04b8\5\u00a2R\2\u04b6\u04b8\5\u00a4"+
"S\2\u04b7\u04a9\3\2\2\2\u04b7\u04aa\3\2\2\2\u04b7\u04ab\3\2\2\2\u04b7"+
"\u04ac\3\2\2\2\u04b7\u04ad\3\2\2\2\u04b7\u04ae\3\2\2\2\u04b7\u04af\3\2"+
"\2\2\u04b7\u04b0\3\2\2\2\u04b7\u04b1\3\2\2\2\u04b7\u04b2\3\2\2\2\u04b7"+
"\u04b3\3\2\2\2\u04b7\u04b4\3\2\2\2\u04b7\u04b5\3\2\2\2\u04b7\u04b6\3\2"+
"\2\2\u04b8\u009f\3\2\2\2\u04b9\u04ba\7q\2\2\u04ba\u04bb\5\u00a6T\2\u04bb"+
"\u04bc\7t\2\2\u04bc\u00a1\3\2\2\2\u04bd\u04be\7r\2\2\u04be\u04bf\5\u00a6"+
"T\2\u04bf\u04c0\7t\2\2\u04c0\u00a3\3\2\2\2\u04c1\u04c2\7s\2\2\u04c2\u04c3"+
"\5\u00a6T\2\u04c3\u04c4\7t\2\2\u04c4\u00a5\3\2\2\2\u04c5\u04c6\t\r\2\2"+
"\u04c6\u00a7\3\2\2\2\u04c7\u04c8\7\u0086\2\2\u04c8\u04cc\5\u00b0Y\2\u04c9"+
"\u04ca\7\u0088\2\2\u04ca\u04cc\7\4\2\2\u04cb\u04c7\3\2\2\2\u04cb\u04c9"+
"\3\2\2\2\u04cc\u00a9\3\2\2\2\u04cd\u04ce\7e\2\2\u04ce\u04d0\7}\2\2\u04cf"+
"\u04d1\5\u00acW\2\u04d0\u04cf\3\2\2\2\u04d0\u04d1\3\2\2\2\u04d1\u04d3"+
"\3\2\2\2\u04d2\u04d4\5\u00aeX\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2"+
"\2\u04d4\u04d6\3\2\2\2\u04d5\u04d7\7\60\2\2\u04d6\u04d5\3\2\2\2\u04d6"+
"\u04d7\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04d9\5\u0090I\2\u04d9\u04da"+
"\7~\2\2\u04da\u051d\3\2\2\2\u04db\u04de\t\13\2\2\u04dc\u04dd\7}\2\2\u04dd"+
"\u04df\7~\2\2\u04de\u04dc\3\2\2\2\u04de\u04df\3\2\2\2\u04df\u051d\3\2"+
"\2\2\u04e0\u04e1\7\31\2\2\u04e1\u04e7\7}\2\2\u04e2\u04e4\7\"\2\2\u04e3"+
"\u04e2\3\2\2\2\u04e3\u04e4\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5\u04e8\5\u0090"+
"I\2\u04e6\u04e8\7\u0083\2\2\u04e7\u04e3\3\2\2\2\u04e7\u04e6\3\2\2\2\u04e8"+
"\u04e9\3\2\2\2\u04e9\u04ef\7~\2\2\u04ea\u04eb\7-\2\2\u04eb\u04ec\7}\2"+
"\2\u04ec\u04ed\5\u008eH\2\u04ed\u04ee\7~\2\2\u04ee\u04f0\3\2\2\2\u04ef"+
"\u04ea\3\2\2\2\u04ef\u04f0\3\2\2\2\u04f0\u04f9\3\2\2\2\u04f1\u04f7\7S"+
"\2\2\u04f2\u04f8\5\u00b0Y\2\u04f3\u04f4\7}\2\2\u04f4\u04f5\5v<\2\u04f5"+
"\u04f6\7~\2\2\u04f6\u04f8\3\2\2\2\u04f7\u04f2\3\2\2\2\u04f7\u04f3\3\2"+
"\2\2\u04f8\u04fa\3\2\2\2\u04f9\u04f1\3\2\2\2\u04f9\u04fa\3\2\2\2\u04fa"+
"\u051d\3\2\2\2\u04fb\u04fc\5\u00b0Y\2\u04fc\u04fe\7}\2\2\u04fd\u04ff\7"+
"\"\2\2\u04fe\u04fd\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0508\3\2\2\2\u0500"+
"\u0505\5\u0090I\2\u0501\u0502\7{\2\2\u0502\u0504\5\u0090I\2\u0503\u0501"+
"\3\2\2\2\u0504\u0507\3\2\2\2\u0505\u0503\3\2\2\2\u0505\u0506\3\2\2\2\u0506"+
"\u0509\3\2\2\2\u0507\u0505\3\2\2\2\u0508\u0500\3\2\2\2\u0508\u0509\3\2"+
"\2\2\u0509\u050a\3\2\2\2\u050a\u0510\7~\2\2\u050b\u050c\7-\2\2\u050c\u050d"+
"\7}\2\2\u050d\u050e\5\u008eH\2\u050e\u050f\7~\2\2\u050f\u0511\3\2\2\2"+
"\u0510\u050b\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u051a\3\2\2\2\u0512\u0518"+
"\7S\2\2\u0513\u0519\5\u00b0Y\2\u0514\u0515\7}\2\2\u0515\u0516\5v<\2\u0516"+
"\u0517\7~\2\2\u0517\u0519\3\2\2\2\u0518\u0513\3\2\2\2\u0518\u0514\3\2"+
"\2\2\u0519\u051b\3\2\2\2\u051a\u0512\3\2\2\2\u051a\u051b\3\2\2\2\u051b"+
"\u051d\3\2\2\2\u051c\u04cd\3\2\2\2\u051c\u04db\3\2\2\2\u051c\u04e0\3\2"+
"\2\2\u051c\u04fb\3\2\2\2\u051d\u00ab\3\2\2\2\u051e\u051f\t\16\2\2\u051f"+
"\u00ad\3\2\2\2\u0520\u0521\t\r\2\2\u0521\u00af\3\2\2\2\u0522\u0523\t\17"+
"\2\2\u0523\u00b1\3\2\2\2\u00a7\u00b4\u00b7\u00c8\u00d3\u00d9\u00e5\u00f2"+
"\u00fa\u00fe\u0106\u010a\u010f\u0112\u0115\u0118\u011c\u011f\u0122\u0127"+
"\u012a\u012e\u0135\u0138\u013b\u013e\u0142\u0149\u014c\u0159\u015d\u0160"+
"\u0169\u016e\u017b\u0183\u018e\u0192\u0196\u0199\u019c\u019f\u01a2\u01a6"+
"\u01a9\u01ac\u01af\u01b2\u01ba\u01c3\u01ca\u01cc\u01d3\u01d5\u01da\u01eb"+
"\u01f7\u0204\u020f\u0211\u0219\u0223\u022f\u0234\u0238\u023e\u0242\u024c"+
"\u024f\u0252\u0255\u0258\u025a\u0261\u0268\u026d\u0274\u0279\u0281\u0286"+
"\u0295\u02a4\u02a7\u02b0\u02b3\u02bb\u02d0\u02d7\u02e0\u02e2\u02eb\u02fa"+
"\u0300\u0305\u0307\u0318\u031c\u031f\u0322\u0325\u032e\u0334\u033c\u033e"+
"\u034a\u0358\u0364\u0370\u0374\u037f\u0384\u0388\u038f\u03a3\u03a7\u03af"+
"\u03b3\u03bd\u03d1\u03d3\u03de\u03e6\u03eb\u03f2\u03f9\u0400\u0405\u040c"+
"\u0411\u0418\u041d\u0424\u0429\u0430\u0435\u043c\u0458\u045f\u0468\u046e"+
"\u0472\u0478\u0480\u0482\u0487\u048f\u0495\u049b\u04b7\u04cb\u04d0\u04d3"+
"\u04d6\u04de\u04e3\u04e7\u04ef\u04f7\u04f9\u04fe\u0505\u0508\u0510\u0518"+
"\u051a\u051c";
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);
}
}
}
