@webda/core 1.6.0-beta.3 → 2.0.0-beta.2

package/lib/stores/webdaql/WebdaQLParserParser.js

@@ -0,0 +1,1781 @@
+"use strict";
+// Generated from src/stores/webdaql/WebdaQLParser.g4 by ANTLR 4.9.0-SNAPSHOT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetExpressionContext = exports.IntegerLiteralContext = exports.StringLiteralContext = exports.BooleanLiteralContext = exports.IdentifierContext = exports.IdentifierAtomContext = exports.ValuesAtomContext = exports.AtomContext = exports.StringAtomContext = exports.IntegerAtomContext = exports.BooleanAtomContext = exports.ValuesContext = exports.AtomExpressionContext = exports.SubExpressionContext = exports.OrLogicExpressionContext = exports.AndLogicExpressionContext = exports.BinaryComparisonExpressionContext = exports.InExpressionContext = exports.LikeExpressionContext = exports.ExpressionContext = exports.OrderExpressionContext = exports.OrderFieldExpressionContext = exports.OffsetExpressionContext = exports.LimitExpressionContext = exports.WebdaqlContext = exports.WebdaQLParserParser = void 0;
+const ATN_1 = require("antlr4ts/atn/ATN");
+const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
+const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
+const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
+const Utils = require("antlr4ts/misc/Utils");
+const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
+const Parser_1 = require("antlr4ts/Parser");
+const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
+const RecognitionException_1 = require("antlr4ts/RecognitionException");
+const Token_1 = require("antlr4ts/Token");
+const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
+class WebdaQLParserParser extends Parser_1.Parser {
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator_1.ParserATNSimulator(WebdaQLParserParser._ATN, this);
+    }
+    // @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_1.FailedPredicateException(this, predicate, message);
+    }
+    // @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_1.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_1.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_1.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_1.Token.EOF) {
+                                this.matchedEOF = true;
+                            }
+                            this._errHandler.reportMatch(this);
+                            this.consume();
+                        }
+                    }
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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_1.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 = 77;
+                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 BinaryComparisonExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 68;
+                            this.identifier();
+                            this.state = 69;
+                            _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_1.Token.EOF) {
+                                    this.matchedEOF = true;
+                                }
+                                this._errHandler.reportMatch(this);
+                                this.consume();
+                            }
+                            this.state = 70;
+                            this.values();
+                        }
+                        break;
+                    case 4:
+                        {
+                            _localctx = new SubExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 72;
+                            this.match(WebdaQLParserParser.LR_BRACKET);
+                            this.state = 73;
+                            this.expression(0);
+                            this.state = 74;
+                            this.match(WebdaQLParserParser.RR_BRACKET);
+                        }
+                        break;
+                    case 5:
+                        {
+                            _localctx = new AtomExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 76;
+                            this.atom();
+                        }
+                        break;
+                }
+                this._ctx._stop = this._input.tryLT(-1);
+                this.state = 87;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
+                while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        if (this._parseListeners != null) {
+                            this.triggerExitRuleEvent();
+                        }
+                        _prevctx = _localctx;
+                        {
+                            this.state = 85;
+                            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 = 79;
+                                        if (!this.precpred(this._ctx, 4)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
+                                        }
+                                        this.state = 80;
+                                        this.match(WebdaQLParserParser.AND);
+                                        this.state = 81;
+                                        this.expression(5);
+                                    }
+                                    break;
+                                case 2:
+                                    {
+                                        _localctx = new OrLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, WebdaQLParserParser.RULE_expression);
+                                        this.state = 82;
+                                        if (!this.precpred(this._ctx, 3)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
+                                        }
+                                        this.state = 83;
+                                        this.match(WebdaQLParserParser.OR);
+                                        this.state = 84;
+                                        this.expression(4);
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    this.state = 89;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 8, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 93;
+            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 = 90;
+                        this.booleanLiteral();
+                    }
+                    break;
+                case WebdaQLParserParser.INTEGER_LITERAL:
+                    _localctx = new IntegerAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 91;
+                        this.integerLiteral();
+                    }
+                    break;
+                case WebdaQLParserParser.DQUOTED_STRING_LITERAL:
+                case WebdaQLParserParser.SQUOTED_STRING_LITERAL:
+                    _localctx = new StringAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 92;
+                        this.stringLiteral();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 97;
+            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 = 95;
+                        this.values();
+                    }
+                    break;
+                case WebdaQLParserParser.IDENTIFIER:
+                case WebdaQLParserParser.IDENTIFIER_WITH_NUMBER:
+                    _localctx = new IdentifierAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 96;
+                        this.identifier();
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException_1.NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 99;
+                _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_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 101;
+                _la = this._input.LA(1);
+                if (!(_la === WebdaQLParserParser.TRUE || _la === WebdaQLParserParser.FALSE)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    if (this._input.LA(1) === Token_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 103;
+                _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_1.Token.EOF) {
+                        this.matchedEOF = true;
+                    }
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 105;
+                this.match(WebdaQLParserParser.INTEGER_LITERAL);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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 = 107;
+                this.match(WebdaQLParserParser.LR_SQ_BRACKET);
+                this.state = 108;
+                this.values();
+                this.state = 113;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === WebdaQLParserParser.COMMA) {
+                    {
+                        {
+                            this.state = 109;
+                            this.match(WebdaQLParserParser.COMMA);
+                            this.state = 110;
+                            this.values();
+                        }
+                    }
+                    this.state = 115;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 116;
+                this.match(WebdaQLParserParser.RR_SQ_BRACKET);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException_1.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_1.ATNDeserializer().deserialize(Utils.toCharArray(WebdaQLParserParser._serializedATN));
+        }
+        return WebdaQLParserParser.__ATN;
+    }
+}
+exports.WebdaQLParserParser = WebdaQLParserParser;
+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.TRUE = 19;
+WebdaQLParserParser.FALSE = 20;
+WebdaQLParserParser.LIMIT = 21;
+WebdaQLParserParser.OFFSET = 22;
+WebdaQLParserParser.ORDER_BY = 23;
+WebdaQLParserParser.ASC = 24;
+WebdaQLParserParser.DESC = 25;
+WebdaQLParserParser.DQUOTED_STRING_LITERAL = 26;
+WebdaQLParserParser.SQUOTED_STRING_LITERAL = 27;
+WebdaQLParserParser.INTEGER_LITERAL = 28;
+WebdaQLParserParser.IDENTIFIER = 29;
+WebdaQLParserParser.IDENTIFIER_WITH_NUMBER = 30;
+WebdaQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 31;
+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'",
+    "'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",
+    "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_1.VocabularyImpl(WebdaQLParserParser._LITERAL_NAMES, WebdaQLParserParser._SYMBOLIC_NAMES, []);
+WebdaQLParserParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03!y\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\x05\x07P\n\x07\x03" +
+    "\x07\x03\x07\x03\x07\x03\x07\x03\x07\x03\x07\x07\x07X\n\x07\f\x07\x0E" +
+    "\x07[\v\x07\x03\b\x03\b\x03\b\x05\b`\n\b\x03\t\x03\t\x05\td\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\x0Er\n\x0E\f\x0E\x0E\x0Eu\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\x1A\x1B\x03\x02\r" +
+    "\x12\x03\x02\x1F \x03\x02\x15\x16\x03\x02\x1C\x1D\x02{\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\fO\x03\x02\x02\x02\x0E_\x03\x02\x02\x02\x10c\x03\x02" +
+    "\x02\x02\x12e\x03\x02\x02\x02\x14g\x03\x02\x02\x02\x16i\x03\x02\x02\x02" +
+    "\x18k\x03\x02\x02\x02\x1Am\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\x17\x02\x02+,\x05\x18" +
+    "\r\x02,\x05\x03\x02\x02\x02-.\x07\x18\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\x19\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\x02AP\x03\x02\x02" +
+    "\x02BC\x05\x12\n\x02CD\x07\x14\x02\x02DE\x05\x1A\x0E\x02EP\x03\x02\x02" +
+    "\x02FG\x05\x12\n\x02GH\t\x03\x02\x02HI\x05\x0E\b\x02IP\x03\x02\x02\x02" +
+    "JK\x07\x04\x02\x02KL\x05\f\x07\x02LM\x07\x05\x02\x02MP\x03\x02\x02\x02" +
+    "NP\x05\x10\t\x02O=\x03\x02\x02\x02OB\x03\x02\x02\x02OF\x03\x02\x02\x02" +
+    "OJ\x03\x02\x02\x02ON\x03\x02\x02\x02PY\x03\x02\x02\x02QR\f\x06\x02\x02" +
+    "RS\x07\v\x02\x02SX\x05\f\x07\x07TU\f\x05\x02\x02UV\x07\f\x02\x02VX\x05" +
+    "\f\x07\x06WQ\x03\x02\x02\x02WT\x03\x02\x02\x02X[\x03\x02\x02\x02YW\x03" +
+    "\x02\x02\x02YZ\x03\x02\x02\x02Z\r\x03\x02\x02\x02[Y\x03\x02\x02\x02\\" +
+    "`\x05\x14\v\x02]`\x05\x18\r\x02^`\x05\x16\f\x02_\\\x03\x02\x02\x02_]\x03" +
+    "\x02\x02\x02_^\x03\x02\x02\x02`\x0F\x03\x02\x02\x02ad\x05\x0E\b\x02bd" +
+    "\x05\x12\n\x02ca\x03\x02\x02\x02cb\x03\x02\x02\x02d\x11\x03\x02\x02\x02" +
+    "ef\t\x04\x02\x02f\x13\x03\x02\x02\x02gh\t\x05\x02\x02h\x15\x03\x02\x02" +
+    "\x02ij\t\x06\x02\x02j\x17\x03\x02\x02\x02kl\x07\x1E\x02\x02l\x19\x03\x02" +
+    "\x02\x02mn\x07\t\x02\x02ns\x05\x0E\b\x02op\x07\x06\x02\x02pr\x05\x0E\b" +
+    "\x02qo\x03\x02\x02\x02ru\x03\x02\x02\x02sq\x03\x02\x02\x02st\x03\x02\x02" +
+    "\x02tv\x03\x02\x02\x02us\x03\x02\x02\x02vw\x07\n\x02\x02w\x1B\x03\x02" +
+    "\x02\x02\x0E\x1D #&2:OWY_cs";
+class WebdaqlContext extends ParserRuleContext_1.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);
+        }
+    }
+}
+exports.WebdaqlContext = WebdaqlContext;
+class LimitExpressionContext extends ParserRuleContext_1.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);
+        }
+    }
+}
+exports.LimitExpressionContext = LimitExpressionContext;
+class OffsetExpressionContext extends ParserRuleContext_1.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);
+        }
+    }
+}
+exports.OffsetExpressionContext = OffsetExpressionContext;
+class OrderFieldExpressionContext extends ParserRuleContext_1.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);
+        }
+    }
+}
+exports.OrderFieldExpressionContext = OrderFieldExpressionContext;
+class OrderExpressionContext extends ParserRuleContext_1.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);
+        }
+    }
+}
+exports.OrderExpressionContext = OrderExpressionContext;
+class ExpressionContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_expression;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.ExpressionContext = ExpressionContext;
+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);
+        }
+    }
+}
+exports.LikeExpressionContext = LikeExpressionContext;
+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);
+        }
+    }
+}
+exports.InExpressionContext = InExpressionContext;
+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);
+        }
+    }
+}
+exports.BinaryComparisonExpressionContext = BinaryComparisonExpressionContext;
+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);
+        }
+    }
+}
+exports.AndLogicExpressionContext = AndLogicExpressionContext;
+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);
+        }
+    }
+}
+exports.OrLogicExpressionContext = OrLogicExpressionContext;
+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);
+        }
+    }
+}
+exports.SubExpressionContext = SubExpressionContext;
+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);
+        }
+    }
+}
+exports.AtomExpressionContext = AtomExpressionContext;
+class ValuesContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_values;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.ValuesContext = ValuesContext;
+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);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBooleanAtom) {
+            return visitor.visitBooleanAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.BooleanAtomContext = BooleanAtomContext;
+class IntegerAtomContext extends ValuesContext {
+    integerLiteral() {
+        return this.getRuleContext(0, IntegerLiteralContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIntegerAtom) {
+            listener.enterIntegerAtom(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIntegerAtom) {
+            listener.exitIntegerAtom(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIntegerAtom) {
+            return visitor.visitIntegerAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IntegerAtomContext = IntegerAtomContext;
+class StringAtomContext extends ValuesContext {
+    stringLiteral() {
+        return this.getRuleContext(0, StringLiteralContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterStringAtom) {
+            listener.enterStringAtom(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitStringAtom) {
+            listener.exitStringAtom(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitStringAtom) {
+            return visitor.visitStringAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.StringAtomContext = StringAtomContext;
+class AtomContext extends ParserRuleContext_1.ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_atom;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+exports.AtomContext = AtomContext;
+class ValuesAtomContext extends AtomContext {
+    values() {
+        return this.getRuleContext(0, ValuesContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterValuesAtom) {
+            listener.enterValuesAtom(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitValuesAtom) {
+            listener.exitValuesAtom(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitValuesAtom) {
+            return visitor.visitValuesAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.ValuesAtomContext = ValuesAtomContext;
+class IdentifierAtomContext extends AtomContext {
+    identifier() {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIdentifierAtom) {
+            listener.enterIdentifierAtom(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIdentifierAtom) {
+            listener.exitIdentifierAtom(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIdentifierAtom) {
+            return visitor.visitIdentifierAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IdentifierAtomContext = IdentifierAtomContext;
+class IdentifierContext extends ParserRuleContext_1.ParserRuleContext {
+    IDENTIFIER() {
+        return this.tryGetToken(WebdaQLParserParser.IDENTIFIER, 0);
+    }
+    IDENTIFIER_WITH_NUMBER() {
+        return this.tryGetToken(WebdaQLParserParser.IDENTIFIER_WITH_NUMBER, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_identifier;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIdentifier) {
+            listener.enterIdentifier(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIdentifier) {
+            listener.exitIdentifier(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIdentifier) {
+            return visitor.visitIdentifier(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IdentifierContext = IdentifierContext;
+class BooleanLiteralContext extends ParserRuleContext_1.ParserRuleContext {
+    TRUE() {
+        return this.tryGetToken(WebdaQLParserParser.TRUE, 0);
+    }
+    FALSE() {
+        return this.tryGetToken(WebdaQLParserParser.FALSE, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_booleanLiteral;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterBooleanLiteral) {
+            listener.enterBooleanLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitBooleanLiteral) {
+            listener.exitBooleanLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBooleanLiteral) {
+            return visitor.visitBooleanLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.BooleanLiteralContext = BooleanLiteralContext;
+class StringLiteralContext extends ParserRuleContext_1.ParserRuleContext {
+    DQUOTED_STRING_LITERAL() {
+        return this.tryGetToken(WebdaQLParserParser.DQUOTED_STRING_LITERAL, 0);
+    }
+    SQUOTED_STRING_LITERAL() {
+        return this.tryGetToken(WebdaQLParserParser.SQUOTED_STRING_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_stringLiteral;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterStringLiteral) {
+            listener.enterStringLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitStringLiteral) {
+            listener.exitStringLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitStringLiteral) {
+            return visitor.visitStringLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.StringLiteralContext = StringLiteralContext;
+class IntegerLiteralContext extends ParserRuleContext_1.ParserRuleContext {
+    INTEGER_LITERAL() {
+        return this.getToken(WebdaQLParserParser.INTEGER_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_integerLiteral;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterIntegerLiteral) {
+            listener.enterIntegerLiteral(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitIntegerLiteral) {
+            listener.exitIntegerLiteral(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIntegerLiteral) {
+            return visitor.visitIntegerLiteral(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.IntegerLiteralContext = IntegerLiteralContext;
+class SetExpressionContext extends ParserRuleContext_1.ParserRuleContext {
+    LR_SQ_BRACKET() {
+        return this.getToken(WebdaQLParserParser.LR_SQ_BRACKET, 0);
+    }
+    values(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ValuesContext);
+        }
+        else {
+            return this.getRuleContext(i, ValuesContext);
+        }
+    }
+    RR_SQ_BRACKET() {
+        return this.getToken(WebdaQLParserParser.RR_SQ_BRACKET, 0);
+    }
+    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_setExpression;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterSetExpression) {
+            listener.enterSetExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitSetExpression) {
+            listener.exitSetExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitSetExpression) {
+            return visitor.visitSetExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+exports.SetExpressionContext = SetExpressionContext;
+//# sourceMappingURL=WebdaQLParserParser.js.map