@webda/ql 4.0.0-beta.1

package/lib/WebdaQLParserParser.js

@@ -0,0 +1,1807 @@
+// 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);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBooleanAtom) {
+            return visitor.visitBooleanAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export 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);
+        }
+    }
+}
+export 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);
+        }
+    }
+}
+export class AtomContext extends ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return WebdaQLParserParser.RULE_atom;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+export 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);
+        }
+    }
+}
+export 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);
+        }
+    }
+}
+export class IdentifierContext extends 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);
+        }
+    }
+}
+export class BooleanLiteralContext extends 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);
+        }
+    }
+}
+export class StringLiteralContext extends 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);
+        }
+    }
+}
+export class IntegerLiteralContext extends 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);
+        }
+    }
+}
+export class SetExpressionContext extends 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);
+        }
+    }
+}
+//# sourceMappingURL=WebdaQLParserParser.js.map