@webda/cloudevents 3.0.0

package/lib/filters/sql/CESQLParserParser.js

@@ -0,0 +1,1825 @@
+// Generated from src/models/filters/sql/CESQLParser.g4 by ANTLR 4.9.0-SNAPSHOT
+import { ATN } from "antlr4ts/atn/ATN.js";
+import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer.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 { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator.js";
+import { RecognitionException } from "antlr4ts/RecognitionException.js";
+import { Token } from "antlr4ts/Token.js";
+import { VocabularyImpl } from "antlr4ts/VocabularyImpl.js";
+import * as Utils from "antlr4ts/misc/Utils.js";
+export class CESQLParserParser extends Parser {
+    // @Override
+    // @NotNull
+    get vocabulary() {
+        return CESQLParserParser.VOCABULARY;
+    }
+    // tslint:enable:no-trailing-whitespace
+    // @Override
+    get grammarFileName() {
+        return "CESQLParser.g4";
+    }
+    // @Override
+    get ruleNames() {
+        return CESQLParserParser.ruleNames;
+    }
+    // @Override
+    get serializedATN() {
+        return CESQLParserParser._serializedATN;
+    }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator(CESQLParserParser._ATN, this);
+    }
+    // @RuleVersion(0)
+    cesql() {
+        let _localctx = new CesqlContext(this._ctx, this.state);
+        this.enterRule(_localctx, 0, CESQLParserParser.RULE_cesql);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 20;
+                this.expression(0);
+                this.state = 21;
+                this.match(CESQLParserParser.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)
+    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 = 2;
+        this.enterRecursionRule(_localctx, 2, CESQLParserParser.RULE_expression, _p);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 38;
+                this._errHandler.sync(this);
+                switch (this.interpreter.adaptivePredict(this._input, 0, this._ctx)) {
+                    case 1:
+                        {
+                            _localctx = new FunctionInvocationExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 24;
+                            this.functionIdentifier();
+                            this.state = 25;
+                            this.functionParameterList();
+                        }
+                        break;
+                    case 2:
+                        {
+                            _localctx = new UnaryLogicExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 27;
+                            this.match(CESQLParserParser.NOT);
+                            this.state = 28;
+                            this.expression(11);
+                        }
+                        break;
+                    case 3:
+                        {
+                            _localctx = new UnaryNumericExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 29;
+                            this.match(CESQLParserParser.MINUS);
+                            this.state = 30;
+                            this.expression(10);
+                        }
+                        break;
+                    case 4:
+                        {
+                            _localctx = new ExistsExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 31;
+                            this.match(CESQLParserParser.EXISTS);
+                            this.state = 32;
+                            this.identifier();
+                        }
+                        break;
+                    case 5:
+                        {
+                            _localctx = new SubExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 33;
+                            this.match(CESQLParserParser.LR_BRACKET);
+                            this.state = 34;
+                            this.expression(0);
+                            this.state = 35;
+                            this.match(CESQLParserParser.RR_BRACKET);
+                        }
+                        break;
+                    case 6:
+                        {
+                            _localctx = new AtomExpressionContext(_localctx);
+                            this._ctx = _localctx;
+                            _prevctx = _localctx;
+                            this.state = 37;
+                            this.atom();
+                        }
+                        break;
+                }
+                this._ctx._stop = this._input.tryLT(-1);
+                this.state = 66;
+                this._errHandler.sync(this);
+                _alt = this.interpreter.adaptivePredict(this._input, 4, this._ctx);
+                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        if (this._parseListeners != null) {
+                            this.triggerExitRuleEvent();
+                        }
+                        _prevctx = _localctx;
+                        {
+                            this.state = 64;
+                            this._errHandler.sync(this);
+                            switch (this.interpreter.adaptivePredict(this._input, 3, this._ctx)) {
+                                case 1:
+                                    {
+                                        _localctx = new BinaryMultiplicativeExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 40;
+                                        if (!this.precpred(this._ctx, 6)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
+                                        }
+                                        this.state = 41;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << CESQLParserParser.STAR) |
+                                                    (1 << CESQLParserParser.DIVIDE) |
+                                                    (1 << CESQLParserParser.MODULE))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 42;
+                                        this.expression(7);
+                                    }
+                                    break;
+                                case 2:
+                                    {
+                                        _localctx = new BinaryAdditiveExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 43;
+                                        if (!this.precpred(this._ctx, 5)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
+                                        }
+                                        this.state = 44;
+                                        _la = this._input.LA(1);
+                                        if (!(_la === CESQLParserParser.PLUS || _la === CESQLParserParser.MINUS)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 45;
+                                        this.expression(6);
+                                    }
+                                    break;
+                                case 3:
+                                    {
+                                        _localctx = new BinaryComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 46;
+                                        if (!this.precpred(this._ctx, 4)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
+                                        }
+                                        this.state = 47;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << CESQLParserParser.EQUAL) |
+                                                    (1 << CESQLParserParser.NOT_EQUAL) |
+                                                    (1 << CESQLParserParser.GREATER) |
+                                                    (1 << CESQLParserParser.GREATER_OR_EQUAL) |
+                                                    (1 << CESQLParserParser.LESS) |
+                                                    (1 << CESQLParserParser.LESS_GREATER) |
+                                                    (1 << CESQLParserParser.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 = 48;
+                                        this.expression(5);
+                                    }
+                                    break;
+                                case 4:
+                                    {
+                                        _localctx = new BinaryLogicExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 49;
+                                        if (!this.precpred(this._ctx, 3)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
+                                        }
+                                        this.state = 50;
+                                        _la = this._input.LA(1);
+                                        if (!((_la & ~0x1f) === 0 &&
+                                            ((1 << _la) &
+                                                ((1 << CESQLParserParser.AND) |
+                                                    (1 << CESQLParserParser.OR) |
+                                                    (1 << CESQLParserParser.XOR))) !==
+                                                0)) {
+                                            this._errHandler.recoverInline(this);
+                                        }
+                                        else {
+                                            if (this._input.LA(1) === Token.EOF) {
+                                                this.matchedEOF = true;
+                                            }
+                                            this._errHandler.reportMatch(this);
+                                            this.consume();
+                                        }
+                                        this.state = 51;
+                                        this.expression(3);
+                                    }
+                                    break;
+                                case 5:
+                                    {
+                                        _localctx = new LikeExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 52;
+                                        if (!this.precpred(this._ctx, 9)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
+                                        }
+                                        this.state = 54;
+                                        this._errHandler.sync(this);
+                                        _la = this._input.LA(1);
+                                        if (_la === CESQLParserParser.NOT) {
+                                            {
+                                                this.state = 53;
+                                                this.match(CESQLParserParser.NOT);
+                                            }
+                                        }
+                                        this.state = 56;
+                                        this.match(CESQLParserParser.LIKE);
+                                        this.state = 57;
+                                        this.stringLiteral();
+                                    }
+                                    break;
+                                case 6:
+                                    {
+                                        _localctx = new InExpressionContext(new ExpressionContext(_parentctx, _parentState));
+                                        this.pushNewRecursionContext(_localctx, _startState, CESQLParserParser.RULE_expression);
+                                        this.state = 58;
+                                        if (!this.precpred(this._ctx, 7)) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
+                                        }
+                                        this.state = 60;
+                                        this._errHandler.sync(this);
+                                        _la = this._input.LA(1);
+                                        if (_la === CESQLParserParser.NOT) {
+                                            {
+                                                this.state = 59;
+                                                this.match(CESQLParserParser.NOT);
+                                            }
+                                        }
+                                        this.state = 62;
+                                        this.match(CESQLParserParser.IN);
+                                        this.state = 63;
+                                        this.setExpression();
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    this.state = 68;
+                    this._errHandler.sync(this);
+                    _alt = this.interpreter.adaptivePredict(this._input, 4, 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)
+    atom() {
+        let _localctx = new AtomContext(this._ctx, this.state);
+        this.enterRule(_localctx, 4, CESQLParserParser.RULE_atom);
+        try {
+            this.state = 73;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case CESQLParserParser.TRUE:
+                case CESQLParserParser.FALSE:
+                    _localctx = new BooleanAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 1);
+                    {
+                        this.state = 69;
+                        this.booleanLiteral();
+                    }
+                    break;
+                case CESQLParserParser.INTEGER_LITERAL:
+                    _localctx = new IntegerAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 2);
+                    {
+                        this.state = 70;
+                        this.integerLiteral();
+                    }
+                    break;
+                case CESQLParserParser.DQUOTED_STRING_LITERAL:
+                case CESQLParserParser.SQUOTED_STRING_LITERAL:
+                    _localctx = new StringAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 3);
+                    {
+                        this.state = 71;
+                        this.stringLiteral();
+                    }
+                    break;
+                case CESQLParserParser.IDENTIFIER:
+                case CESQLParserParser.IDENTIFIER_WITH_NUMBER:
+                    _localctx = new IdentifierAtomContext(_localctx);
+                    this.enterOuterAlt(_localctx, 4);
+                    {
+                        this.state = 72;
+                        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, 6, CESQLParserParser.RULE_identifier);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 75;
+                _la = this._input.LA(1);
+                if (!(_la === CESQLParserParser.IDENTIFIER || _la === CESQLParserParser.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)
+    functionIdentifier() {
+        let _localctx = new FunctionIdentifierContext(this._ctx, this.state);
+        this.enterRule(_localctx, 8, CESQLParserParser.RULE_functionIdentifier);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 77;
+                _la = this._input.LA(1);
+                if (!(_la === CESQLParserParser.IDENTIFIER || _la === CESQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE)) {
+                    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, 10, CESQLParserParser.RULE_booleanLiteral);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 79;
+                _la = this._input.LA(1);
+                if (!(_la === CESQLParserParser.TRUE || _la === CESQLParserParser.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, 12, CESQLParserParser.RULE_stringLiteral);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 81;
+                _la = this._input.LA(1);
+                if (!(_la === CESQLParserParser.DQUOTED_STRING_LITERAL || _la === CESQLParserParser.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, 14, CESQLParserParser.RULE_integerLiteral);
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 83;
+                this.match(CESQLParserParser.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)
+    functionParameterList() {
+        let _localctx = new FunctionParameterListContext(this._ctx, this.state);
+        this.enterRule(_localctx, 16, CESQLParserParser.RULE_functionParameterList);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 85;
+                this.match(CESQLParserParser.LR_BRACKET);
+                this.state = 94;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (((_la - 2) & ~0x1f) === 0 &&
+                    ((1 << (_la - 2)) &
+                        ((1 << (CESQLParserParser.LR_BRACKET - 2)) |
+                            (1 << (CESQLParserParser.NOT - 2)) |
+                            (1 << (CESQLParserParser.MINUS - 2)) |
+                            (1 << (CESQLParserParser.EXISTS - 2)) |
+                            (1 << (CESQLParserParser.TRUE - 2)) |
+                            (1 << (CESQLParserParser.FALSE - 2)) |
+                            (1 << (CESQLParserParser.DQUOTED_STRING_LITERAL - 2)) |
+                            (1 << (CESQLParserParser.SQUOTED_STRING_LITERAL - 2)) |
+                            (1 << (CESQLParserParser.INTEGER_LITERAL - 2)) |
+                            (1 << (CESQLParserParser.IDENTIFIER - 2)) |
+                            (1 << (CESQLParserParser.IDENTIFIER_WITH_NUMBER - 2)) |
+                            (1 << (CESQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE - 2)))) !==
+                        0) {
+                    {
+                        this.state = 86;
+                        this.expression(0);
+                        this.state = 91;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === CESQLParserParser.COMMA) {
+                            {
+                                {
+                                    this.state = 87;
+                                    this.match(CESQLParserParser.COMMA);
+                                    this.state = 88;
+                                    this.expression(0);
+                                }
+                            }
+                            this.state = 93;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                    }
+                }
+                this.state = 96;
+                this.match(CESQLParserParser.RR_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;
+    }
+    // @RuleVersion(0)
+    setExpression() {
+        let _localctx = new SetExpressionContext(this._ctx, this.state);
+        this.enterRule(_localctx, 18, CESQLParserParser.RULE_setExpression);
+        let _la;
+        try {
+            this.enterOuterAlt(_localctx, 1);
+            {
+                this.state = 98;
+                this.match(CESQLParserParser.LR_BRACKET);
+                this.state = 99;
+                this.expression(0);
+                this.state = 104;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === CESQLParserParser.COMMA) {
+                    {
+                        {
+                            this.state = 100;
+                            this.match(CESQLParserParser.COMMA);
+                            this.state = 101;
+                            this.expression(0);
+                        }
+                    }
+                    this.state = 106;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 107;
+                this.match(CESQLParserParser.RR_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 1:
+                return this.expression_sempred(_localctx, predIndex);
+        }
+        return true;
+    }
+    expression_sempred(_localctx, predIndex) {
+        switch (predIndex) {
+            case 0:
+                return this.precpred(this._ctx, 6);
+            case 1:
+                return this.precpred(this._ctx, 5);
+            case 2:
+                return this.precpred(this._ctx, 4);
+            case 3:
+                return this.precpred(this._ctx, 3);
+            case 4:
+                return this.precpred(this._ctx, 9);
+            case 5:
+                return this.precpred(this._ctx, 7);
+        }
+        return true;
+    }
+    static get _ATN() {
+        if (!CESQLParserParser.__ATN) {
+            CESQLParserParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(CESQLParserParser._serializedATN));
+        }
+        return CESQLParserParser.__ATN;
+    }
+}
+CESQLParserParser.SPACE = 1;
+CESQLParserParser.LR_BRACKET = 2;
+CESQLParserParser.RR_BRACKET = 3;
+CESQLParserParser.COMMA = 4;
+CESQLParserParser.SINGLE_QUOTE_SYMB = 5;
+CESQLParserParser.DOUBLE_QUOTE_SYMB = 6;
+CESQLParserParser.AND = 7;
+CESQLParserParser.OR = 8;
+CESQLParserParser.XOR = 9;
+CESQLParserParser.NOT = 10;
+CESQLParserParser.STAR = 11;
+CESQLParserParser.DIVIDE = 12;
+CESQLParserParser.MODULE = 13;
+CESQLParserParser.PLUS = 14;
+CESQLParserParser.MINUS = 15;
+CESQLParserParser.EQUAL = 16;
+CESQLParserParser.NOT_EQUAL = 17;
+CESQLParserParser.GREATER = 18;
+CESQLParserParser.GREATER_OR_EQUAL = 19;
+CESQLParserParser.LESS = 20;
+CESQLParserParser.LESS_GREATER = 21;
+CESQLParserParser.LESS_OR_EQUAL = 22;
+CESQLParserParser.LIKE = 23;
+CESQLParserParser.EXISTS = 24;
+CESQLParserParser.IN = 25;
+CESQLParserParser.TRUE = 26;
+CESQLParserParser.FALSE = 27;
+CESQLParserParser.DQUOTED_STRING_LITERAL = 28;
+CESQLParserParser.SQUOTED_STRING_LITERAL = 29;
+CESQLParserParser.INTEGER_LITERAL = 30;
+CESQLParserParser.IDENTIFIER = 31;
+CESQLParserParser.IDENTIFIER_WITH_NUMBER = 32;
+CESQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE = 33;
+CESQLParserParser.RULE_cesql = 0;
+CESQLParserParser.RULE_expression = 1;
+CESQLParserParser.RULE_atom = 2;
+CESQLParserParser.RULE_identifier = 3;
+CESQLParserParser.RULE_functionIdentifier = 4;
+CESQLParserParser.RULE_booleanLiteral = 5;
+CESQLParserParser.RULE_stringLiteral = 6;
+CESQLParserParser.RULE_integerLiteral = 7;
+CESQLParserParser.RULE_functionParameterList = 8;
+CESQLParserParser.RULE_setExpression = 9;
+// tslint:disable:no-trailing-whitespace
+CESQLParserParser.ruleNames = [
+    "cesql",
+    "expression",
+    "atom",
+    "identifier",
+    "functionIdentifier",
+    "booleanLiteral",
+    "stringLiteral",
+    "integerLiteral",
+    "functionParameterList",
+    "setExpression"
+];
+CESQLParserParser._LITERAL_NAMES = [
+    undefined,
+    undefined,
+    "'('",
+    "')'",
+    "','",
+    "'''",
+    "'\"'",
+    "'AND'",
+    "'OR'",
+    "'XOR'",
+    "'NOT'",
+    "'*'",
+    "'/'",
+    "'%'",
+    "'+'",
+    "'-'",
+    "'='",
+    "'!='",
+    "'>'",
+    "'>='",
+    "'<'",
+    "'<>'",
+    "'<='",
+    "'LIKE'",
+    "'EXISTS'",
+    "'IN'",
+    "'TRUE'",
+    "'FALSE'"
+];
+CESQLParserParser._SYMBOLIC_NAMES = [
+    undefined,
+    "SPACE",
+    "LR_BRACKET",
+    "RR_BRACKET",
+    "COMMA",
+    "SINGLE_QUOTE_SYMB",
+    "DOUBLE_QUOTE_SYMB",
+    "AND",
+    "OR",
+    "XOR",
+    "NOT",
+    "STAR",
+    "DIVIDE",
+    "MODULE",
+    "PLUS",
+    "MINUS",
+    "EQUAL",
+    "NOT_EQUAL",
+    "GREATER",
+    "GREATER_OR_EQUAL",
+    "LESS",
+    "LESS_GREATER",
+    "LESS_OR_EQUAL",
+    "LIKE",
+    "EXISTS",
+    "IN",
+    "TRUE",
+    "FALSE",
+    "DQUOTED_STRING_LITERAL",
+    "SQUOTED_STRING_LITERAL",
+    "INTEGER_LITERAL",
+    "IDENTIFIER",
+    "IDENTIFIER_WITH_NUMBER",
+    "FUNCTION_IDENTIFIER_WITH_UNDERSCORE"
+];
+CESQLParserParser.VOCABULARY = new VocabularyImpl(CESQLParserParser._LITERAL_NAMES, CESQLParserParser._SYMBOLIC_NAMES, []);
+CESQLParserParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03#p\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\x03\x02\x03\x02\x03\x02\x03\x03" +
+    "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+    "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x05\x03)\n\x03\x03\x03\x03\x03" +
+    "\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+    "\x03\x03\x03\x03\x03\x03\x05\x039\n\x03\x03\x03\x03\x03\x03\x03\x03\x03" +
+    "\x05\x03?\n\x03\x03\x03\x03\x03\x07\x03C\n\x03\f\x03\x0E\x03F\v\x03\x03" +
+    "\x04\x03\x04\x03\x04\x03\x04\x05\x04L\n\x04\x03\x05\x03\x05\x03\x06\x03" +
+    "\x06\x03\x07\x03\x07\x03\b\x03\b\x03\t\x03\t\x03\n\x03\n\x03\n\x03\n\x07" +
+    "\n\\\n\n\f\n\x0E\n_\v\n\x05\na\n\n\x03\n\x03\n\x03\v\x03\v\x03\v\x03\v" +
+    "\x07\vi\n\v\f\v\x0E\vl\v\v\x03\v\x03\v\x03\v\x02\x02\x03\x04\f\x02\x02" +
+    "\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x02" +
+    "\n\x03\x02\r\x0F\x03\x02\x10\x11\x03\x02\x12\x18\x03\x02\t\v\x03\x02!" +
+    '"\x04\x02!!##\x03\x02\x1C\x1D\x03\x02\x1E\x1F\x02x\x02\x16\x03\x02\x02' +
+    "\x02\x04(\x03\x02\x02\x02\x06K\x03\x02\x02\x02\bM\x03\x02\x02\x02\nO\x03" +
+    "\x02\x02\x02\fQ\x03\x02\x02\x02\x0ES\x03\x02\x02\x02\x10U\x03\x02\x02" +
+    "\x02\x12W\x03\x02\x02\x02\x14d\x03\x02\x02\x02\x16\x17\x05\x04\x03\x02" +
+    "\x17\x18\x07\x02\x02\x03\x18\x03\x03\x02\x02\x02\x19\x1A\b\x03\x01\x02" +
+    "\x1A\x1B\x05\n\x06\x02\x1B\x1C\x05\x12\n\x02\x1C)\x03\x02\x02\x02\x1D" +
+    "\x1E\x07\f\x02\x02\x1E)\x05\x04\x03\r\x1F \x07\x11\x02\x02 )\x05\x04\x03" +
+    '\f!"\x07\x1A\x02\x02")\x05\b\x05\x02#$\x07\x04\x02\x02$%\x05\x04\x03' +
+    "\x02%&\x07\x05\x02\x02&)\x03\x02\x02\x02')\x05\x06\x04\x02(\x19\x03\x02" +
+    "\x02\x02(\x1D\x03\x02\x02\x02(\x1F\x03\x02\x02\x02(!\x03\x02\x02\x02(" +
+    "#\x03\x02\x02\x02('\x03\x02\x02\x02)D\x03\x02\x02\x02*+\f\b\x02\x02+" +
+    ",\t\x02\x02\x02,C\x05\x04\x03\t-.\f\x07\x02\x02./\t\x03\x02\x02/C\x05" +
+    "\x04\x03\b01\f\x06\x02\x0212\t\x04\x02\x022C\x05\x04\x03\x0734\f\x05\x02" +
+    "\x0245\t\x05\x02\x025C\x05\x04\x03\x0568\f\v\x02\x0279\x07\f\x02\x028" +
+    "7\x03\x02\x02\x0289\x03\x02\x02\x029:\x03\x02\x02\x02:;\x07\x19\x02\x02" +
+    ";C\x05\x0E\b\x02<>\f\t\x02\x02=?\x07\f\x02\x02>=\x03\x02\x02\x02>?\x03" +
+    "\x02\x02\x02?@\x03\x02\x02\x02@A\x07\x1B\x02\x02AC\x05\x14\v\x02B*\x03" +
+    "\x02\x02\x02B-\x03\x02\x02\x02B0\x03\x02\x02\x02B3\x03\x02\x02\x02B6\x03" +
+    "\x02\x02\x02B<\x03\x02\x02\x02CF\x03\x02\x02\x02DB\x03\x02\x02\x02DE\x03" +
+    "\x02\x02\x02E\x05\x03\x02\x02\x02FD\x03\x02\x02\x02GL\x05\f\x07\x02HL" +
+    "\x05\x10\t\x02IL\x05\x0E\b\x02JL\x05\b\x05\x02KG\x03\x02\x02\x02KH\x03" +
+    "\x02\x02\x02KI\x03\x02\x02\x02KJ\x03\x02\x02\x02L\x07\x03\x02\x02\x02" +
+    "MN\t\x06\x02\x02N\t\x03\x02\x02\x02OP\t\x07\x02\x02P\v\x03\x02\x02\x02" +
+    "QR\t\b\x02\x02R\r\x03\x02\x02\x02ST\t\t\x02\x02T\x0F\x03\x02\x02\x02U" +
+    "V\x07 \x02\x02V\x11\x03\x02\x02\x02W`\x07\x04\x02\x02X]\x05\x04\x03\x02" +
+    "YZ\x07\x06\x02\x02Z\\\x05\x04\x03\x02[Y\x03\x02\x02\x02\\_\x03\x02\x02" +
+    "\x02][\x03\x02\x02\x02]^\x03\x02\x02\x02^a\x03\x02\x02\x02_]\x03\x02\x02" +
+    "\x02`X\x03\x02\x02\x02`a\x03\x02\x02\x02ab\x03\x02\x02\x02bc\x07\x05\x02" +
+    "\x02c\x13\x03\x02\x02\x02de\x07\x04\x02\x02ej\x05\x04\x03\x02fg\x07\x06" +
+    "\x02\x02gi\x05\x04\x03\x02hf\x03\x02\x02\x02il\x03\x02\x02\x02jh\x03\x02" +
+    "\x02\x02jk\x03\x02\x02\x02km\x03\x02\x02\x02lj\x03\x02\x02\x02mn\x07\x05" +
+    "\x02\x02n\x15\x03\x02\x02\x02\v(8>BDK]`j";
+export class CesqlContext extends ParserRuleContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    EOF() {
+        return this.getToken(CESQLParserParser.EOF, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.RULE_cesql;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterCesql) {
+            listener.enterCesql(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitCesql) {
+            listener.exitCesql(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitCesql) {
+            return visitor.visitCesql(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExpressionContext extends ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.RULE_expression;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+export class FunctionInvocationExpressionContext extends ExpressionContext {
+    functionIdentifier() {
+        return this.getRuleContext(0, FunctionIdentifierContext);
+    }
+    functionParameterList() {
+        return this.getRuleContext(0, FunctionParameterListContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterFunctionInvocationExpression) {
+            listener.enterFunctionInvocationExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitFunctionInvocationExpression) {
+            listener.exitFunctionInvocationExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFunctionInvocationExpression) {
+            return visitor.visitFunctionInvocationExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class UnaryLogicExpressionContext extends ExpressionContext {
+    NOT() {
+        return this.getToken(CESQLParserParser.NOT, 0);
+    }
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterUnaryLogicExpression) {
+            listener.enterUnaryLogicExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitUnaryLogicExpression) {
+            listener.exitUnaryLogicExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitUnaryLogicExpression) {
+            return visitor.visitUnaryLogicExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class UnaryNumericExpressionContext extends ExpressionContext {
+    MINUS() {
+        return this.getToken(CESQLParserParser.MINUS, 0);
+    }
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterUnaryNumericExpression) {
+            listener.enterUnaryNumericExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitUnaryNumericExpression) {
+            listener.exitUnaryNumericExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitUnaryNumericExpression) {
+            return visitor.visitUnaryNumericExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class LikeExpressionContext extends ExpressionContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    LIKE() {
+        return this.getToken(CESQLParserParser.LIKE, 0);
+    }
+    stringLiteral() {
+        return this.getRuleContext(0, StringLiteralContext);
+    }
+    NOT() {
+        return this.tryGetToken(CESQLParserParser.NOT, 0);
+    }
+    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 ExistsExpressionContext extends ExpressionContext {
+    EXISTS() {
+        return this.getToken(CESQLParserParser.EXISTS, 0);
+    }
+    identifier() {
+        return this.getRuleContext(0, IdentifierContext);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterExistsExpression) {
+            listener.enterExistsExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitExistsExpression) {
+            listener.exitExistsExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExistsExpression) {
+            return visitor.visitExistsExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class InExpressionContext extends ExpressionContext {
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    IN() {
+        return this.getToken(CESQLParserParser.IN, 0);
+    }
+    setExpression() {
+        return this.getRuleContext(0, SetExpressionContext);
+    }
+    NOT() {
+        return this.tryGetToken(CESQLParserParser.NOT, 0);
+    }
+    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 BinaryMultiplicativeExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    STAR() {
+        return this.tryGetToken(CESQLParserParser.STAR, 0);
+    }
+    DIVIDE() {
+        return this.tryGetToken(CESQLParserParser.DIVIDE, 0);
+    }
+    MODULE() {
+        return this.tryGetToken(CESQLParserParser.MODULE, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterBinaryMultiplicativeExpression) {
+            listener.enterBinaryMultiplicativeExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitBinaryMultiplicativeExpression) {
+            listener.exitBinaryMultiplicativeExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBinaryMultiplicativeExpression) {
+            return visitor.visitBinaryMultiplicativeExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BinaryAdditiveExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    PLUS() {
+        return this.tryGetToken(CESQLParserParser.PLUS, 0);
+    }
+    MINUS() {
+        return this.tryGetToken(CESQLParserParser.MINUS, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterBinaryAdditiveExpression) {
+            listener.enterBinaryAdditiveExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitBinaryAdditiveExpression) {
+            listener.exitBinaryAdditiveExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBinaryAdditiveExpression) {
+            return visitor.visitBinaryAdditiveExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BinaryComparisonExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    EQUAL() {
+        return this.tryGetToken(CESQLParserParser.EQUAL, 0);
+    }
+    NOT_EQUAL() {
+        return this.tryGetToken(CESQLParserParser.NOT_EQUAL, 0);
+    }
+    LESS_GREATER() {
+        return this.tryGetToken(CESQLParserParser.LESS_GREATER, 0);
+    }
+    GREATER_OR_EQUAL() {
+        return this.tryGetToken(CESQLParserParser.GREATER_OR_EQUAL, 0);
+    }
+    LESS_OR_EQUAL() {
+        return this.tryGetToken(CESQLParserParser.LESS_OR_EQUAL, 0);
+    }
+    LESS() {
+        return this.tryGetToken(CESQLParserParser.LESS, 0);
+    }
+    GREATER() {
+        return this.tryGetToken(CESQLParserParser.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 BinaryLogicExpressionContext extends ExpressionContext {
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    AND() {
+        return this.tryGetToken(CESQLParserParser.AND, 0);
+    }
+    OR() {
+        return this.tryGetToken(CESQLParserParser.OR, 0);
+    }
+    XOR() {
+        return this.tryGetToken(CESQLParserParser.XOR, 0);
+    }
+    constructor(ctx) {
+        super(ctx.parent, ctx.invokingState);
+        this.copyFrom(ctx);
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterBinaryLogicExpression) {
+            listener.enterBinaryLogicExpression(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitBinaryLogicExpression) {
+            listener.exitBinaryLogicExpression(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBinaryLogicExpression) {
+            return visitor.visitBinaryLogicExpression(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SubExpressionContext extends ExpressionContext {
+    LR_BRACKET() {
+        return this.getToken(CESQLParserParser.LR_BRACKET, 0);
+    }
+    expression() {
+        return this.getRuleContext(0, ExpressionContext);
+    }
+    RR_BRACKET() {
+        return this.getToken(CESQLParserParser.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 AtomContext extends ParserRuleContext {
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.RULE_atom;
+    }
+    copyFrom(ctx) {
+        super.copyFrom(ctx);
+    }
+}
+export class BooleanAtomContext extends AtomContext {
+    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 AtomContext {
+    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 AtomContext {
+    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 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(CESQLParserParser.IDENTIFIER, 0);
+    }
+    IDENTIFIER_WITH_NUMBER() {
+        return this.tryGetToken(CESQLParserParser.IDENTIFIER_WITH_NUMBER, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.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 FunctionIdentifierContext extends ParserRuleContext {
+    IDENTIFIER() {
+        return this.tryGetToken(CESQLParserParser.IDENTIFIER, 0);
+    }
+    FUNCTION_IDENTIFIER_WITH_UNDERSCORE() {
+        return this.tryGetToken(CESQLParserParser.FUNCTION_IDENTIFIER_WITH_UNDERSCORE, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.RULE_functionIdentifier;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterFunctionIdentifier) {
+            listener.enterFunctionIdentifier(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitFunctionIdentifier) {
+            listener.exitFunctionIdentifier(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFunctionIdentifier) {
+            return visitor.visitFunctionIdentifier(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BooleanLiteralContext extends ParserRuleContext {
+    TRUE() {
+        return this.tryGetToken(CESQLParserParser.TRUE, 0);
+    }
+    FALSE() {
+        return this.tryGetToken(CESQLParserParser.FALSE, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.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(CESQLParserParser.DQUOTED_STRING_LITERAL, 0);
+    }
+    SQUOTED_STRING_LITERAL() {
+        return this.tryGetToken(CESQLParserParser.SQUOTED_STRING_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.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(CESQLParserParser.INTEGER_LITERAL, 0);
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.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 FunctionParameterListContext extends ParserRuleContext {
+    LR_BRACKET() {
+        return this.getToken(CESQLParserParser.LR_BRACKET, 0);
+    }
+    RR_BRACKET() {
+        return this.getToken(CESQLParserParser.RR_BRACKET, 0);
+    }
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    COMMA(i) {
+        if (i === undefined) {
+            return this.getTokens(CESQLParserParser.COMMA);
+        }
+        else {
+            return this.getToken(CESQLParserParser.COMMA, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.RULE_functionParameterList;
+    }
+    // @Override
+    enterRule(listener) {
+        if (listener.enterFunctionParameterList) {
+            listener.enterFunctionParameterList(this);
+        }
+    }
+    // @Override
+    exitRule(listener) {
+        if (listener.exitFunctionParameterList) {
+            listener.exitFunctionParameterList(this);
+        }
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFunctionParameterList) {
+            return visitor.visitFunctionParameterList(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SetExpressionContext extends ParserRuleContext {
+    LR_BRACKET() {
+        return this.getToken(CESQLParserParser.LR_BRACKET, 0);
+    }
+    expression(i) {
+        if (i === undefined) {
+            return this.getRuleContexts(ExpressionContext);
+        }
+        else {
+            return this.getRuleContext(i, ExpressionContext);
+        }
+    }
+    RR_BRACKET() {
+        return this.getToken(CESQLParserParser.RR_BRACKET, 0);
+    }
+    COMMA(i) {
+        if (i === undefined) {
+            return this.getTokens(CESQLParserParser.COMMA);
+        }
+        else {
+            return this.getToken(CESQLParserParser.COMMA, i);
+        }
+    }
+    constructor(parent, invokingState) {
+        super(parent, invokingState);
+    }
+    // @Override
+    get ruleIndex() {
+        return CESQLParserParser.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=CESQLParserParser.js.map