@webda/core
Version:
Expose API with Lambda
1,472 lines • 58.7 kB
JavaScript
// Generated from src/stores/webdaql/WebdaQLParser.g4 by ANTLR 4.9.0-SNAPSHOT
import { ATN } from "antlr4ts/atn/ATN.js";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer.js";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator.js";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException.js";
import { NoViableAltException } from "antlr4ts/NoViableAltException.js";
import { Parser } from "antlr4ts/Parser.js";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext.js";
import { RecognitionException } from "antlr4ts/RecognitionException.js";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { Token } from "antlr4ts/Token.js";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl.js";
import * as Utils from "antlr4ts/misc/Utils.js";
export class WebdaQLParserParser extends Parser {
// @Override
// @NotNull
get vocabulary() {
return WebdaQLParserParser.VOCABULARY;
}
// tslint:enable:no-trailing-whitespace
// @Override
get grammarFileName() {
return "WebdaQLParser.g4";
}
// @Override
get ruleNames() {
return WebdaQLParserParser.ruleNames;
}
// @Override
get serializedATN() {
return WebdaQLParserParser._serializedATN;
}
createFailedPredicateException(predicate, message) {
return new FailedPredicateException(this, predicate, message);
}
constructor(input) {
super(input);
this._interp = new ParserATNSimulator(WebdaQLParserParser._ATN, this);
}
// @RuleVersion(0)
webdaql() {
let _localctx = new WebdaqlContext(this._ctx, this.state);
this.enterRule(_localctx, 0, WebdaQLParserParser.RULE_webdaql);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 27;
this._errHandler.sync(this);
_la = this._input.LA(1);
if ((_la & ~0x1f) === 0 &&
((1 << _la) &
((1 << WebdaQLParserParser.LR_BRACKET) |
(1 << WebdaQLParserParser.TRUE) |
(1 << WebdaQLParserParser.FALSE) |
(1 << WebdaQLParserParser.DQUOTED_STRING_LITERAL) |
(1 << WebdaQLParserParser.SQUOTED_STRING_LITERAL) |
(1 << WebdaQLParserParser.INTEGER_LITERAL) |
(1 << WebdaQLParserParser.IDENTIFIER) |
(1 << WebdaQLParserParser.IDENTIFIER_WITH_NUMBER))) !==
0) {
{
this.state = 26;
this.expression(0);
}
}
this.state = 30;
this._errHandler.sync(this);
_la = this._input.LA(1);
if (_la === WebdaQLParserParser.ORDER_BY) {
{
this.state = 29;
this.orderExpression();
}
}
this.state = 33;
this._errHandler.sync(this);
_la = this._input.LA(1);
if (_la === WebdaQLParserParser.LIMIT) {
{
this.state = 32;
this.limitExpression();
}
}
this.state = 36;
this._errHandler.sync(this);
_la = this._input.LA(1);
if (_la === WebdaQLParserParser.OFFSET) {
{
this.state = 35;
this.offsetExpression();
}
}
this.state = 38;
this.match(WebdaQLParserParser.EOF);
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
limitExpression() {
let _localctx = new LimitExpressionContext(this._ctx, this.state);
this.enterRule(_localctx, 2, WebdaQLParserParser.RULE_limitExpression);
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 40;
this.match(WebdaQLParserParser.LIMIT);
this.state = 41;
this.integerLiteral();
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
offsetExpression() {
let _localctx = new OffsetExpressionContext(this._ctx, this.state);
this.enterRule(_localctx, 4, WebdaQLParserParser.RULE_offsetExpression);
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 43;
this.match(WebdaQLParserParser.OFFSET);
this.state = 44;
this.stringLiteral();
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
orderFieldExpression() {
let _localctx = new OrderFieldExpressionContext(this._ctx, this.state);
this.enterRule(_localctx, 6, WebdaQLParserParser.RULE_orderFieldExpression);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 46;
this.identifier();
this.state = 48;
this._errHandler.sync(this);
_la = this._input.LA(1);
if (_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC) {
{
this.state = 47;
_la = this._input.LA(1);
if (!(_la === WebdaQLParserParser.ASC || _la === WebdaQLParserParser.DESC)) {
this._errHandler.recoverInline(this);
}
else {
if (this._input.LA(1) === Token.EOF) {
this.matchedEOF = true;
}
this._errHandler.reportMatch(this);
this.consume();
}
}
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
orderExpression() {
let _localctx = new OrderExpressionContext(this._ctx, this.state);
this.enterRule(_localctx, 8, WebdaQLParserParser.RULE_orderExpression);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 50;
this.match(WebdaQLParserParser.ORDER_BY);
this.state = 51;
this.orderFieldExpression();
this.state = 56;
this._errHandler.sync(this);
_la = this._input.LA(1);
while (_la === WebdaQLParserParser.COMMA) {
{
{
this.state = 52;
this.match(WebdaQLParserParser.COMMA);
this.state = 53;
this.orderFieldExpression();
}
}
this.state = 58;
this._errHandler.sync(this);
_la = this._input.LA(1);
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
expression(_p) {
if (_p === undefined) {
_p = 0;
}
let _parentctx = this._ctx;
let _parentState = this.state;
let _localctx = new ExpressionContext(this._ctx, _parentState);
let _prevctx = _localctx;
let _startState = 10;
this.enterRecursionRule(_localctx, 10, WebdaQLParserParser.RULE_expression, _p);
let _la;
try {
let _alt;
this.enterOuterAlt(_localctx, 1);
{
this.state = 81;
this._errHandler.sync(this);
switch (this.interpreter.adaptivePredict(this._input, 6, this._ctx)) {
case 1:
{
_localctx = new LikeExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 60;
this.identifier();
this.state = 61;
this.match(WebdaQLParserParser.LIKE);
this.state = 62;
this.stringLiteral();
}
break;
case 2:
{
_localctx = new InExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 64;
this.identifier();
this.state = 65;
this.match(WebdaQLParserParser.IN);
this.state = 66;
this.setExpression();
}
break;
case 3:
{
_localctx = new ContainsExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 68;
this.identifier();
this.state = 69;
this.match(WebdaQLParserParser.CONTAINS);
this.state = 70;
this.stringLiteral();
}
break;
case 4:
{
_localctx = new BinaryComparisonExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 72;
this.identifier();
this.state = 73;
_la = this._input.LA(1);
if (!((_la & ~0x1f) === 0 &&
((1 << _la) &
((1 << WebdaQLParserParser.EQUAL) |
(1 << WebdaQLParserParser.NOT_EQUAL) |
(1 << WebdaQLParserParser.GREATER) |
(1 << WebdaQLParserParser.GREATER_OR_EQUAL) |
(1 << WebdaQLParserParser.LESS) |
(1 << WebdaQLParserParser.LESS_OR_EQUAL))) !==
0)) {
this._errHandler.recoverInline(this);
}
else {
if (this._input.LA(1) === Token.EOF) {
this.matchedEOF = true;
}
this._errHandler.reportMatch(this);
this.consume();
}
this.state = 74;
this.values();
}
break;
case 5:
{
_localctx = new SubExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 76;
this.match(WebdaQLParserParser.LR_BRACKET);
this.state = 77;
this.expression(0);
this.state = 78;
this.match(WebdaQLParserParser.RR_BRACKET);
}
break;
case 6:
{
_localctx = new AtomExpressionContext(_localctx);
this._ctx = _localctx;
_prevctx = _localctx;
this.state = 80;
this.atom();
}
break;
}
this._ctx._stop = this._input.tryLT(-1);
this.state = 91;
this._errHandler.sync(this);
_alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
if (_alt === 1) {
if (this._parseListeners != null) {
this.triggerExitRuleEvent();
}
_prevctx = _localctx;
{
this.state = 89;
this._errHandler.sync(this);
switch (this.interpreter.adaptivePredict(this._input, 7, this._ctx)) {
case 1:
{
_localctx = new AndLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
this.state = 83;
if (!this.precpred(this._ctx, 4)) {
throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
}
this.state = 84;
this.match(WebdaQLParserParser.AND);
this.state = 85;
this.expression(5);
}
break;
case 2:
{
_localctx = new OrLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
this.state = 86;
if (!this.precpred(this._ctx, 3)) {
throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
}
this.state = 87;
this.match(WebdaQLParserParser.OR);
this.state = 88;
this.expression(4);
}
break;
}
}
}
this.state = 93;
this._errHandler.sync(this);
_alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.unrollRecursionContexts(_parentctx);
}
return _localctx;
}
// @RuleVersion(0)
values() {
let _localctx = new ValuesContext(this._ctx, this.state);
this.enterRule(_localctx, 12, WebdaQLParserParser.RULE_values);
try {
this.state = 97;
this._errHandler.sync(this);
switch (this._input.LA(1)) {
case WebdaQLParserParser.TRUE:
case WebdaQLParserParser.FALSE:
_localctx = new BooleanAtomContext(_localctx);
this.enterOuterAlt(_localctx, 1);
{
this.state = 94;
this.booleanLiteral();
}
break;
case WebdaQLParserParser.INTEGER_LITERAL:
_localctx = new IntegerAtomContext(_localctx);
this.enterOuterAlt(_localctx, 2);
{
this.state = 95;
this.integerLiteral();
}
break;
case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
_localctx = new StringAtomContext(_localctx);
this.enterOuterAlt(_localctx, 3);
{
this.state = 96;
this.stringLiteral();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
atom() {
let _localctx = new AtomContext(this._ctx, this.state);
this.enterRule(_localctx, 14, WebdaQLParserParser.RULE_atom);
try {
this.state = 101;
this._errHandler.sync(this);
switch (this._input.LA(1)) {
case WebdaQLParserParser.TRUE:
case WebdaQLParserParser.FALSE:
case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
case WebdaQLParserParser.INTEGER_LITERAL:
_localctx = new ValuesAtomContext(_localctx);
this.enterOuterAlt(_localctx, 1);
{
this.state = 99;
this.values();
}
break;
case WebdaQLParserParser.IDENTIFIER:
case WebdaQLParserParser.IDENTIFIER_WITH_NUMBER:
_localctx = new IdentifierAtomContext(_localctx);
this.enterOuterAlt(_localctx, 2);
{
this.state = 100;
this.identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
identifier() {
let _localctx = new IdentifierContext(this._ctx, this.state);
this.enterRule(_localctx, 16, WebdaQLParserParser.RULE_identifier);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 103;
_la = this._input.LA(1);
if (!(_la === WebdaQLParserParser.IDENTIFIER || _la === WebdaQLParserParser.IDENTIFIER_WITH_NUMBER)) {
this._errHandler.recoverInline(this);
}
else {
if (this._input.LA(1) === Token.EOF) {
this.matchedEOF = true;
}
this._errHandler.reportMatch(this);
this.consume();
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
booleanLiteral() {
let _localctx = new BooleanLiteralContext(this._ctx, this.state);
this.enterRule(_localctx, 18, WebdaQLParserParser.RULE_booleanLiteral);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 105;
_la = this._input.LA(1);
if (!(_la === WebdaQLParserParser.TRUE || _la === WebdaQLParserParser.FALSE)) {
this._errHandler.recoverInline(this);
}
else {
if (this._input.LA(1) === Token.EOF) {
this.matchedEOF = true;
}
this._errHandler.reportMatch(this);
this.consume();
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
stringLiteral() {
let _localctx = new StringLiteralContext(this._ctx, this.state);
this.enterRule(_localctx, 20, WebdaQLParserParser.RULE_stringLiteral);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 107;
_la = this._input.LA(1);
if (!(_la === WebdaQLParserParser.DQUOTED_STRING_LITERAL || _la === WebdaQLParserParser.SQUOTED_STRING_LITERAL)) {
this._errHandler.recoverInline(this);
}
else {
if (this._input.LA(1) === Token.EOF) {
this.matchedEOF = true;
}
this._errHandler.reportMatch(this);
this.consume();
}
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
integerLiteral() {
let _localctx = new IntegerLiteralContext(this._ctx, this.state);
this.enterRule(_localctx, 22, WebdaQLParserParser.RULE_integerLiteral);
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 109;
this.match(WebdaQLParserParser.INTEGER_LITERAL);
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
// @RuleVersion(0)
setExpression() {
let _localctx = new SetExpressionContext(this._ctx, this.state);
this.enterRule(_localctx, 24, WebdaQLParserParser.RULE_setExpression);
let _la;
try {
this.enterOuterAlt(_localctx, 1);
{
this.state = 111;
this.match(WebdaQLParserParser.LR_SQ_BRACKET);
this.state = 112;
this.values();
this.state = 117;
this._errHandler.sync(this);
_la = this._input.LA(1);
while (_la === WebdaQLParserParser.COMMA) {
{
{
this.state = 113;
this.match(WebdaQLParserParser.COMMA);
this.state = 114;
this.values();
}
}
this.state = 119;
this._errHandler.sync(this);
_la = this._input.LA(1);
}
this.state = 120;
this.match(WebdaQLParserParser.RR_SQ_BRACKET);
}
}
catch (re) {
if (re instanceof RecognitionException) {
_localctx.exception = re;
this._errHandler.reportError(this, re);
this._errHandler.recover(this, re);
}
else {
throw re;
}
}
finally {
this.exitRule();
}
return _localctx;
}
sempred(_localctx, ruleIndex, predIndex) {
switch (ruleIndex) {
case 5:
return this.expression_sempred(_localctx, predIndex);
}
return true;
}
expression_sempred(_localctx, predIndex) {
switch (predIndex) {
case 0:
return this.precpred(this._ctx, 4);
case 1:
return this.precpred(this._ctx, 3);
}
return true;
}
static get _ATN() {
if (!WebdaQLParserParser.__ATN) {
WebdaQLParserParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(WebdaQLParserParser._serializedATN));
}
return WebdaQLParserParser.__ATN;
}
}
WebdaQLParserParser.SPACE = 1;
WebdaQLParserParser.LR_BRACKET = 2;
WebdaQLParserParser.RR_BRACKET = 3;
WebdaQLParserParser.COMMA = 4;
WebdaQLParserParser.SINGLE_QUOTE_SYMB = 5;
WebdaQLParserParser.DOUBLE_QUOTE_SYMB = 6;
WebdaQLParserParser.LR_SQ_BRACKET = 7;
WebdaQLParserParser.RR_SQ_BRACKET = 8;
WebdaQLParserParser.AND = 9;
WebdaQLParserParser.OR = 10;
WebdaQLParserParser.EQUAL = 11;
WebdaQLParserParser.NOT_EQUAL = 12;
WebdaQLParserParser.GREATER = 13;
WebdaQLParserParser.GREATER_OR_EQUAL = 14;
WebdaQLParserParser.LESS = 15;
WebdaQLParserParser.LESS_OR_EQUAL = 16;
WebdaQLParserParser.LIKE = 17;
WebdaQLParserParser.IN = 18;
WebdaQLParserParser.CONTAINS = 19;
WebdaQLParserParser.TRUE = 20;
WebdaQLParserParser.FALSE = 21;
WebdaQLParserParser.LIMIT = 22;
WebdaQLParserParser.OFFSET = 23;
WebdaQLParserParser.ORDER_BY = 24;
WebdaQLParserParser.ASC = 25;
WebdaQLParserParser.DESC = 26;
WebdaQLParserParser.DQUOTED_STRING_LITERAL = 27;
WebdaQLParserParser.SQUOTED_STRING_LITERAL = 28;
WebdaQLParserParser.INTEGER_LITERAL = 29;
WebdaQLParserParser.IDENTIFIER = 30;
WebdaQLParserParser.IDENTIFIER_WITH_NUMBER = 31;
WebdaQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 32;
WebdaQLParserParser.RULE_webdaql = 0;
WebdaQLParserParser.RULE_limitExpression = 1;
WebdaQLParserParser.RULE_offsetExpression = 2;
WebdaQLParserParser.RULE_orderFieldExpression = 3;
WebdaQLParserParser.RULE_orderExpression = 4;
WebdaQLParserParser.RULE_expression = 5;
WebdaQLParserParser.RULE_values = 6;
WebdaQLParserParser.RULE_atom = 7;
WebdaQLParserParser.RULE_identifier = 8;
WebdaQLParserParser.RULE_booleanLiteral = 9;
WebdaQLParserParser.RULE_stringLiteral = 10;
WebdaQLParserParser.RULE_integerLiteral = 11;
WebdaQLParserParser.RULE_setExpression = 12;
// tslint:disable:no-trailing-whitespace
WebdaQLParserParser.ruleNames = [
"webdaql",
"limitExpression",
"offsetExpression",
"orderFieldExpression",
"orderExpression",
"expression",
"values",
"atom",
"identifier",
"booleanLiteral",
"stringLiteral",
"integerLiteral",
"setExpression"
];
WebdaQLParserParser._LITERAL_NAMES = [
undefined,
undefined,
"'('",
"')'",
"','",
"'''",
"'\"'",
"'['",
"']'",
"'AND'",
"'OR'",
"'='",
"'!='",
"'>'",
"'>='",
"'<'",
"'<='",
"'LIKE'",
"'IN'",
"'CONTAINS'",
"'TRUE'",
"'FALSE'",
"'LIMIT'",
"'OFFSET'",
"'ORDER BY'",
"'ASC'",
"'DESC'"
];
WebdaQLParserParser._SYMBOLIC_NAMES = [
undefined,
"SPACE",
"LR_BRACKET",
"RR_BRACKET",
"COMMA",
"SINGLE_QUOTE_SYMB",
"DOUBLE_QUOTE_SYMB",
"LR_SQ_BRACKET",
"RR_SQ_BRACKET",
"AND",
"OR",
"EQUAL",
"NOT_EQUAL",
"GREATER",
"GREATER_OR_EQUAL",
"LESS",
"LESS_OR_EQUAL",
"LIKE",
"IN",
"CONTAINS",
"TRUE",
"FALSE",
"LIMIT",
"OFFSET",
"ORDER_BY",
"ASC",
"DESC",
"DQUOTED_STRING_LITERAL",
"SQUOTED_STRING_LITERAL",
"INTEGER_LITERAL",
"IDENTIFIER",
"IDENTIFIER_WITH_NUMBER",
"FUNCTION_IDENTIFIER_WITH_UNDERSCORE"
];
WebdaQLParserParser.VOCABULARY = new VocabularyImpl(WebdaQLParserParser._LITERAL_NAMES, WebdaQLParserParser._SYMBOLIC_NAMES, []);
WebdaQLParserParser._serializedATN = '\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03"}\x04\x02\t' +
"\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07\t" +
"\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04\x0E" +
"\t\x0E\x03\x02\x05\x02\x1E\n\x02\x03\x02\x05\x02!\n\x02\x03\x02\x05\x02" +
"$\n\x02\x03\x02\x05\x02'\n\x02\x03\x02\x03\x02\x03\x03\x03\x03\x03\x03" +
"\x03\x04\x03\x04\x03\x04\x03\x05\x03\x05\x05\x053\n\x05\x03\x06\x03\x06" +
"\x03\x06\x03\x06\x07\x069\n\x06\f\x06\x0E\x06<\v\x06\x03\x07\x03\x07\x03" +
"\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03" +
"\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03" +
"\x07\x03\x07\x05\x07T\n\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03" +
"\x07\x07\x07\\\n\x07\f\x07\x0E\x07_\v\x07\x03\b\x03\b\x03\b\x05\bd\n\b" +
"\x03\t\x03\t\x05\th\n\t\x03\n\x03\n\x03\v\x03\v\x03\f\x03\f\x03\r\x03" +
"\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x07\x0Ev\n\x0E\f\x0E\x0E\x0Ey\v\x0E" +
"\x03\x0E\x03\x0E\x03\x0E\x02\x02\x03\f\x0F\x02\x02\x04\x02\x06\x02\b\x02" +
"\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x02" +
"\x07\x03\x02\x1B\x1C\x03\x02\r\x12\x03\x02 !\x03\x02\x16\x17\x03\x02\x1D" +
"\x1E\x02\x80\x02\x1D\x03\x02\x02\x02\x04*\x03\x02\x02\x02\x06-\x03\x02" +
"\x02\x02\b0\x03\x02\x02\x02\n4\x03\x02\x02\x02\fS\x03\x02\x02\x02\x0E" +
"c\x03\x02\x02\x02\x10g\x03\x02\x02\x02\x12i\x03\x02\x02\x02\x14k\x03\x02" +
"\x02\x02\x16m\x03\x02\x02\x02\x18o\x03\x02\x02\x02\x1Aq\x03\x02\x02\x02" +
"\x1C\x1E\x05\f\x07\x02\x1D\x1C\x03\x02\x02\x02\x1D\x1E\x03\x02\x02\x02" +
"\x1E \x03\x02\x02\x02\x1F!\x05\n\x06\x02 \x1F\x03\x02\x02\x02 !\x03\x02" +
'\x02\x02!#\x03\x02\x02\x02"$\x05\x04\x03\x02#"\x03\x02\x02\x02#$\x03' +
"\x02\x02\x02$&\x03\x02\x02\x02%'\x05\x06\x04\x02&%\x03\x02\x02\x02&'" +
"\x03\x02\x02\x02'(\x03\x02\x02\x02()\x07\x02\x02\x03)\x03\x03\x02\x02" +
"\x02*+\x07\x18\x02\x02+,\x05\x18\r\x02,\x05\x03\x02\x02\x02-.\x07\x19" +
"\x02\x02./\x05\x16\f\x02/\x07\x03\x02\x02\x0202\x05\x12\n\x0213\t\x02" +
"\x02\x0221\x03\x02\x02\x0223\x03\x02\x02\x023\t\x03\x02\x02\x0245\x07" +
"\x1A\x02\x025:\x05\b\x05\x0267\x07\x06\x02\x0279\x05\b\x05\x0286\x03\x02" +
"\x02\x029<\x03\x02\x02\x02:8\x03\x02\x02\x02:;\x03\x02\x02\x02;\v\x03" +
"\x02\x02\x02<:\x03\x02\x02\x02=>\b\x07\x01\x02>?\x05\x12\n\x02?@\x07\x13" +
"\x02\x02@A\x05\x16\f\x02AT\x03\x02\x02\x02BC\x05\x12\n\x02CD\x07\x14\x02" +
"\x02DE\x05\x1A\x0E\x02ET\x03\x02\x02\x02FG\x05\x12\n\x02GH\x07\x15\x02" +
"\x02HI\x05\x16\f\x02IT\x03\x02\x02\x02JK\x05\x12\n\x02KL\t\x03\x02\x02" +
"LM\x05\x0E\b\x02MT\x03\x02\x02\x02NO\x07\x04\x02\x02OP\x05\f\x07\x02P" +
"Q\x07\x05\x02\x02QT\x03\x02\x02\x02RT\x05\x10\t\x02S=\x03\x02\x02\x02" +
"SB\x03\x02\x02\x02SF\x03\x02\x02\x02SJ\x03\x02\x02\x02SN\x03\x02\x02\x02" +
"SR\x03\x02\x02\x02T]\x03\x02\x02\x02UV\f\x06\x02\x02VW\x07\v\x02\x02W" +
"\\\x05\f\x07\x07XY\f\x05\x02\x02YZ\x07\f\x02\x02Z\\\x05\f\x07\x06[U\x03" +
"\x02\x02\x02[X\x03\x02\x02\x02\\_\x03\x02\x02\x02][\x03\x02\x02\x02]^" +
"\x03\x02\x02\x02^\r\x03\x02\x02\x02_]\x03\x02\x02\x02`d\x05\x14\v\x02" +
"ad\x05\x18\r\x02bd\x05\x16\f\x02c`\x03\x02\x02\x02ca\x03\x02\x02\x02c" +
"b\x03\x02\x02\x02d\x0F\x03\x02\x02\x02eh\x05\x0E\b\x02fh\x05\x12\n\x02" +
"ge\x03\x02\x02\x02gf\x03\x02\x02\x02h\x11\x03\x02\x02\x02ij\t\x04\x02" +
"\x02j\x13\x03\x02\x02\x02kl\t\x05\x02\x02l\x15\x03\x02\x02\x02mn\t\x06" +
"\x02\x02n\x17\x03\x02\x02\x02op\x07\x1F\x02\x02p\x19\x03\x02\x02\x02q" +
"r\x07\t\x02\x02rw\x05\x0E\b\x02st\x07\x06\x02\x02tv\x05\x0E\b\x02us\x03" +
"\x02\x02\x02vy\x03\x02\x02\x02wu\x03\x02\x02\x02wx\x03\x02\x02\x02xz\x03" +
"\x02\x02\x02yw\x03\x02\x02\x02z{\x07\n\x02\x02{\x1B\x03\x02\x02\x02\x0E" +
"\x1D #&2:S[]cgw";
export class WebdaqlContext extends ParserRuleContext {
EOF() {
return this.getToken(WebdaQLParserParser.EOF, 0);
}
expression() {
return this.tryGetRuleContext(0, ExpressionContext);
}
orderExpression() {
return this.tryGetRuleContext(0, OrderExpressionContext);
}
limitExpression() {
return this.tryGetRuleContext(0, LimitExpressionContext);
}
offsetExpression() {
return this.tryGetRuleContext(0, OffsetExpressionContext);
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_webdaql;
}
// @Override
enterRule(listener) {
if (listener.enterWebdaql) {
listener.enterWebdaql(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitWebdaql) {
listener.exitWebdaql(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitWebdaql) {
return visitor.visitWebdaql(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class LimitExpressionContext extends ParserRuleContext {
LIMIT() {
return this.getToken(WebdaQLParserParser.LIMIT, 0);
}
integerLiteral() {
return this.getRuleContext(0, IntegerLiteralContext);
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_limitExpression;
}
// @Override
enterRule(listener) {
if (listener.enterLimitExpression) {
listener.enterLimitExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitLimitExpression) {
listener.exitLimitExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitLimitExpression) {
return visitor.visitLimitExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class OffsetExpressionContext extends ParserRuleContext {
OFFSET() {
return this.getToken(WebdaQLParserParser.OFFSET, 0);
}
stringLiteral() {
return this.getRuleContext(0, StringLiteralContext);
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_offsetExpression;
}
// @Override
enterRule(listener) {
if (listener.enterOffsetExpression) {
listener.enterOffsetExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitOffsetExpression) {
listener.exitOffsetExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitOffsetExpression) {
return visitor.visitOffsetExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class OrderFieldExpressionContext extends ParserRuleContext {
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
ASC() {
return this.tryGetToken(WebdaQLParserParser.ASC, 0);
}
DESC() {
return this.tryGetToken(WebdaQLParserParser.DESC, 0);
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_orderFieldExpression;
}
// @Override
enterRule(listener) {
if (listener.enterOrderFieldExpression) {
listener.enterOrderFieldExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitOrderFieldExpression) {
listener.exitOrderFieldExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitOrderFieldExpression) {
return visitor.visitOrderFieldExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class OrderExpressionContext extends ParserRuleContext {
ORDER_BY() {
return this.getToken(WebdaQLParserParser.ORDER_BY, 0);
}
orderFieldExpression(i) {
if (i === undefined) {
return this.getRuleContexts(OrderFieldExpressionContext);
}
else {
return this.getRuleContext(i, OrderFieldExpressionContext);
}
}
COMMA(i) {
if (i === undefined) {
return this.getTokens(WebdaQLParserParser.COMMA);
}
else {
return this.getToken(WebdaQLParserParser.COMMA, i);
}
}
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_orderExpression;
}
// @Override
enterRule(listener) {
if (listener.enterOrderExpression) {
listener.enterOrderExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitOrderExpression) {
listener.exitOrderExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitOrderExpression) {
return visitor.visitOrderExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class ExpressionContext extends ParserRuleContext {
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_expression;
}
copyFrom(ctx) {
super.copyFrom(ctx);
}
}
export class LikeExpressionContext extends ExpressionContext {
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
LIKE() {
return this.getToken(WebdaQLParserParser.LIKE, 0);
}
stringLiteral() {
return this.getRuleContext(0, StringLiteralContext);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterLikeExpression) {
listener.enterLikeExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitLikeExpression) {
listener.exitLikeExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitLikeExpression) {
return visitor.visitLikeExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class InExpressionContext extends ExpressionContext {
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
IN() {
return this.getToken(WebdaQLParserParser.IN, 0);
}
setExpression() {
return this.getRuleContext(0, SetExpressionContext);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterInExpression) {
listener.enterInExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitInExpression) {
listener.exitInExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitInExpression) {
return visitor.visitInExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class ContainsExpressionContext extends ExpressionContext {
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
CONTAINS() {
return this.getToken(WebdaQLParserParser.CONTAINS, 0);
}
stringLiteral() {
return this.getRuleContext(0, StringLiteralContext);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterContainsExpression) {
listener.enterContainsExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitContainsExpression) {
listener.exitContainsExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitContainsExpression) {
return visitor.visitContainsExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class BinaryComparisonExpressionContext extends ExpressionContext {
identifier() {
return this.getRuleContext(0, IdentifierContext);
}
values() {
return this.getRuleContext(0, ValuesContext);
}
EQUAL() {
return this.tryGetToken(WebdaQLParserParser.EQUAL, 0);
}
NOT_EQUAL() {
return this.tryGetToken(WebdaQLParserParser.NOT_EQUAL, 0);
}
GREATER_OR_EQUAL() {
return this.tryGetToken(WebdaQLParserParser.GREATER_OR_EQUAL, 0);
}
LESS_OR_EQUAL() {
return this.tryGetToken(WebdaQLParserParser.LESS_OR_EQUAL, 0);
}
LESS() {
return this.tryGetToken(WebdaQLParserParser.LESS, 0);
}
GREATER() {
return this.tryGetToken(WebdaQLParserParser.GREATER, 0);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterBinaryComparisonExpression) {
listener.enterBinaryComparisonExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitBinaryComparisonExpression) {
listener.exitBinaryComparisonExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitBinaryComparisonExpression) {
return visitor.visitBinaryComparisonExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class AndLogicExpressionContext extends ExpressionContext {
expression(i) {
if (i === undefined) {
return this.getRuleContexts(ExpressionContext);
}
else {
return this.getRuleContext(i, ExpressionContext);
}
}
AND() {
return this.getToken(WebdaQLParserParser.AND, 0);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterAndLogicExpression) {
listener.enterAndLogicExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitAndLogicExpression) {
listener.exitAndLogicExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitAndLogicExpression) {
return visitor.visitAndLogicExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class OrLogicExpressionContext extends ExpressionContext {
expression(i) {
if (i === undefined) {
return this.getRuleContexts(ExpressionContext);
}
else {
return this.getRuleContext(i, ExpressionContext);
}
}
OR() {
return this.getToken(WebdaQLParserParser.OR, 0);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterOrLogicExpression) {
listener.enterOrLogicExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitOrLogicExpression) {
listener.exitOrLogicExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitOrLogicExpression) {
return visitor.visitOrLogicExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class SubExpressionContext extends ExpressionContext {
LR_BRACKET() {
return this.getToken(WebdaQLParserParser.LR_BRACKET, 0);
}
expression() {
return this.getRuleContext(0, ExpressionContext);
}
RR_BRACKET() {
return this.getToken(WebdaQLParserParser.RR_BRACKET, 0);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterSubExpression) {
listener.enterSubExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitSubExpression) {
listener.exitSubExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitSubExpression) {
return visitor.visitSubExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class AtomExpressionContext extends ExpressionContext {
atom() {
return this.getRuleContext(0, AtomContext);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterAtomExpression) {
listener.enterAtomExpression(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitAtomExpression) {
listener.exitAtomExpression(this);
}
}
// @Override
accept(visitor) {
if (visitor.visitAtomExpression) {
return visitor.visitAtomExpression(this);
}
else {
return visitor.visitChildren(this);
}
}
}
export class ValuesContext extends ParserRuleContext {
constructor(parent, invokingState) {
super(parent, invokingState);
}
// @Override
get ruleIndex() {
return WebdaQLParserParser.RULE_values;
}
copyFrom(ctx) {
super.copyFrom(ctx);
}
}
export class BooleanAtomContext extends ValuesContext {
booleanLiteral() {
return this.getRuleContext(0, BooleanLiteralContext);
}
constructor(ctx) {
super(ctx.parent, ctx.invokingState);
this.copyFrom(ctx);
}
// @Override
enterRule(listener) {
if (listener.enterBooleanAtom) {
listener.enterBooleanAtom(this);
}
}
// @Override
exitRule(listener) {
if (listener.exitBooleanAtom) {
listener.exitBooleanAtom(this);
}
}
// @Ove