init: benchmarks

Author: hp4k1h5

bench/index.ts

@@ -0,0 +1,44 @@
+import { parseQuery, parseQueryEXP } from '../src/parse'
+
+const queries = [
+  '  What song was or do you want to be the your first dance at your wedding',
+  'What song would make the best theme music for you',
+  'What is the most irrational superstition you have',
+  'What is "the weirdest food" combination "you enjoy"',
+  'What is the stupidest thing you ever did on a dare',
+  'What is the worst date you have ever been on',
+  'Who is the most embarrassing person you had a crush on',
+  'What is your idea of the "perfect day"',
+  'If you could swap lives with one of your friends, who would it be',
+  'Who knows the most secrets about you',
+  // 'What are your must-have qualities in a best friend',
+  // 'If you had to get a tattoo today, what would you get',
+  // 'If you could have free meals for life at one fast food chain, which one would you choose',
+  // 'What is the most embarrassing thing your parents have ever done',
+  // 'What is a lie or exaggeration you said to impress a crush',
+  // 'What is the silliest you have ever felt',
+  // 'When was the last time you laughed so hard that you cried',
+  // 'What "does your mother yell at you" when she’s angry',
+  // 'What is a telltale sign that you are upset',
+  // 'What is your nickname',
+  // 'What is the wackiest thing you ever did to help a friend',
+  // 'What fictional character would you most like to be friends with',
+  // 'What is your favorite topic to talk about',
+]
+
+function benchIter(fn, iterations = 1) {
+  const start = new Date().valueOf()
+  for (let i = 0; i < iterations; i++) {
+    fn()
+  }
+  console.log(new Date().valueOf() - start)
+}
+
+function fun(fn) {
+  queries.forEach((q, i) => {
+    fn(q)
+  })
+}
+
+benchIter(() => fun(parseQuery))
+benchIter(() => fun(parseQueryEXP))

built/filter.d.ts

@@ -1,2 +1,2 @@
-import { filter } from './lib/structs';
-export declare function buildFilters(filters: filter[]): import("arangojs/aql").GeneratedAqlQuery;
+import { Filter } from './lib/structs';
+export declare function buildFilters(filters: Filter[]): import("arangojs/aql").GeneratedAqlQuery;

built/lib/structs.d.ts

@@ -15,15 +15,15 @@ export interface query {
     /**
      * either an array of @param term interfaces or a string to be parsed by `parseQuery()`
      * */
-    terms: term[] | string;
+    terms: Term[] | string;
     /**
      * the name(s) of the document key to search. @default "text"
      * */
     key?: string[] | string;
     /**
      * a list of @filter interfaces. All filters are implicitly AND'ed together.
      * */
-    filters?: filter[];
+    filters?: Filter[];
 }
 /**
  * Each collection referenced by the ArangoSearch that the user wishes to
@@ -60,12 +60,12 @@ export interface collection {
  *             | LEVENS | TODO | TODO| TODO  |
  * ```
  * */
-export interface term {
+export interface Term {
     /**
      * must be one of [ 'phr', 'tok' ], corresponding to `PHRASE` and
      * `TOKENS` respectively.
      **/
-    type: string;
+    type: Type;
     /**
      * the search string
      * */
@@ -74,16 +74,35 @@ export interface term {
      * must be one of [ '+', '?', '-' ] corresponding to `ANDS`, `ORS`, and
      * `NOTS`, respectively.
      * */
-    op: string;
+    op: Operator;
+}
+export declare enum Type {
+    phrase = "phr",
+    token = "tok"
+}
+export declare enum Operator {
+    AND = "+",
+    '+' = "+",
+    OR = "?",
+    '?' = "?",
+    NOT = "-",
+    '-' = "-"
 }
 /**
  * passed to AQL `FILTER`
  * */
-export interface filter {
+export interface Filter {
     /** the arango document field name to filter on */
     field: string;
     /** the high-level operator to filter by */
     op: string;
     /** the query string to filter with */
     val: string | number | Date;
 }
+export declare class Char {
+    char: string;
+    constructor(ch: string);
+    isSpace(): boolean;
+    isOperator(): boolean;
+    isQuote(): boolean;
+}

built/lib/structs.js

@@ -1,2 +1,33 @@
 "use strict";
 exports.__esModule = true;
+exports.Char = exports.Operator = exports.Type = void 0;
+var Type;
+(function (Type) {
+    Type["phrase"] = "phr";
+    Type["token"] = "tok";
+})(Type = exports.Type || (exports.Type = {}));
+var Operator;
+(function (Operator) {
+    Operator["AND"] = "+";
+    Operator["+"] = "+";
+    Operator["OR"] = "?";
+    Operator["?"] = "?";
+    Operator["NOT"] = "-";
+    Operator["-"] = "-";
+})(Operator = exports.Operator || (exports.Operator = {}));
+var Char = /** @class */ (function () {
+    function Char(ch) {
+        this.char = ch;
+    }
+    Char.prototype.isSpace = function () {
+        return /\s/.test(this.char);
+    };
+    Char.prototype.isOperator = function () {
+        return /[-+?]/.test(this.char);
+    };
+    Char.prototype.isQuote = function () {
+        return /"|'/.test(this.char);
+    };
+    return Char;
+}());
+exports.Char = Char;

built/parse.d.ts

@@ -1,2 +1,9 @@
-import { term } from './lib/structs';
-export declare function parseQuery(queryString: string): term[];
+import { Term } from './lib/structs';
+export declare function parseQuery(queryString: string): Term[];
+export declare function parseQueryEXP(queryString: string): Term[];
+export declare class ParseError extends Error {
+    char: string;
+    pos: number;
+    constructor(char: string, pos: number, message: string);
+    print(): string;
+}

built/parse.js

@@ -1,32 +1,121 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 exports.__esModule = true;
-exports.parseQuery = void 0;
+exports.ParseError = exports.parseQueryEXP = exports.parseQuery = void 0;
+var structs_1 = require("./lib/structs");
 function parseQuery(queryString) {
     var queryRgx = /[+?-]?(["'(]).+?(\1|\))|[^"'()\s]+/g;
     var matches = queryString.match(queryRgx);
     if (!matches)
         return [];
     return matches.map(function (match) {
         /* strip op */
-        var op = '?';
+        var op = structs_1.Operator.OR;
         if (/[+?-]/.test(match[0])) {
-            op = match[0];
+            op = structs_1.Operator[match[0]];
             match = match.substring(1);
         }
         if (match[0] == '"' || match[0] == "'") {
             return {
-                type: 'phr',
+                type: structs_1.Type.phrase,
                 val: match,
                 op: op
             };
         }
         else {
             return {
-                type: 'tok',
+                type: structs_1.Type.token,
                 val: match,
                 op: op
             };
         }
     });
 }
 exports.parseQuery = parseQuery;
+function parseQueryEXP(queryString) {
+    return lex(queryString);
+}
+exports.parseQueryEXP = parseQueryEXP;
+function lex(queryString) {
+    var lexes = [];
+    var curToken = '';
+    var curTokenType = structs_1.Type.token;
+    var curOperator = structs_1.Operator.OR;
+    var isToken = false;
+    for (var i = 0; i < queryString.length; i++) {
+        var ch = new structs_1.Char(queryString[i]);
+        if (ch.isSpace()) {
+            if (curToken.length) {
+                if (curTokenType === structs_1.Type.token) {
+                    isToken = true;
+                }
+                else {
+                    curToken += ch.char;
+                }
+            }
+        }
+        else if (ch.isOperator()) {
+            if (curToken.length) {
+                throw new ParseError(ch.char, i, "Logical operator must precede query term.");
+            }
+            curOperator = structs_1.Operator[ch.char];
+        }
+        else if (ch.isQuote()) {
+            if (curToken.length && curTokenType === structs_1.Type.phrase) {
+                isToken = true;
+            }
+            else {
+                curTokenType = structs_1.Type.phrase;
+            }
+        }
+        else {
+            curToken += ch.char;
+        }
+        if (isToken) {
+            resetCur();
+        }
+    }
+    if (curToken.length) {
+        resetCur();
+    }
+    function resetCur() {
+        lexes.push({
+            type: curTokenType,
+            val: curToken,
+            op: curOperator
+        });
+        curToken = '';
+        curTokenType = structs_1.Type.token;
+        curOperator = structs_1.Operator.OR;
+        isToken = false;
+    }
+    return lexes;
+}
+var ParseError = /** @class */ (function (_super) {
+    __extends(ParseError, _super);
+    function ParseError(char, pos, message) {
+        var _this = _super.call(this, message) || this;
+        _this.char = char;
+        _this.pos = pos;
+        return _this;
+    }
+    ParseError.prototype.print = function () {
+        return "err:  \u201C ".concat(this.char, " \u201D in position ").concat(this.pos, " ").concat(this.message);
+    };
+    return ParseError;
+}(Error));
+exports.ParseError = ParseError;

built/search.js

@@ -6,6 +6,7 @@ var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cook
 exports.__esModule = true;
 exports.buildSearch = void 0;
 var arangojs_1 = require("arangojs");
+var structs_1 = require("./lib/structs");
 var parse_1 = require("./parse");
 function buildSearch(query) {
     /* parse string query */
@@ -35,7 +36,7 @@ function buildOps(collections, terms, op) {
     if (!queryTerms.length)
         return;
     /* phrases */
-    var phrases = queryTerms.filter(function (qT) { return qT.type == 'phr'; });
+    var phrases = queryTerms.filter(function (qT) { return qT.type == structs_1.Type.phrase; });
     phrases = buildPhrases(phrases, collections, opWord);
     /* tokens */
     var tokens = queryTerms.filter(function (qT) { return qT.type === 'tok'; });

src/lib/structs.ts

@@ -120,7 +120,7 @@ export class Char {
     return /\s/.test(this.char)
   }
   isOperator() {
-    return /[+-?]/.test(this.char)
+    return /[-+?]/.test(this.char)
   }
   isQuote() {
     return /"|'/.test(this.char)