@chaoswise/business 0.0.6 → 0.0.8

package/lib/AggregateSearch/CLSPL/CLQLParser.js

@@ -0,0 +1,2797 @@
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+// Generated from /Users/changle/Documents/code/doop/cql/src/main/resources/antlr/cql/CLQLParser.g4 by ANTLR 4.9.2
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import CLQLParserListener from './CLQLParserListener.js';
+import CLQLParserVisitor from './CLQLParserVisitor.js';
+var serializedATN = ["\x03\u608B\uA72A\u8133\uB9ED\u417C\u3BE7\u7786", "\u5964\x03\"\xB2\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\x0B\t\x0B\x04\f\t\f", "\x04\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10", "\x04\x11\t\x11\x04\x12\t\x12\x04\x13\t\x13\x04\x14", "\t\x14\x04\x15\t\x15\x04\x16\t\x16\x03\x02\x03\x02", "\x05\x02/\n\x02\x03\x02\x03\x02\x03\x03\x03\x03", "\x03\x04\x06\x046\n\x04\r\x04\x0E\x047\x03\x05\x03", "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03", "\x05\x03\x05\x03\x05\x05\x05D\n\x05\x03\x05\x03", "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x07\x05L", "\n\x05\f\x05\x0E\x05O\x0B\x05\x03\x06\x03\x06\x03", "\x06\x05\x06T\n\x06\x03\x07\x03\x07\x03\b\x03\b", "\x05\bZ\n\b\x03\b\x03\b\x05\b^\n\b\x07\b`\n\b\f\b\x0E\b", "c\x0B\b\x03\b\x05\bf\n\b\x03\b\x03\b\x03\t\x03\t\x03", "\t\x03\t\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03", "\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03\n\x03", "\n\x03\n\x07\n\x80\n\n\f\n\x0E\n\x83\x0B\n\x03\n\x03", "\n\x03\n\x03\n\x05\n\x89\n\n\x03\x0B\x03\x0B\x03\f", "\x03\f\x05\f\x8F\n\f\x03\r\x03\r\x03\x0E\x03\x0E\x05", "\x0E\x95\n\x0E\x03\x0F\x03\x0F\x03\x10\x03\x10", "\x05\x10\x9B\n\x10\x03\x11\x03\x11\x03\x12\x03", "\x12\x05\x12\xA1\n\x12\x03\x13\x05\x13\xA4\n\x13", "\x03\x13\x03\x13\x03\x14\x05\x14\xA9\n\x14\x03", "\x14\x03\x14\x03\x15\x03\x15\x03\x16\x03\x16\x03", "\x16\x03\x16\x02\x03\b\x17\x02\x04\x06\b\n\f\x0E", "\x10\x12\x14\x16\x18\x1A\x1C\x1E \"$&(*\x02\b\x04", "\x02\x11\x11\x13\x13\x04\x02\x12\x12\x14\x14\x04", "\x02\x1C\x1C  \x03\x02\x16\x17\x03\x02\x1E\x1F", "\x03\x02\x0B\x0E\x02\xB4\x02.\x03\x02\x02\x02", "\x042\x03\x02\x02\x02\x065\x03\x02\x02\x02\bC\x03", "\x02\x02\x02\nS\x03\x02\x02\x02\fU\x03\x02\x02\x02", "\x0EW\x03\x02\x02\x02\x10i\x03\x02\x02\x02\x12", "\x88\x03\x02\x02\x02\x14\x8A\x03\x02\x02\x02\x16", "\x8E\x03\x02\x02\x02\x18\x90\x03\x02\x02\x02\x1A", "\x94\x03\x02\x02\x02\x1C\x96\x03\x02\x02\x02\x1E", "\x9A\x03\x02\x02\x02 \x9C\x03\x02\x02\x02\"\xA0", "\x03\x02\x02\x02$\xA3\x03\x02\x02\x02&\xA8\x03", "\x02\x02\x02(\xAC\x03\x02\x02\x02*\xAE\x03\x02", "\x02\x02,/\x05\x04\x03\x02-/\x05*\x16\x02.,\x03", "\x02\x02\x02.-\x03\x02\x02\x02/0\x03\x02\x02\x02", "01\x07\x02\x02\x031\x03\x03\x02\x02\x0223\x05\x06", "\x04\x023\x05\x03\x02\x02\x0246\x05\b\x05\x0254", "\x03\x02\x02\x0267\x03\x02\x02\x0275\x03\x02\x02", "\x0278\x03\x02\x02\x028\x07\x03\x02\x02\x029:\b", "\x05\x01\x02:;\x07\t\x02\x02;<\x05\b\x05\x02<=\x07", "\n\x02\x02=D\x03\x02\x02\x02>?\x07\x19\x02\x02?", "D\x05\b\x05\b@D\x05\x10\t\x02AD\x05\x12\n\x02BD\x05", "\n\x06\x02C9\x03\x02\x02\x02C>\x03\x02\x02\x02C", "@\x03\x02\x02\x02CA\x03\x02\x02\x02CB\x03\x02\x02", "\x02DM\x03\x02\x02\x02EF\f\x07\x02\x02FG\x07\x1A", "\x02\x02GL\x05\b\x05\bHI\f\x06\x02\x02IJ\x07\x18\x02", "\x02JL\x05\b\x05\x07KE\x03\x02\x02\x02KH\x03\x02", "\x02\x02LO\x03\x02\x02\x02MK\x03\x02\x02\x02MN\x03", "\x02\x02\x02N\t\x03\x02\x02\x02OM\x03\x02\x02\x02", "PT\x05\x14\x0B\x02QT\x05\f\x07\x02RT\x05\x0E\b\x02", "SP\x03\x02\x02\x02SQ\x03\x02\x02\x02SR\x03\x02\x02", "\x02T\x0B\x03\x02\x02\x02UV\x07\x04\x02\x02V\r\x03", "\x02\x02\x02We\x07\x03\x02\x02XZ\x07\x05\x02\x02", "YX\x03\x02\x02\x02YZ\x03\x02\x02\x02Z[\x03\x02\x02", "\x02[]\x07\x10\x02\x02\\^\x07\x05\x02\x02]\\\x03", "\x02\x02\x02]^\x03\x02\x02\x02^`\x03\x02\x02\x02", "_Y\x03\x02\x02\x02`c\x03\x02\x02\x02a_\x03\x02\x02", "\x02ab\x03\x02\x02\x02bf\x03\x02\x02\x02ca\x03\x02", "\x02\x02df\x07\x05\x02\x02ea\x03\x02\x02\x02ed\x03", "\x02\x02\x02fg\x03\x02\x02\x02gh\x07\x03\x02\x02", "h\x0F\x03\x02\x02\x02ij\x05\x16\f\x02jk\x05(\x15", "\x02kl\x05\x16\f\x02l\x11\x03\x02\x02\x02mn\x05", "\x18\r\x02no\x07\b\x02\x02op\x05\x1A\x0E\x02p\x89", "\x03\x02\x02\x02qr\x05\x18\r\x02rs\x07\b\x02\x02", "st\t\x02\x02\x02tu\x05\"\x12\x02uv\x07\x1B\x02\x02", "vw\x05\"\x12\x02wx\t\x03\x02\x02x\x89\x03\x02\x02", "\x02yz\x05\x18\r\x02z{\x07\b\x02\x02{|\x07\t\x02\x02", "|\x81\x05\x1E\x10\x02}~\x07\x1A\x02\x02~\x80\x05", "\x1E\x10\x02\x7F}\x03\x02\x02\x02\x80\x83\x03", "\x02\x02\x02\x81\x7F\x03\x02\x02\x02\x81\x82\x03", "\x02\x02\x02\x82\x84\x03\x02\x02\x02\x83\x81\x03", "\x02\x02\x02\x84\x85\x07\n\x02\x02\x85\x89\x03", "\x02\x02\x02\x86\x87\x07\x15\x02\x02\x87\x89\x05", "\x18\r\x02\x88m\x03\x02\x02\x02\x88q\x03\x02\x02", "\x02\x88y\x03\x02\x02\x02\x88\x86\x03\x02\x02", "\x02\x89\x13\x03\x02\x02\x02\x8A\x8B\x05\x1A\x0E", "\x02\x8B\x15\x03\x02\x02\x02\x8C\x8F\x05\x18\r", "\x02\x8D\x8F\x05\x1E\x10\x02\x8E\x8C\x03\x02\x02", "\x02\x8E\x8D\x03\x02\x02\x02\x8F\x17\x03\x02\x02", "\x02\x90\x91\x07 \x02\x02\x91\x19\x03\x02\x02", "\x02\x92\x95\x05\x1C\x0F\x02\x93\x95\x05\x1E\x10", "\x02\x94\x92\x03\x02\x02\x02\x94\x93\x03\x02\x02", "\x02\x95\x1B\x03\x02\x02\x02\x96\x97\x07\"\x02", "\x02\x97\x1D\x03\x02\x02\x02\x98\x9B\x05 \x11", "\x02\x99\x9B\x05\"\x12\x02\x9A\x98\x03\x02\x02", "\x02\x9A\x99\x03\x02\x02\x02\x9B\x1F\x03\x02\x02", "\x02\x9C\x9D\t\x04\x02\x02\x9D!\x03\x02\x02\x02", "\x9E\xA1\x05$\x13\x02\x9F\xA1\x05&\x14\x02\xA0", "\x9E\x03\x02\x02\x02\xA0\x9F\x03\x02\x02\x02\xA1", "#\x03\x02\x02\x02\xA2\xA4\t\x05\x02\x02\xA3\xA2", "\x03\x02\x02\x02\xA3\xA4\x03\x02\x02\x02\xA4\xA5", "\x03\x02\x02\x02\xA5\xA6\x07\x1D\x02\x02\xA6%", "\x03\x02\x02\x02\xA7\xA9\t\x05\x02\x02\xA8\xA7", "\x03\x02\x02\x02\xA8\xA9\x03\x02\x02\x02\xA9\xAA", "\x03\x02\x02\x02\xAA\xAB\t\x06\x02\x02\xAB'\x03", "\x02\x02\x02\xAC\xAD\t\x07\x02\x02\xAD)\x03\x02", "\x02\x02\xAE\xAF\x07!\x02\x02\xAF\xB0\b\x16\x01", "\x02\xB0+\x03\x02\x02\x02\x14.7CKMSY]ae\x81\x88\x8E", "\x94\x9A\xA0\xA3\xA8"].join('');
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+var decisionsToDFA = atn.decisionToState.map(function (ds, index) {
+  return new antlr4.dfa.DFA(ds, index);
+});
+var sharedContextCache = new antlr4.PredictionContextCache();
+var CLQLParser = /*#__PURE__*/function (_antlr4$Parser) {
+  _inherits(CLQLParser, _antlr4$Parser);
+  var _super = _createSuper(CLQLParser);
+  function CLQLParser(input) {
+    var _this;
+    _classCallCheck(this, CLQLParser);
+    _this = _super.call(this, input);
+    _this._interp = new antlr4.atn.ParserATNSimulator(_assertThisInitialized(_this), atn, decisionsToDFA, sharedContextCache);
+    _this.ruleNames = CLQLParser.ruleNames;
+    _this.literalNames = CLQLParser.literalNames;
+    _this.symbolicNames = CLQLParser.symbolicNames;
+    return _this;
+  }
+  _createClass(CLQLParser, [{
+    key: "atn",
+    get: function get() {
+      return atn;
+    }
+  }, {
+    key: "sempred",
+    value: function sempred(localctx, ruleIndex, predIndex) {
+      switch (ruleIndex) {
+        case 3:
+          return this.logical_expr_sempred(localctx, predIndex);
+        default:
+          throw 'No predicate with index:' + ruleIndex;
+      }
+    }
+  }, {
+    key: "logical_expr_sempred",
+    value: function logical_expr_sempred(localctx, predIndex) {
+      switch (predIndex) {
+        case 0:
+          return this.precpred(this._ctx, 5);
+        case 1:
+          return this.precpred(this._ctx, 4);
+        default:
+          throw 'No predicate with index:' + predIndex;
+      }
+    }
+  }, {
+    key: "root",
+    value: function root() {
+      var localctx = new RootContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 0, CLQLParser.RULE_root);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 44;
+        this._errHandler.sync(this);
+        switch (this._input.LA(1)) {
+          case CLQLParser.WEI:
+          case CLQLParser.REGEX:
+          case CLQLParser.LPAREN:
+          case CLQLParser.WAVE:
+          case CLQLParser.PLUS:
+          case CLQLParser.MINUS:
+          case CLQLParser.K_NOT:
+          case CLQLParser.DQUOTA_STRING:
+          case CLQLParser.INTEGER_LITERAL:
+          case CLQLParser.DECIMAL_LITERAL:
+          case CLQLParser.HEXADECIMAL_LITERAL:
+          case CLQLParser.UNQUOTA_STRING:
+          case CLQLParser.FUZZY_LITERAL:
+            this.state = 42;
+            this.cqlStatement();
+            break;
+          case CLQLParser.UNEXPECTED_CHAR:
+            this.state = 43;
+            this.err();
+            break;
+          default:
+            throw new antlr4.error.NoViableAltException(this);
+        }
+        this.state = 46;
+        this.match(CLQLParser.EOF);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "cqlStatement",
+    value: function cqlStatement() {
+      var localctx = new CqlStatementContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 2, CLQLParser.RULE_cqlStatement);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 48;
+        this.search();
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "search",
+    value: function search() {
+      var localctx = new SearchContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 4, CLQLParser.RULE_search);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 51;
+        this._errHandler.sync(this);
+        _la = this._input.LA(1);
+        do {
+          this.state = 50;
+          this.logical_expr(0);
+          this.state = 53;
+          this._errHandler.sync(this);
+          _la = this._input.LA(1);
+        } while ((_la - 1 & ~0x1f) == 0 && (1 << _la - 1 & (1 << CLQLParser.WEI - 1 | 1 << CLQLParser.REGEX - 1 | 1 << CLQLParser.LPAREN - 1 | 1 << CLQLParser.WAVE - 1 | 1 << CLQLParser.PLUS - 1 | 1 << CLQLParser.MINUS - 1 | 1 << CLQLParser.K_NOT - 1 | 1 << CLQLParser.DQUOTA_STRING - 1 | 1 << CLQLParser.INTEGER_LITERAL - 1 | 1 << CLQLParser.DECIMAL_LITERAL - 1 | 1 << CLQLParser.HEXADECIMAL_LITERAL - 1 | 1 << CLQLParser.UNQUOTA_STRING - 1 | 1 << CLQLParser.FUZZY_LITERAL - 1)) !== 0);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "logical_expr",
+    value: function logical_expr(_p) {
+      if (_p === undefined) {
+        _p = 0;
+      }
+      var _parentctx = this._ctx;
+      var _parentState = this.state;
+      var localctx = new Logical_exprContext(this, this._ctx, _parentState);
+      var _prevctx = localctx;
+      var _startState = 6;
+      this.enterRecursionRule(localctx, 6, CLQLParser.RULE_logical_expr, _p);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 65;
+        this._errHandler.sync(this);
+        var la_ = this._interp.adaptivePredict(this._input, 2, this._ctx);
+        switch (la_) {
+          case 1:
+            localctx = new ParenExprContext(this, localctx);
+            this._ctx = localctx;
+            _prevctx = localctx;
+            this.state = 56;
+            this.match(CLQLParser.LPAREN);
+            this.state = 57;
+            this.logical_expr(0);
+            this.state = 58;
+            this.match(CLQLParser.RPAREN);
+            break;
+          case 2:
+            localctx = new NotExprContext(this, localctx);
+            this._ctx = localctx;
+            _prevctx = localctx;
+            this.state = 60;
+            this.match(CLQLParser.K_NOT);
+            this.state = 61;
+            this.logical_expr(6);
+            break;
+          case 3:
+            localctx = new ComparisonExprContext(this, localctx);
+            this._ctx = localctx;
+            _prevctx = localctx;
+            this.state = 62;
+            this.comparison_expr();
+            break;
+          case 4:
+            localctx = new FieldExprContext(this, localctx);
+            this._ctx = localctx;
+            _prevctx = localctx;
+            this.state = 63;
+            this.field_expr();
+            break;
+          case 5:
+            localctx = new TextExprContext(this, localctx);
+            this._ctx = localctx;
+            _prevctx = localctx;
+            this.state = 64;
+            this.text_expr();
+            break;
+        }
+        this._ctx.stop = this._input.LT(-1);
+        this.state = 75;
+        this._errHandler.sync(this);
+        var _alt = this._interp.adaptivePredict(this._input, 4, this._ctx);
+        while (_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+          if (_alt === 1) {
+            if (this._parseListeners !== null) {
+              this.triggerExitRuleEvent();
+            }
+            _prevctx = localctx;
+            this.state = 73;
+            this._errHandler.sync(this);
+            var la_ = this._interp.adaptivePredict(this._input, 3, this._ctx);
+            switch (la_) {
+              case 1:
+                localctx = new OrExprContext(this, new Logical_exprContext(this, _parentctx, _parentState));
+                localctx.left = _prevctx;
+                this.pushNewRecursionContext(localctx, _startState, CLQLParser.RULE_logical_expr);
+                this.state = 67;
+                if (!this.precpred(this._ctx, 5)) {
+                  throw new antlr4.error.FailedPredicateException(this, 'this.precpred(this._ctx, 5)');
+                }
+                this.state = 68;
+                this.match(CLQLParser.K_OR);
+                this.state = 69;
+                localctx.right = this.logical_expr(6);
+                break;
+              case 2:
+                localctx = new AndExprContext(this, new Logical_exprContext(this, _parentctx, _parentState));
+                localctx.left = _prevctx;
+                this.pushNewRecursionContext(localctx, _startState, CLQLParser.RULE_logical_expr);
+                this.state = 70;
+                if (!this.precpred(this._ctx, 4)) {
+                  throw new antlr4.error.FailedPredicateException(this, 'this.precpred(this._ctx, 4)');
+                }
+                this.state = 71;
+                this.match(CLQLParser.K_AND);
+                this.state = 72;
+                localctx.right = this.logical_expr(5);
+                break;
+            }
+          }
+          this.state = 77;
+          this._errHandler.sync(this);
+          _alt = this._interp.adaptivePredict(this._input, 4, this._ctx);
+        }
+      } catch (error) {
+        if (error instanceof antlr4.error.RecognitionException) {
+          localctx.exception = error;
+          this._errHandler.reportError(this, error);
+          this._errHandler.recover(this, error);
+        } else {
+          throw error;
+        }
+      } finally {
+        this.unrollRecursionContexts(_parentctx);
+      }
+      return localctx;
+    }
+  }, {
+    key: "text_expr",
+    value: function text_expr() {
+      var localctx = new Text_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 8, CLQLParser.RULE_text_expr);
+      try {
+        this.state = 81;
+        this._errHandler.sync(this);
+        switch (this._input.LA(1)) {
+          case CLQLParser.PLUS:
+          case CLQLParser.MINUS:
+          case CLQLParser.DQUOTA_STRING:
+          case CLQLParser.INTEGER_LITERAL:
+          case CLQLParser.DECIMAL_LITERAL:
+          case CLQLParser.HEXADECIMAL_LITERAL:
+          case CLQLParser.UNQUOTA_STRING:
+          case CLQLParser.FUZZY_LITERAL:
+            localctx = new TextSearchExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 1);
+            this.state = 78;
+            this.text_search_expr();
+            break;
+          case CLQLParser.REGEX:
+            localctx = new TextRegexExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 2);
+            this.state = 79;
+            this.text_regex_expr();
+            break;
+          case CLQLParser.WEI:
+            localctx = new TextRegexModelExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 3);
+            this.state = 80;
+            this.text_regex_model_expr();
+            break;
+          default:
+            throw new antlr4.error.NoViableAltException(this);
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "text_regex_expr",
+    value: function text_regex_expr() {
+      var localctx = new Text_regex_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 10, CLQLParser.RULE_text_regex_expr);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 83;
+        this.match(CLQLParser.REGEX);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "text_regex_model_expr",
+    value: function text_regex_model_expr() {
+      var localctx = new Text_regex_model_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 12, CLQLParser.RULE_text_regex_model_expr);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 85;
+        this.match(CLQLParser.WEI);
+        this.state = 99;
+        this._errHandler.sync(this);
+        var la_ = this._interp.adaptivePredict(this._input, 9, this._ctx);
+        switch (la_) {
+          case 1:
+            this.state = 95;
+            this._errHandler.sync(this);
+            _la = this._input.LA(1);
+            while (_la === CLQLParser.BQUOTA_STRING || _la === CLQLParser.STAR) {
+              this.state = 87;
+              this._errHandler.sync(this);
+              _la = this._input.LA(1);
+              if (_la === CLQLParser.BQUOTA_STRING) {
+                this.state = 86;
+                this.match(CLQLParser.BQUOTA_STRING);
+              }
+              this.state = 89;
+              this.match(CLQLParser.STAR);
+              this.state = 91;
+              this._errHandler.sync(this);
+              var la_ = this._interp.adaptivePredict(this._input, 7, this._ctx);
+              if (la_ === 1) {
+                this.state = 90;
+                this.match(CLQLParser.BQUOTA_STRING);
+              }
+              this.state = 97;
+              this._errHandler.sync(this);
+              _la = this._input.LA(1);
+            }
+            break;
+          case 2:
+            this.state = 98;
+            this.match(CLQLParser.BQUOTA_STRING);
+            break;
+        }
+        this.state = 101;
+        this.match(CLQLParser.WEI);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "comparison_expr",
+    value: function comparison_expr() {
+      var localctx = new Comparison_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 14, CLQLParser.RULE_comparison_expr);
+      try {
+        localctx = new NumberCompareExprContext(this, localctx);
+        this.enterOuterAlt(localctx, 1);
+        this.state = 103;
+        localctx.left = this.primary_expr();
+        this.state = 104;
+        this.comparison_number_operator();
+        this.state = 105;
+        localctx.right = this.primary_expr();
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "field_expr",
+    value: function field_expr() {
+      var localctx = new Field_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 16, CLQLParser.RULE_field_expr);
+      var _la = 0; // Token type
+      try {
+        this.state = 134;
+        this._errHandler.sync(this);
+        var la_ = this._interp.adaptivePredict(this._input, 11, this._ctx);
+        switch (la_) {
+          case 1:
+            localctx = new FieldValueExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 1);
+            this.state = 107;
+            localctx.left = this.field();
+            this.state = 108;
+            this.match(CLQLParser.COLON);
+            this.state = 109;
+            localctx.right = this.fuzzy_literal_value();
+            break;
+          case 2:
+            localctx = new FieldRangeExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 2);
+            this.state = 111;
+            this.field();
+            this.state = 112;
+            this.match(CLQLParser.COLON);
+            this.state = 113;
+            _la = this._input.LA(1);
+            if (!(_la === CLQLParser.LBRAKET || _la === CLQLParser.LCURLY)) {
+              this._errHandler.recoverInline(this);
+            } else {
+              this._errHandler.reportMatch(this);
+              this.consume();
+            }
+            this.state = 114;
+            this.number_literal();
+            this.state = 115;
+            this.match(CLQLParser.K_TO);
+            this.state = 116;
+            this.number_literal();
+            this.state = 117;
+            _la = this._input.LA(1);
+            if (!(_la === CLQLParser.RBRAKET || _la === CLQLParser.RCURLY)) {
+              this._errHandler.recoverInline(this);
+            } else {
+              this._errHandler.reportMatch(this);
+              this.consume();
+            }
+            break;
+          case 3:
+            localctx = new FieldInExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 3);
+            this.state = 119;
+            this.field();
+            this.state = 120;
+            this.match(CLQLParser.COLON);
+            this.state = 121;
+            this.match(CLQLParser.LPAREN);
+            this.state = 122;
+            this.literal_value();
+            this.state = 127;
+            this._errHandler.sync(this);
+            _la = this._input.LA(1);
+            while (_la === CLQLParser.K_OR) {
+              this.state = 123;
+              this.match(CLQLParser.K_OR);
+              this.state = 124;
+              this.literal_value();
+              this.state = 129;
+              this._errHandler.sync(this);
+              _la = this._input.LA(1);
+            }
+            this.state = 130;
+            this.match(CLQLParser.RPAREN);
+            break;
+          case 4:
+            localctx = new FieldExistExprContext(this, localctx);
+            this.enterOuterAlt(localctx, 4);
+            this.state = 132;
+            this.match(CLQLParser.WAVE);
+            this.state = 133;
+            this.field();
+            break;
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "text_search_expr",
+    value: function text_search_expr() {
+      var localctx = new Text_search_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 18, CLQLParser.RULE_text_search_expr);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 136;
+        this.fuzzy_literal_value();
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "primary_expr",
+    value: function primary_expr() {
+      var localctx = new Primary_exprContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 20, CLQLParser.RULE_primary_expr);
+      try {
+        this.state = 140;
+        this._errHandler.sync(this);
+        var la_ = this._interp.adaptivePredict(this._input, 12, this._ctx);
+        switch (la_) {
+          case 1:
+            this.enterOuterAlt(localctx, 1);
+            this.state = 138;
+            this.field();
+            break;
+          case 2:
+            this.enterOuterAlt(localctx, 2);
+            this.state = 139;
+            this.literal_value();
+            break;
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "field",
+    value: function field() {
+      var localctx = new FieldContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 22, CLQLParser.RULE_field);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 142;
+        this.match(CLQLParser.UNQUOTA_STRING);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "fuzzy_literal_value",
+    value: function fuzzy_literal_value() {
+      var localctx = new Fuzzy_literal_valueContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 24, CLQLParser.RULE_fuzzy_literal_value);
+      try {
+        this.state = 146;
+        this._errHandler.sync(this);
+        switch (this._input.LA(1)) {
+          case CLQLParser.FUZZY_LITERAL:
+            this.enterOuterAlt(localctx, 1);
+            this.state = 144;
+            this.fuzzy_literal();
+            break;
+          case CLQLParser.PLUS:
+          case CLQLParser.MINUS:
+          case CLQLParser.DQUOTA_STRING:
+          case CLQLParser.INTEGER_LITERAL:
+          case CLQLParser.DECIMAL_LITERAL:
+          case CLQLParser.HEXADECIMAL_LITERAL:
+          case CLQLParser.UNQUOTA_STRING:
+            this.enterOuterAlt(localctx, 2);
+            this.state = 145;
+            this.literal_value();
+            break;
+          default:
+            throw new antlr4.error.NoViableAltException(this);
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "fuzzy_literal",
+    value: function fuzzy_literal() {
+      var localctx = new Fuzzy_literalContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 26, CLQLParser.RULE_fuzzy_literal);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 148;
+        this.match(CLQLParser.FUZZY_LITERAL);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "literal_value",
+    value: function literal_value() {
+      var localctx = new Literal_valueContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 28, CLQLParser.RULE_literal_value);
+      try {
+        this.state = 152;
+        this._errHandler.sync(this);
+        switch (this._input.LA(1)) {
+          case CLQLParser.DQUOTA_STRING:
+          case CLQLParser.UNQUOTA_STRING:
+            this.enterOuterAlt(localctx, 1);
+            this.state = 150;
+            this.string_literal();
+            break;
+          case CLQLParser.PLUS:
+          case CLQLParser.MINUS:
+          case CLQLParser.INTEGER_LITERAL:
+          case CLQLParser.DECIMAL_LITERAL:
+          case CLQLParser.HEXADECIMAL_LITERAL:
+            this.enterOuterAlt(localctx, 2);
+            this.state = 151;
+            this.number_literal();
+            break;
+          default:
+            throw new antlr4.error.NoViableAltException(this);
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "string_literal",
+    value: function string_literal() {
+      var localctx = new String_literalContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 30, CLQLParser.RULE_string_literal);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 154;
+        _la = this._input.LA(1);
+        if (!(_la === CLQLParser.DQUOTA_STRING || _la === CLQLParser.UNQUOTA_STRING)) {
+          this._errHandler.recoverInline(this);
+        } else {
+          this._errHandler.reportMatch(this);
+          this.consume();
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "number_literal",
+    value: function number_literal() {
+      var localctx = new Number_literalContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 32, CLQLParser.RULE_number_literal);
+      try {
+        this.state = 158;
+        this._errHandler.sync(this);
+        var la_ = this._interp.adaptivePredict(this._input, 15, this._ctx);
+        switch (la_) {
+          case 1:
+            this.enterOuterAlt(localctx, 1);
+            this.state = 156;
+            this.integer_literal();
+            break;
+          case 2:
+            this.enterOuterAlt(localctx, 2);
+            this.state = 157;
+            this.decimal_literal();
+            break;
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "integer_literal",
+    value: function integer_literal() {
+      var localctx = new Integer_literalContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 34, CLQLParser.RULE_integer_literal);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 161;
+        this._errHandler.sync(this);
+        _la = this._input.LA(1);
+        if (_la === CLQLParser.PLUS || _la === CLQLParser.MINUS) {
+          this.state = 160;
+          _la = this._input.LA(1);
+          if (!(_la === CLQLParser.PLUS || _la === CLQLParser.MINUS)) {
+            this._errHandler.recoverInline(this);
+          } else {
+            this._errHandler.reportMatch(this);
+            this.consume();
+          }
+        }
+        this.state = 163;
+        this.match(CLQLParser.INTEGER_LITERAL);
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "decimal_literal",
+    value: function decimal_literal() {
+      var localctx = new Decimal_literalContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 36, CLQLParser.RULE_decimal_literal);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 166;
+        this._errHandler.sync(this);
+        _la = this._input.LA(1);
+        if (_la === CLQLParser.PLUS || _la === CLQLParser.MINUS) {
+          this.state = 165;
+          _la = this._input.LA(1);
+          if (!(_la === CLQLParser.PLUS || _la === CLQLParser.MINUS)) {
+            this._errHandler.recoverInline(this);
+          } else {
+            this._errHandler.reportMatch(this);
+            this.consume();
+          }
+        }
+        this.state = 168;
+        _la = this._input.LA(1);
+        if (!(_la === CLQLParser.DECIMAL_LITERAL || _la === CLQLParser.HEXADECIMAL_LITERAL)) {
+          this._errHandler.recoverInline(this);
+        } else {
+          this._errHandler.reportMatch(this);
+          this.consume();
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "comparison_number_operator",
+    value: function comparison_number_operator() {
+      var localctx = new Comparison_number_operatorContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 38, CLQLParser.RULE_comparison_number_operator);
+      var _la = 0; // Token type
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 170;
+        _la = this._input.LA(1);
+        if (!((_la & ~0x1f) == 0 && (1 << _la & (1 << CLQLParser.LT | 1 << CLQLParser.GT | 1 << CLQLParser.LE | 1 << CLQLParser.GE)) !== 0)) {
+          this._errHandler.recoverInline(this);
+        } else {
+          this._errHandler.reportMatch(this);
+          this.consume();
+        }
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }, {
+    key: "err",
+    value: function err() {
+      var localctx = new ErrContext(this, this._ctx, this.state);
+      this.enterRule(localctx, 40, CLQLParser.RULE_err);
+      try {
+        this.enterOuterAlt(localctx, 1);
+        this.state = 172;
+        localctx._UNEXPECTED_CHAR = this.match(CLQLParser.UNEXPECTED_CHAR);
+        throw new Error('UNEXPECTED_CHAR=' + (localctx._UNEXPECTED_CHAR === null ? null : localctx._UNEXPECTED_CHAR.text));
+      } catch (re) {
+        if (re instanceof antlr4.error.RecognitionException) {
+          localctx.exception = re;
+          this._errHandler.reportError(this, re);
+          this._errHandler.recover(this, re);
+        } else {
+          throw re;
+        }
+      } finally {
+        this.exitRule();
+      }
+      return localctx;
+    }
+  }]);
+  return CLQLParser;
+}(antlr4.Parser);
+_defineProperty(CLQLParser, "grammarFileName", 'CLQLParser.g4');
+_defineProperty(CLQLParser, "literalNames", [null, "'#'", null, null, null, null, "':'", "'('", "')'", "'<'", "'>'", "'<='", "'>='", "'?'", "'*'", "'['", "']'", "'{'", "'}'", "'~'", "'+'", "'-'"]);
+_defineProperty(CLQLParser, "symbolicNames", [null, 'WEI', 'REGEX', 'BQUOTA_STRING', 'LINE_COMMENT', 'SPACES', 'COLON', 'LPAREN', 'RPAREN', 'LT', 'GT', 'LE', 'GE', 'QUESTION', 'STAR', 'LBRAKET', 'RBRAKET', 'LCURLY', 'RCURLY', 'WAVE', 'PLUS', 'MINUS', 'K_AND', 'K_NOT', 'K_OR', 'K_TO', 'DQUOTA_STRING', 'INTEGER_LITERAL', 'DECIMAL_LITERAL', 'HEXADECIMAL_LITERAL', 'UNQUOTA_STRING', 'UNEXPECTED_CHAR', 'FUZZY_LITERAL']);
+_defineProperty(CLQLParser, "ruleNames", ['root', 'cqlStatement', 'search', 'logical_expr', 'text_expr', 'text_regex_expr', 'text_regex_model_expr', 'comparison_expr', 'field_expr', 'text_search_expr', 'primary_expr', 'field', 'fuzzy_literal_value', 'fuzzy_literal', 'literal_value', 'string_literal', 'number_literal', 'integer_literal', 'decimal_literal', 'comparison_number_operator', 'err']);
+export { CLQLParser as default };
+CLQLParser.EOF = antlr4.Token.EOF;
+CLQLParser.WEI = 1;
+CLQLParser.REGEX = 2;
+CLQLParser.BQUOTA_STRING = 3;
+CLQLParser.LINE_COMMENT = 4;
+CLQLParser.SPACES = 5;
+CLQLParser.COLON = 6;
+CLQLParser.LPAREN = 7;
+CLQLParser.RPAREN = 8;
+CLQLParser.LT = 9;
+CLQLParser.GT = 10;
+CLQLParser.LE = 11;
+CLQLParser.GE = 12;
+CLQLParser.QUESTION = 13;
+CLQLParser.STAR = 14;
+CLQLParser.LBRAKET = 15;
+CLQLParser.RBRAKET = 16;
+CLQLParser.LCURLY = 17;
+CLQLParser.RCURLY = 18;
+CLQLParser.WAVE = 19;
+CLQLParser.PLUS = 20;
+CLQLParser.MINUS = 21;
+CLQLParser.K_AND = 22;
+CLQLParser.K_NOT = 23;
+CLQLParser.K_OR = 24;
+CLQLParser.K_TO = 25;
+CLQLParser.DQUOTA_STRING = 26;
+CLQLParser.INTEGER_LITERAL = 27;
+CLQLParser.DECIMAL_LITERAL = 28;
+CLQLParser.HEXADECIMAL_LITERAL = 29;
+CLQLParser.UNQUOTA_STRING = 30;
+CLQLParser.UNEXPECTED_CHAR = 31;
+CLQLParser.FUZZY_LITERAL = 32;
+CLQLParser.RULE_root = 0;
+CLQLParser.RULE_cqlStatement = 1;
+CLQLParser.RULE_search = 2;
+CLQLParser.RULE_logical_expr = 3;
+CLQLParser.RULE_text_expr = 4;
+CLQLParser.RULE_text_regex_expr = 5;
+CLQLParser.RULE_text_regex_model_expr = 6;
+CLQLParser.RULE_comparison_expr = 7;
+CLQLParser.RULE_field_expr = 8;
+CLQLParser.RULE_text_search_expr = 9;
+CLQLParser.RULE_primary_expr = 10;
+CLQLParser.RULE_field = 11;
+CLQLParser.RULE_fuzzy_literal_value = 12;
+CLQLParser.RULE_fuzzy_literal = 13;
+CLQLParser.RULE_literal_value = 14;
+CLQLParser.RULE_string_literal = 15;
+CLQLParser.RULE_number_literal = 16;
+CLQLParser.RULE_integer_literal = 17;
+CLQLParser.RULE_decimal_literal = 18;
+CLQLParser.RULE_comparison_number_operator = 19;
+CLQLParser.RULE_err = 20;
+var RootContext = /*#__PURE__*/function (_antlr4$ParserRuleCon) {
+  _inherits(RootContext, _antlr4$ParserRuleCon);
+  var _super2 = _createSuper(RootContext);
+  function RootContext(parser, parent, invokingState) {
+    var _this2;
+    _classCallCheck(this, RootContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this2 = _super2.call(this, parent, invokingState);
+    _this2.parser = parser;
+    _this2.ruleIndex = CLQLParser.RULE_root;
+    return _this2;
+  }
+  _createClass(RootContext, [{
+    key: "EOF",
+    value: function EOF() {
+      return this.getToken(CLQLParser.EOF, 0);
+    }
+  }, {
+    key: "cqlStatement",
+    value: function cqlStatement() {
+      return this.getTypedRuleContext(CqlStatementContext, 0);
+    }
+  }, {
+    key: "err",
+    value: function err() {
+      return this.getTypedRuleContext(ErrContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterRoot(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitRoot(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitRoot(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return RootContext;
+}(antlr4.ParserRuleContext);
+var CqlStatementContext = /*#__PURE__*/function (_antlr4$ParserRuleCon2) {
+  _inherits(CqlStatementContext, _antlr4$ParserRuleCon2);
+  var _super3 = _createSuper(CqlStatementContext);
+  function CqlStatementContext(parser, parent, invokingState) {
+    var _this3;
+    _classCallCheck(this, CqlStatementContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this3 = _super3.call(this, parent, invokingState);
+    _this3.parser = parser;
+    _this3.ruleIndex = CLQLParser.RULE_cqlStatement;
+    return _this3;
+  }
+  _createClass(CqlStatementContext, [{
+    key: "search",
+    value: function search() {
+      return this.getTypedRuleContext(SearchContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterCqlStatement(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitCqlStatement(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitCqlStatement(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return CqlStatementContext;
+}(antlr4.ParserRuleContext);
+var SearchContext = /*#__PURE__*/function (_antlr4$ParserRuleCon3) {
+  _inherits(SearchContext, _antlr4$ParserRuleCon3);
+  var _super4 = _createSuper(SearchContext);
+  function SearchContext(parser, parent, invokingState) {
+    var _this4;
+    _classCallCheck(this, SearchContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this4 = _super4.call(this, parent, invokingState);
+    _defineProperty(_assertThisInitialized(_this4), "logical_expr", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Logical_exprContext);
+      } else {
+        return this.getTypedRuleContext(Logical_exprContext, i);
+      }
+    });
+    _this4.parser = parser;
+    _this4.ruleIndex = CLQLParser.RULE_search;
+    return _this4;
+  }
+  _createClass(SearchContext, [{
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterSearch(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitSearch(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitSearch(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return SearchContext;
+}(antlr4.ParserRuleContext);
+var Logical_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon4) {
+  _inherits(Logical_exprContext, _antlr4$ParserRuleCon4);
+  var _super5 = _createSuper(Logical_exprContext);
+  function Logical_exprContext(parser, parent, invokingState) {
+    var _this5;
+    _classCallCheck(this, Logical_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this5 = _super5.call(this, parent, invokingState);
+    _this5.parser = parser;
+    _this5.ruleIndex = CLQLParser.RULE_logical_expr;
+    return _this5;
+  }
+  _createClass(Logical_exprContext, [{
+    key: "copyFrom",
+    value: function copyFrom(ctx) {
+      _get(_getPrototypeOf(Logical_exprContext.prototype), "copyFrom", this).call(this, ctx);
+    }
+  }]);
+  return Logical_exprContext;
+}(antlr4.ParserRuleContext);
+var NotExprContext = /*#__PURE__*/function (_Logical_exprContext) {
+  _inherits(NotExprContext, _Logical_exprContext);
+  var _super6 = _createSuper(NotExprContext);
+  function NotExprContext(parser, ctx) {
+    var _thisSuper, _this6;
+    _classCallCheck(this, NotExprContext);
+    _this6 = _super6.call(this, parser);
+    _get((_thisSuper = _assertThisInitialized(_this6), _getPrototypeOf(NotExprContext.prototype)), "copyFrom", _thisSuper).call(_thisSuper, ctx);
+    return _this6;
+  }
+  _createClass(NotExprContext, [{
+    key: "K_NOT",
+    value: function K_NOT() {
+      return this.getToken(CLQLParser.K_NOT, 0);
+    }
+  }, {
+    key: "logical_expr",
+    value: function logical_expr() {
+      return this.getTypedRuleContext(Logical_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterNotExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitNotExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitNotExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return NotExprContext;
+}(Logical_exprContext);
+CLQLParser.NotExprContext = NotExprContext;
+var TextExprContext = /*#__PURE__*/function (_Logical_exprContext2) {
+  _inherits(TextExprContext, _Logical_exprContext2);
+  var _super7 = _createSuper(TextExprContext);
+  function TextExprContext(parser, ctx) {
+    var _thisSuper2, _this7;
+    _classCallCheck(this, TextExprContext);
+    _this7 = _super7.call(this, parser);
+    _get((_thisSuper2 = _assertThisInitialized(_this7), _getPrototypeOf(TextExprContext.prototype)), "copyFrom", _thisSuper2).call(_thisSuper2, ctx);
+    return _this7;
+  }
+  _createClass(TextExprContext, [{
+    key: "text_expr",
+    value: function text_expr() {
+      return this.getTypedRuleContext(Text_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterTextExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitTextExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitTextExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return TextExprContext;
+}(Logical_exprContext);
+CLQLParser.TextExprContext = TextExprContext;
+var OrExprContext = /*#__PURE__*/function (_Logical_exprContext3) {
+  _inherits(OrExprContext, _Logical_exprContext3);
+  var _super8 = _createSuper(OrExprContext);
+  function OrExprContext(parser, ctx) {
+    var _thisSuper3, _this8;
+    _classCallCheck(this, OrExprContext);
+    _this8 = _super8.call(this, parser);
+    _defineProperty(_assertThisInitialized(_this8), "logical_expr", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Logical_exprContext);
+      } else {
+        return this.getTypedRuleContext(Logical_exprContext, i);
+      }
+    });
+    _this8.left = null; // Logical_exprContext;
+    _this8.right = null; // Logical_exprContext;
+    _get((_thisSuper3 = _assertThisInitialized(_this8), _getPrototypeOf(OrExprContext.prototype)), "copyFrom", _thisSuper3).call(_thisSuper3, ctx);
+    return _this8;
+  }
+  _createClass(OrExprContext, [{
+    key: "K_OR",
+    value: function K_OR() {
+      return this.getToken(CLQLParser.K_OR, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterOrExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitOrExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitOrExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return OrExprContext;
+}(Logical_exprContext);
+CLQLParser.OrExprContext = OrExprContext;
+var ComparisonExprContext = /*#__PURE__*/function (_Logical_exprContext4) {
+  _inherits(ComparisonExprContext, _Logical_exprContext4);
+  var _super9 = _createSuper(ComparisonExprContext);
+  function ComparisonExprContext(parser, ctx) {
+    var _thisSuper4, _this9;
+    _classCallCheck(this, ComparisonExprContext);
+    _this9 = _super9.call(this, parser);
+    _get((_thisSuper4 = _assertThisInitialized(_this9), _getPrototypeOf(ComparisonExprContext.prototype)), "copyFrom", _thisSuper4).call(_thisSuper4, ctx);
+    return _this9;
+  }
+  _createClass(ComparisonExprContext, [{
+    key: "comparison_expr",
+    value: function comparison_expr() {
+      return this.getTypedRuleContext(Comparison_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterComparisonExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitComparisonExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitComparisonExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return ComparisonExprContext;
+}(Logical_exprContext);
+CLQLParser.ComparisonExprContext = ComparisonExprContext;
+var FieldExprContext = /*#__PURE__*/function (_Logical_exprContext5) {
+  _inherits(FieldExprContext, _Logical_exprContext5);
+  var _super10 = _createSuper(FieldExprContext);
+  function FieldExprContext(parser, ctx) {
+    var _thisSuper5, _this10;
+    _classCallCheck(this, FieldExprContext);
+    _this10 = _super10.call(this, parser);
+    _get((_thisSuper5 = _assertThisInitialized(_this10), _getPrototypeOf(FieldExprContext.prototype)), "copyFrom", _thisSuper5).call(_thisSuper5, ctx);
+    return _this10;
+  }
+  _createClass(FieldExprContext, [{
+    key: "field_expr",
+    value: function field_expr() {
+      return this.getTypedRuleContext(Field_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFieldExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFieldExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFieldExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldExprContext;
+}(Logical_exprContext);
+CLQLParser.FieldExprContext = FieldExprContext;
+var ParenExprContext = /*#__PURE__*/function (_Logical_exprContext6) {
+  _inherits(ParenExprContext, _Logical_exprContext6);
+  var _super11 = _createSuper(ParenExprContext);
+  function ParenExprContext(parser, ctx) {
+    var _thisSuper6, _this11;
+    _classCallCheck(this, ParenExprContext);
+    _this11 = _super11.call(this, parser);
+    _get((_thisSuper6 = _assertThisInitialized(_this11), _getPrototypeOf(ParenExprContext.prototype)), "copyFrom", _thisSuper6).call(_thisSuper6, ctx);
+    return _this11;
+  }
+  _createClass(ParenExprContext, [{
+    key: "LPAREN",
+    value: function LPAREN() {
+      return this.getToken(CLQLParser.LPAREN, 0);
+    }
+  }, {
+    key: "logical_expr",
+    value: function logical_expr() {
+      return this.getTypedRuleContext(Logical_exprContext, 0);
+    }
+  }, {
+    key: "RPAREN",
+    value: function RPAREN() {
+      return this.getToken(CLQLParser.RPAREN, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterParenExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitParenExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitParenExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return ParenExprContext;
+}(Logical_exprContext);
+CLQLParser.ParenExprContext = ParenExprContext;
+var AndExprContext = /*#__PURE__*/function (_Logical_exprContext7) {
+  _inherits(AndExprContext, _Logical_exprContext7);
+  var _super12 = _createSuper(AndExprContext);
+  function AndExprContext(parser, ctx) {
+    var _thisSuper7, _this12;
+    _classCallCheck(this, AndExprContext);
+    _this12 = _super12.call(this, parser);
+    _defineProperty(_assertThisInitialized(_this12), "logical_expr", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Logical_exprContext);
+      } else {
+        return this.getTypedRuleContext(Logical_exprContext, i);
+      }
+    });
+    _this12.left = null; // Logical_exprContext;
+    _this12.right = null; // Logical_exprContext;
+    _get((_thisSuper7 = _assertThisInitialized(_this12), _getPrototypeOf(AndExprContext.prototype)), "copyFrom", _thisSuper7).call(_thisSuper7, ctx);
+    return _this12;
+  }
+  _createClass(AndExprContext, [{
+    key: "K_AND",
+    value: function K_AND() {
+      return this.getToken(CLQLParser.K_AND, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterAndExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitAndExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitAndExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return AndExprContext;
+}(Logical_exprContext);
+CLQLParser.AndExprContext = AndExprContext;
+var Text_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon5) {
+  _inherits(Text_exprContext, _antlr4$ParserRuleCon5);
+  var _super13 = _createSuper(Text_exprContext);
+  function Text_exprContext(parser, parent, invokingState) {
+    var _this13;
+    _classCallCheck(this, Text_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this13 = _super13.call(this, parent, invokingState);
+    _this13.parser = parser;
+    _this13.ruleIndex = CLQLParser.RULE_text_expr;
+    return _this13;
+  }
+  _createClass(Text_exprContext, [{
+    key: "copyFrom",
+    value: function copyFrom(ctx) {
+      _get(_getPrototypeOf(Text_exprContext.prototype), "copyFrom", this).call(this, ctx);
+    }
+  }]);
+  return Text_exprContext;
+}(antlr4.ParserRuleContext);
+var TextSearchExprContext = /*#__PURE__*/function (_Text_exprContext) {
+  _inherits(TextSearchExprContext, _Text_exprContext);
+  var _super14 = _createSuper(TextSearchExprContext);
+  function TextSearchExprContext(parser, ctx) {
+    var _thisSuper8, _this14;
+    _classCallCheck(this, TextSearchExprContext);
+    _this14 = _super14.call(this, parser);
+    _get((_thisSuper8 = _assertThisInitialized(_this14), _getPrototypeOf(TextSearchExprContext.prototype)), "copyFrom", _thisSuper8).call(_thisSuper8, ctx);
+    return _this14;
+  }
+  _createClass(TextSearchExprContext, [{
+    key: "text_search_expr",
+    value: function text_search_expr() {
+      return this.getTypedRuleContext(Text_search_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterTextSearchExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitTextSearchExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitTextSearchExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return TextSearchExprContext;
+}(Text_exprContext);
+CLQLParser.TextSearchExprContext = TextSearchExprContext;
+var TextRegexExprContext = /*#__PURE__*/function (_Text_exprContext2) {
+  _inherits(TextRegexExprContext, _Text_exprContext2);
+  var _super15 = _createSuper(TextRegexExprContext);
+  function TextRegexExprContext(parser, ctx) {
+    var _thisSuper9, _this15;
+    _classCallCheck(this, TextRegexExprContext);
+    _this15 = _super15.call(this, parser);
+    _get((_thisSuper9 = _assertThisInitialized(_this15), _getPrototypeOf(TextRegexExprContext.prototype)), "copyFrom", _thisSuper9).call(_thisSuper9, ctx);
+    return _this15;
+  }
+  _createClass(TextRegexExprContext, [{
+    key: "text_regex_expr",
+    value: function text_regex_expr() {
+      return this.getTypedRuleContext(Text_regex_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterTextRegexExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitTextRegexExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitTextRegexExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return TextRegexExprContext;
+}(Text_exprContext);
+CLQLParser.TextRegexExprContext = TextRegexExprContext;
+var TextRegexModelExprContext = /*#__PURE__*/function (_Text_exprContext3) {
+  _inherits(TextRegexModelExprContext, _Text_exprContext3);
+  var _super16 = _createSuper(TextRegexModelExprContext);
+  function TextRegexModelExprContext(parser, ctx) {
+    var _thisSuper10, _this16;
+    _classCallCheck(this, TextRegexModelExprContext);
+    _this16 = _super16.call(this, parser);
+    _get((_thisSuper10 = _assertThisInitialized(_this16), _getPrototypeOf(TextRegexModelExprContext.prototype)), "copyFrom", _thisSuper10).call(_thisSuper10, ctx);
+    return _this16;
+  }
+  _createClass(TextRegexModelExprContext, [{
+    key: "text_regex_model_expr",
+    value: function text_regex_model_expr() {
+      return this.getTypedRuleContext(Text_regex_model_exprContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterTextRegexModelExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitTextRegexModelExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitTextRegexModelExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return TextRegexModelExprContext;
+}(Text_exprContext);
+CLQLParser.TextRegexModelExprContext = TextRegexModelExprContext;
+var Text_regex_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon6) {
+  _inherits(Text_regex_exprContext, _antlr4$ParserRuleCon6);
+  var _super17 = _createSuper(Text_regex_exprContext);
+  function Text_regex_exprContext(parser, parent, invokingState) {
+    var _this17;
+    _classCallCheck(this, Text_regex_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this17 = _super17.call(this, parent, invokingState);
+    _this17.parser = parser;
+    _this17.ruleIndex = CLQLParser.RULE_text_regex_expr;
+    return _this17;
+  }
+  _createClass(Text_regex_exprContext, [{
+    key: "REGEX",
+    value: function REGEX() {
+      return this.getToken(CLQLParser.REGEX, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterText_regex_expr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitText_regex_expr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitText_regex_expr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Text_regex_exprContext;
+}(antlr4.ParserRuleContext);
+var Text_regex_model_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon7) {
+  _inherits(Text_regex_model_exprContext, _antlr4$ParserRuleCon7);
+  var _super18 = _createSuper(Text_regex_model_exprContext);
+  function Text_regex_model_exprContext(parser, parent, invokingState) {
+    var _this18;
+    _classCallCheck(this, Text_regex_model_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this18 = _super18.call(this, parent, invokingState);
+    _defineProperty(_assertThisInitialized(_this18), "WEI", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTokens(CLQLParser.WEI);
+      } else {
+        return this.getToken(CLQLParser.WEI, i);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this18), "BQUOTA_STRING", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTokens(CLQLParser.BQUOTA_STRING);
+      } else {
+        return this.getToken(CLQLParser.BQUOTA_STRING, i);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this18), "STAR", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTokens(CLQLParser.STAR);
+      } else {
+        return this.getToken(CLQLParser.STAR, i);
+      }
+    });
+    _this18.parser = parser;
+    _this18.ruleIndex = CLQLParser.RULE_text_regex_model_expr;
+    return _this18;
+  }
+  _createClass(Text_regex_model_exprContext, [{
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterText_regex_model_expr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitText_regex_model_expr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitText_regex_model_expr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Text_regex_model_exprContext;
+}(antlr4.ParserRuleContext);
+var Comparison_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon8) {
+  _inherits(Comparison_exprContext, _antlr4$ParserRuleCon8);
+  var _super19 = _createSuper(Comparison_exprContext);
+  function Comparison_exprContext(parser, parent, invokingState) {
+    var _this19;
+    _classCallCheck(this, Comparison_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this19 = _super19.call(this, parent, invokingState);
+    _this19.parser = parser;
+    _this19.ruleIndex = CLQLParser.RULE_comparison_expr;
+    return _this19;
+  }
+  _createClass(Comparison_exprContext, [{
+    key: "copyFrom",
+    value: function copyFrom(ctx) {
+      _get(_getPrototypeOf(Comparison_exprContext.prototype), "copyFrom", this).call(this, ctx);
+    }
+  }]);
+  return Comparison_exprContext;
+}(antlr4.ParserRuleContext);
+var NumberCompareExprContext = /*#__PURE__*/function (_Comparison_exprConte) {
+  _inherits(NumberCompareExprContext, _Comparison_exprConte);
+  var _super20 = _createSuper(NumberCompareExprContext);
+  function NumberCompareExprContext(parser, ctx) {
+    var _thisSuper11, _this20;
+    _classCallCheck(this, NumberCompareExprContext);
+    _this20 = _super20.call(this, parser);
+    _defineProperty(_assertThisInitialized(_this20), "primary_expr", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Primary_exprContext);
+      } else {
+        return this.getTypedRuleContext(Primary_exprContext, i);
+      }
+    });
+    _this20.left = null; // Primary_exprContext;
+    _this20.right = null; // Primary_exprContext;
+    _get((_thisSuper11 = _assertThisInitialized(_this20), _getPrototypeOf(NumberCompareExprContext.prototype)), "copyFrom", _thisSuper11).call(_thisSuper11, ctx);
+    return _this20;
+  }
+  _createClass(NumberCompareExprContext, [{
+    key: "comparison_number_operator",
+    value: function comparison_number_operator() {
+      return this.getTypedRuleContext(Comparison_number_operatorContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterNumberCompareExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitNumberCompareExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitNumberCompareExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return NumberCompareExprContext;
+}(Comparison_exprContext);
+CLQLParser.NumberCompareExprContext = NumberCompareExprContext;
+var Field_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon9) {
+  _inherits(Field_exprContext, _antlr4$ParserRuleCon9);
+  var _super21 = _createSuper(Field_exprContext);
+  function Field_exprContext(parser, parent, invokingState) {
+    var _this21;
+    _classCallCheck(this, Field_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this21 = _super21.call(this, parent, invokingState);
+    _this21.parser = parser;
+    _this21.ruleIndex = CLQLParser.RULE_field_expr;
+    return _this21;
+  }
+  _createClass(Field_exprContext, [{
+    key: "copyFrom",
+    value: function copyFrom(ctx) {
+      _get(_getPrototypeOf(Field_exprContext.prototype), "copyFrom", this).call(this, ctx);
+    }
+  }]);
+  return Field_exprContext;
+}(antlr4.ParserRuleContext);
+var FieldRangeExprContext = /*#__PURE__*/function (_Field_exprContext) {
+  _inherits(FieldRangeExprContext, _Field_exprContext);
+  var _super22 = _createSuper(FieldRangeExprContext);
+  function FieldRangeExprContext(parser, ctx) {
+    var _thisSuper12, _this22;
+    _classCallCheck(this, FieldRangeExprContext);
+    _this22 = _super22.call(this, parser);
+    _defineProperty(_assertThisInitialized(_this22), "number_literal", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Number_literalContext);
+      } else {
+        return this.getTypedRuleContext(Number_literalContext, i);
+      }
+    });
+    _get((_thisSuper12 = _assertThisInitialized(_this22), _getPrototypeOf(FieldRangeExprContext.prototype)), "copyFrom", _thisSuper12).call(_thisSuper12, ctx);
+    return _this22;
+  }
+  _createClass(FieldRangeExprContext, [{
+    key: "field",
+    value: function field() {
+      return this.getTypedRuleContext(FieldContext, 0);
+    }
+  }, {
+    key: "COLON",
+    value: function COLON() {
+      return this.getToken(CLQLParser.COLON, 0);
+    }
+  }, {
+    key: "K_TO",
+    value: function K_TO() {
+      return this.getToken(CLQLParser.K_TO, 0);
+    }
+  }, {
+    key: "LBRAKET",
+    value: function LBRAKET() {
+      return this.getToken(CLQLParser.LBRAKET, 0);
+    }
+  }, {
+    key: "LCURLY",
+    value: function LCURLY() {
+      return this.getToken(CLQLParser.LCURLY, 0);
+    }
+  }, {
+    key: "RBRAKET",
+    value: function RBRAKET() {
+      return this.getToken(CLQLParser.RBRAKET, 0);
+    }
+  }, {
+    key: "RCURLY",
+    value: function RCURLY() {
+      return this.getToken(CLQLParser.RCURLY, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFieldRangeExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFieldRangeExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFieldRangeExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldRangeExprContext;
+}(Field_exprContext);
+CLQLParser.FieldRangeExprContext = FieldRangeExprContext;
+var FieldValueExprContext = /*#__PURE__*/function (_Field_exprContext2) {
+  _inherits(FieldValueExprContext, _Field_exprContext2);
+  var _super23 = _createSuper(FieldValueExprContext);
+  function FieldValueExprContext(parser, ctx) {
+    var _thisSuper13, _this23;
+    _classCallCheck(this, FieldValueExprContext);
+    _this23 = _super23.call(this, parser);
+    _this23.left = null; // FieldContext;
+    _this23.right = null; // Fuzzy_literal_valueContext;
+    _get((_thisSuper13 = _assertThisInitialized(_this23), _getPrototypeOf(FieldValueExprContext.prototype)), "copyFrom", _thisSuper13).call(_thisSuper13, ctx);
+    return _this23;
+  }
+  _createClass(FieldValueExprContext, [{
+    key: "COLON",
+    value: function COLON() {
+      return this.getToken(CLQLParser.COLON, 0);
+    }
+  }, {
+    key: "field",
+    value: function field() {
+      return this.getTypedRuleContext(FieldContext, 0);
+    }
+  }, {
+    key: "fuzzy_literal_value",
+    value: function fuzzy_literal_value() {
+      return this.getTypedRuleContext(Fuzzy_literal_valueContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFieldValueExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFieldValueExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFieldValueExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldValueExprContext;
+}(Field_exprContext);
+CLQLParser.FieldValueExprContext = FieldValueExprContext;
+var FieldInExprContext = /*#__PURE__*/function (_Field_exprContext3) {
+  _inherits(FieldInExprContext, _Field_exprContext3);
+  var _super24 = _createSuper(FieldInExprContext);
+  function FieldInExprContext(parser, ctx) {
+    var _thisSuper14, _this24;
+    _classCallCheck(this, FieldInExprContext);
+    _this24 = _super24.call(this, parser);
+    _defineProperty(_assertThisInitialized(_this24), "literal_value", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTypedRuleContexts(Literal_valueContext);
+      } else {
+        return this.getTypedRuleContext(Literal_valueContext, i);
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this24), "K_OR", function (i) {
+      if (i === undefined) {
+        i = null;
+      }
+      if (i === null) {
+        return this.getTokens(CLQLParser.K_OR);
+      } else {
+        return this.getToken(CLQLParser.K_OR, i);
+      }
+    });
+    _get((_thisSuper14 = _assertThisInitialized(_this24), _getPrototypeOf(FieldInExprContext.prototype)), "copyFrom", _thisSuper14).call(_thisSuper14, ctx);
+    return _this24;
+  }
+  _createClass(FieldInExprContext, [{
+    key: "field",
+    value: function field() {
+      return this.getTypedRuleContext(FieldContext, 0);
+    }
+  }, {
+    key: "COLON",
+    value: function COLON() {
+      return this.getToken(CLQLParser.COLON, 0);
+    }
+  }, {
+    key: "LPAREN",
+    value: function LPAREN() {
+      return this.getToken(CLQLParser.LPAREN, 0);
+    }
+  }, {
+    key: "RPAREN",
+    value: function RPAREN() {
+      return this.getToken(CLQLParser.RPAREN, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFieldInExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFieldInExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFieldInExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldInExprContext;
+}(Field_exprContext);
+CLQLParser.FieldInExprContext = FieldInExprContext;
+var FieldExistExprContext = /*#__PURE__*/function (_Field_exprContext4) {
+  _inherits(FieldExistExprContext, _Field_exprContext4);
+  var _super25 = _createSuper(FieldExistExprContext);
+  function FieldExistExprContext(parser, ctx) {
+    var _thisSuper15, _this25;
+    _classCallCheck(this, FieldExistExprContext);
+    _this25 = _super25.call(this, parser);
+    _get((_thisSuper15 = _assertThisInitialized(_this25), _getPrototypeOf(FieldExistExprContext.prototype)), "copyFrom", _thisSuper15).call(_thisSuper15, ctx);
+    return _this25;
+  }
+  _createClass(FieldExistExprContext, [{
+    key: "WAVE",
+    value: function WAVE() {
+      return this.getToken(CLQLParser.WAVE, 0);
+    }
+  }, {
+    key: "field",
+    value: function field() {
+      return this.getTypedRuleContext(FieldContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFieldExistExpr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFieldExistExpr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFieldExistExpr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldExistExprContext;
+}(Field_exprContext);
+CLQLParser.FieldExistExprContext = FieldExistExprContext;
+var Text_search_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon10) {
+  _inherits(Text_search_exprContext, _antlr4$ParserRuleCon10);
+  var _super26 = _createSuper(Text_search_exprContext);
+  function Text_search_exprContext(parser, parent, invokingState) {
+    var _this26;
+    _classCallCheck(this, Text_search_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this26 = _super26.call(this, parent, invokingState);
+    _this26.parser = parser;
+    _this26.ruleIndex = CLQLParser.RULE_text_search_expr;
+    return _this26;
+  }
+  _createClass(Text_search_exprContext, [{
+    key: "fuzzy_literal_value",
+    value: function fuzzy_literal_value() {
+      return this.getTypedRuleContext(Fuzzy_literal_valueContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterText_search_expr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitText_search_expr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitText_search_expr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Text_search_exprContext;
+}(antlr4.ParserRuleContext);
+var Primary_exprContext = /*#__PURE__*/function (_antlr4$ParserRuleCon11) {
+  _inherits(Primary_exprContext, _antlr4$ParserRuleCon11);
+  var _super27 = _createSuper(Primary_exprContext);
+  function Primary_exprContext(parser, parent, invokingState) {
+    var _this27;
+    _classCallCheck(this, Primary_exprContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this27 = _super27.call(this, parent, invokingState);
+    _this27.parser = parser;
+    _this27.ruleIndex = CLQLParser.RULE_primary_expr;
+    return _this27;
+  }
+  _createClass(Primary_exprContext, [{
+    key: "field",
+    value: function field() {
+      return this.getTypedRuleContext(FieldContext, 0);
+    }
+  }, {
+    key: "literal_value",
+    value: function literal_value() {
+      return this.getTypedRuleContext(Literal_valueContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterPrimary_expr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitPrimary_expr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitPrimary_expr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Primary_exprContext;
+}(antlr4.ParserRuleContext);
+var FieldContext = /*#__PURE__*/function (_antlr4$ParserRuleCon12) {
+  _inherits(FieldContext, _antlr4$ParserRuleCon12);
+  var _super28 = _createSuper(FieldContext);
+  function FieldContext(parser, parent, invokingState) {
+    var _this28;
+    _classCallCheck(this, FieldContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this28 = _super28.call(this, parent, invokingState);
+    _this28.parser = parser;
+    _this28.ruleIndex = CLQLParser.RULE_field;
+    return _this28;
+  }
+  _createClass(FieldContext, [{
+    key: "UNQUOTA_STRING",
+    value: function UNQUOTA_STRING() {
+      return this.getToken(CLQLParser.UNQUOTA_STRING, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterField(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitField(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitField(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return FieldContext;
+}(antlr4.ParserRuleContext);
+var Fuzzy_literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon13) {
+  _inherits(Fuzzy_literal_valueContext, _antlr4$ParserRuleCon13);
+  var _super29 = _createSuper(Fuzzy_literal_valueContext);
+  function Fuzzy_literal_valueContext(parser, parent, invokingState) {
+    var _this29;
+    _classCallCheck(this, Fuzzy_literal_valueContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this29 = _super29.call(this, parent, invokingState);
+    _this29.parser = parser;
+    _this29.ruleIndex = CLQLParser.RULE_fuzzy_literal_value;
+    return _this29;
+  }
+  _createClass(Fuzzy_literal_valueContext, [{
+    key: "fuzzy_literal",
+    value: function fuzzy_literal() {
+      return this.getTypedRuleContext(Fuzzy_literalContext, 0);
+    }
+  }, {
+    key: "literal_value",
+    value: function literal_value() {
+      return this.getTypedRuleContext(Literal_valueContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFuzzy_literal_value(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFuzzy_literal_value(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFuzzy_literal_value(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Fuzzy_literal_valueContext;
+}(antlr4.ParserRuleContext);
+var Fuzzy_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon14) {
+  _inherits(Fuzzy_literalContext, _antlr4$ParserRuleCon14);
+  var _super30 = _createSuper(Fuzzy_literalContext);
+  function Fuzzy_literalContext(parser, parent, invokingState) {
+    var _this30;
+    _classCallCheck(this, Fuzzy_literalContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this30 = _super30.call(this, parent, invokingState);
+    _this30.parser = parser;
+    _this30.ruleIndex = CLQLParser.RULE_fuzzy_literal;
+    return _this30;
+  }
+  _createClass(Fuzzy_literalContext, [{
+    key: "FUZZY_LITERAL",
+    value: function FUZZY_LITERAL() {
+      return this.getToken(CLQLParser.FUZZY_LITERAL, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterFuzzy_literal(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitFuzzy_literal(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitFuzzy_literal(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Fuzzy_literalContext;
+}(antlr4.ParserRuleContext);
+var Literal_valueContext = /*#__PURE__*/function (_antlr4$ParserRuleCon15) {
+  _inherits(Literal_valueContext, _antlr4$ParserRuleCon15);
+  var _super31 = _createSuper(Literal_valueContext);
+  function Literal_valueContext(parser, parent, invokingState) {
+    var _this31;
+    _classCallCheck(this, Literal_valueContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this31 = _super31.call(this, parent, invokingState);
+    _this31.parser = parser;
+    _this31.ruleIndex = CLQLParser.RULE_literal_value;
+    return _this31;
+  }
+  _createClass(Literal_valueContext, [{
+    key: "string_literal",
+    value: function string_literal() {
+      return this.getTypedRuleContext(String_literalContext, 0);
+    }
+  }, {
+    key: "number_literal",
+    value: function number_literal() {
+      return this.getTypedRuleContext(Number_literalContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterLiteral_value(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitLiteral_value(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitLiteral_value(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Literal_valueContext;
+}(antlr4.ParserRuleContext);
+var String_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon16) {
+  _inherits(String_literalContext, _antlr4$ParserRuleCon16);
+  var _super32 = _createSuper(String_literalContext);
+  function String_literalContext(parser, parent, invokingState) {
+    var _this32;
+    _classCallCheck(this, String_literalContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this32 = _super32.call(this, parent, invokingState);
+    _this32.parser = parser;
+    _this32.ruleIndex = CLQLParser.RULE_string_literal;
+    return _this32;
+  }
+  _createClass(String_literalContext, [{
+    key: "UNQUOTA_STRING",
+    value: function UNQUOTA_STRING() {
+      return this.getToken(CLQLParser.UNQUOTA_STRING, 0);
+    }
+  }, {
+    key: "DQUOTA_STRING",
+    value: function DQUOTA_STRING() {
+      return this.getToken(CLQLParser.DQUOTA_STRING, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterString_literal(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitString_literal(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitString_literal(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return String_literalContext;
+}(antlr4.ParserRuleContext);
+var Number_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon17) {
+  _inherits(Number_literalContext, _antlr4$ParserRuleCon17);
+  var _super33 = _createSuper(Number_literalContext);
+  function Number_literalContext(parser, parent, invokingState) {
+    var _this33;
+    _classCallCheck(this, Number_literalContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this33 = _super33.call(this, parent, invokingState);
+    _this33.parser = parser;
+    _this33.ruleIndex = CLQLParser.RULE_number_literal;
+    return _this33;
+  }
+  _createClass(Number_literalContext, [{
+    key: "integer_literal",
+    value: function integer_literal() {
+      return this.getTypedRuleContext(Integer_literalContext, 0);
+    }
+  }, {
+    key: "decimal_literal",
+    value: function decimal_literal() {
+      return this.getTypedRuleContext(Decimal_literalContext, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterNumber_literal(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitNumber_literal(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitNumber_literal(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Number_literalContext;
+}(antlr4.ParserRuleContext);
+var Integer_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon18) {
+  _inherits(Integer_literalContext, _antlr4$ParserRuleCon18);
+  var _super34 = _createSuper(Integer_literalContext);
+  function Integer_literalContext(parser, parent, invokingState) {
+    var _this34;
+    _classCallCheck(this, Integer_literalContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this34 = _super34.call(this, parent, invokingState);
+    _this34.parser = parser;
+    _this34.ruleIndex = CLQLParser.RULE_integer_literal;
+    return _this34;
+  }
+  _createClass(Integer_literalContext, [{
+    key: "INTEGER_LITERAL",
+    value: function INTEGER_LITERAL() {
+      return this.getToken(CLQLParser.INTEGER_LITERAL, 0);
+    }
+  }, {
+    key: "PLUS",
+    value: function PLUS() {
+      return this.getToken(CLQLParser.PLUS, 0);
+    }
+  }, {
+    key: "MINUS",
+    value: function MINUS() {
+      return this.getToken(CLQLParser.MINUS, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterInteger_literal(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitInteger_literal(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitInteger_literal(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Integer_literalContext;
+}(antlr4.ParserRuleContext);
+var Decimal_literalContext = /*#__PURE__*/function (_antlr4$ParserRuleCon19) {
+  _inherits(Decimal_literalContext, _antlr4$ParserRuleCon19);
+  var _super35 = _createSuper(Decimal_literalContext);
+  function Decimal_literalContext(parser, parent, invokingState) {
+    var _this35;
+    _classCallCheck(this, Decimal_literalContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this35 = _super35.call(this, parent, invokingState);
+    _this35.parser = parser;
+    _this35.ruleIndex = CLQLParser.RULE_decimal_literal;
+    return _this35;
+  }
+  _createClass(Decimal_literalContext, [{
+    key: "DECIMAL_LITERAL",
+    value: function DECIMAL_LITERAL() {
+      return this.getToken(CLQLParser.DECIMAL_LITERAL, 0);
+    }
+  }, {
+    key: "HEXADECIMAL_LITERAL",
+    value: function HEXADECIMAL_LITERAL() {
+      return this.getToken(CLQLParser.HEXADECIMAL_LITERAL, 0);
+    }
+  }, {
+    key: "PLUS",
+    value: function PLUS() {
+      return this.getToken(CLQLParser.PLUS, 0);
+    }
+  }, {
+    key: "MINUS",
+    value: function MINUS() {
+      return this.getToken(CLQLParser.MINUS, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterDecimal_literal(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitDecimal_literal(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitDecimal_literal(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Decimal_literalContext;
+}(antlr4.ParserRuleContext);
+var Comparison_number_operatorContext = /*#__PURE__*/function (_antlr4$ParserRuleCon20) {
+  _inherits(Comparison_number_operatorContext, _antlr4$ParserRuleCon20);
+  var _super36 = _createSuper(Comparison_number_operatorContext);
+  function Comparison_number_operatorContext(parser, parent, invokingState) {
+    var _this36;
+    _classCallCheck(this, Comparison_number_operatorContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this36 = _super36.call(this, parent, invokingState);
+    _this36.parser = parser;
+    _this36.ruleIndex = CLQLParser.RULE_comparison_number_operator;
+    return _this36;
+  }
+  _createClass(Comparison_number_operatorContext, [{
+    key: "LT",
+    value: function LT() {
+      return this.getToken(CLQLParser.LT, 0);
+    }
+  }, {
+    key: "GT",
+    value: function GT() {
+      return this.getToken(CLQLParser.GT, 0);
+    }
+  }, {
+    key: "LE",
+    value: function LE() {
+      return this.getToken(CLQLParser.LE, 0);
+    }
+  }, {
+    key: "GE",
+    value: function GE() {
+      return this.getToken(CLQLParser.GE, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterComparison_number_operator(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitComparison_number_operator(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitComparison_number_operator(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return Comparison_number_operatorContext;
+}(antlr4.ParserRuleContext);
+var ErrContext = /*#__PURE__*/function (_antlr4$ParserRuleCon21) {
+  _inherits(ErrContext, _antlr4$ParserRuleCon21);
+  var _super37 = _createSuper(ErrContext);
+  function ErrContext(parser, parent, invokingState) {
+    var _this37;
+    _classCallCheck(this, ErrContext);
+    if (parent === undefined) {
+      parent = null;
+    }
+    if (invokingState === undefined || invokingState === null) {
+      invokingState = -1;
+    }
+    _this37 = _super37.call(this, parent, invokingState);
+    _this37.parser = parser;
+    _this37.ruleIndex = CLQLParser.RULE_err;
+    _this37._UNEXPECTED_CHAR = null; // Token
+    return _this37;
+  }
+  _createClass(ErrContext, [{
+    key: "UNEXPECTED_CHAR",
+    value: function UNEXPECTED_CHAR() {
+      return this.getToken(CLQLParser.UNEXPECTED_CHAR, 0);
+    }
+  }, {
+    key: "enterRule",
+    value: function enterRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.enterErr(this);
+      }
+    }
+  }, {
+    key: "exitRule",
+    value: function exitRule(listener) {
+      if (listener instanceof CLQLParserListener) {
+        listener.exitErr(this);
+      }
+    }
+  }, {
+    key: "accept",
+    value: function accept(visitor) {
+      if (visitor instanceof CLQLParserVisitor) {
+        return visitor.visitErr(this);
+      } else {
+        return visitor.visitChildren(this);
+      }
+    }
+  }]);
+  return ErrContext;
+}(antlr4.ParserRuleContext);
+CLQLParser.RootContext = RootContext;
+CLQLParser.CqlStatementContext = CqlStatementContext;
+CLQLParser.SearchContext = SearchContext;
+CLQLParser.Logical_exprContext = Logical_exprContext;
+CLQLParser.Text_exprContext = Text_exprContext;
+CLQLParser.Text_regex_exprContext = Text_regex_exprContext;
+CLQLParser.Text_regex_model_exprContext = Text_regex_model_exprContext;
+CLQLParser.Comparison_exprContext = Comparison_exprContext;
+CLQLParser.Field_exprContext = Field_exprContext;
+CLQLParser.Text_search_exprContext = Text_search_exprContext;
+CLQLParser.Primary_exprContext = Primary_exprContext;
+CLQLParser.FieldContext = FieldContext;
+CLQLParser.Fuzzy_literal_valueContext = Fuzzy_literal_valueContext;
+CLQLParser.Fuzzy_literalContext = Fuzzy_literalContext;
+CLQLParser.Literal_valueContext = Literal_valueContext;
+CLQLParser.String_literalContext = String_literalContext;
+CLQLParser.Number_literalContext = Number_literalContext;
+CLQLParser.Integer_literalContext = Integer_literalContext;
+CLQLParser.Decimal_literalContext = Decimal_literalContext;
+CLQLParser.Comparison_number_operatorContext = Comparison_number_operatorContext;
+CLQLParser.ErrContext = ErrContext;