simple-graph-query 2.0.2 → 2.1.2

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export declare class SimpleGraphQueryEvaluator {
     datum: IDataInstance;
     forgeListener: ForgeListenerImpl;
     walker: ParseTreeWalker;
+    private parseTreeCache;
     constructor(datum: IDataInstance);
     getExpressionParseTree(forgeExpr: string): import("./forge-antlr/ForgeParser").ParseExprContext;
     evaluateExpression(forgeExpr: string): EvaluationResult;

package/dist/simple-graph-query.bundle.js

@@ -48473,11 +48473,17 @@ function extractNumber(val) {
 function isString(value) {
     return typeof value === "string";
 }
+// Helper to create a string key from a tuple for fast lookup
+function tupleToKey(tuple) {
+    return JSON.stringify(tuple);
+}
 function areTuplesEqual(a, b) {
     return a.length === b.length && a.every((val, i) => val === b[i]);
 }
 function isTupleArraySubset(a, b) {
-    return a.every((tupleA) => b.some((tupleB) => areTuplesEqual(tupleA, tupleB)));
+    // Optimize using Set for O(n) lookup instead of O(n²)
+    const bSet = new Set(b.map(tupleToKey));
+    return a.every((tupleA) => bSet.has(tupleToKey(tupleA)));
 }
 function areTupleArraysEqual(a, b) {
     if (a.length !== b.length) {
@@ -48486,9 +48492,13 @@ function areTupleArraysEqual(a, b) {
     return isTupleArraySubset(a, b) && isTupleArraySubset(b, a);
 }
 function deduplicateTuples(tuples) {
+    // Optimize using Set for O(n) deduplication instead of O(n²)
+    const seen = new Set();
     const result = [];
     for (const tuple of tuples) {
-        if (!result.some((existing) => areTuplesEqual(existing, tuple))) {
+        const key = tupleToKey(tuple);
+        if (!seen.has(key)) {
+            seen.add(key);
             result.push(tuple);
         }
     }
@@ -48497,15 +48507,23 @@ function deduplicateTuples(tuples) {
 function getCombinations(arrays) {
     // first, turn each string[][] into a string[] by flattening
     const valueSets = arrays.map((tuple) => tuple.flat());
-    // now, recursively compute the cartesian product
-    function cartesianProduct(arrays) {
-        if (arrays.length === 0)
-            return [[]];
-        const [first, ...rest] = arrays;
-        const restProduct = cartesianProduct(rest);
-        return first.flatMap((value) => restProduct.map((product) => [value, ...product]));
+    // Early exit for empty arrays
+    if (valueSets.length === 0)
+        return [[]];
+    if (valueSets.some(arr => arr.length === 0))
+        return [];
+    // Iterative approach for better performance on large cartesian products
+    let result = [[]];
+    for (const valueSet of valueSets) {
+        const newResult = [];
+        for (const existing of result) {
+            for (const value of valueSet) {
+                newResult.push([...existing, value]);
+            }
+        }
+        result = newResult;
     }
-    return cartesianProduct(valueSets);
+    return result;
 }
 function transitiveClosure(pairs) {
     if (pairs.length === 0)
@@ -48524,20 +48542,21 @@ function transitiveClosure(pairs) {
         }
         graph.get(from).add(to);
     }
-    // perform BFS from each node to get the transitive closure
+    // Use more efficient BFS with index-based queue to avoid O(n) shift() operations
     // NOTE: we use Set<string> instead of Set<[SingleValue, SingleValue]> since
     // TS would compute equality over the object's reference instead of the value
     // when the value is an array
-    const transitiveClosure = new Set();
+    const transitiveClosureSet = new Set();
     for (const start of graph.keys()) {
         const visited = new Set();
         const queue = [...(graph.get(start) ?? [])];
-        while (queue.length > 0) {
-            const current = queue.shift();
+        let queueIndex = 0; // Use index instead of shift() for O(1) access
+        while (queueIndex < queue.length) {
+            const current = queue[queueIndex++];
             if (visited.has(current))
                 continue;
             visited.add(current);
-            transitiveClosure.add(JSON.stringify([start, current]));
+            transitiveClosureSet.add(JSON.stringify([start, current]));
             const neighbors = graph.get(current);
             if (neighbors) {
                 for (const neighbor of neighbors) {
@@ -48549,22 +48568,34 @@ function transitiveClosure(pairs) {
         }
     }
     // convert the result back to a Tuple[] and return
-    return Array.from(transitiveClosure).map((pair) => JSON.parse(pair));
+    return Array.from(transitiveClosureSet).map((pair) => JSON.parse(pair));
 }
 function dotJoin(left, right) {
     const leftExpr = isSingleValue(left) ? [[left]] : left;
     const rightExpr = isSingleValue(right) ? [[right]] : right;
+    // Optimize join using a Map for O(n+m) instead of O(n*m) lookup
+    // Group right tuples by their first element for fast lookup
+    const rightIndex = new Map();
+    for (const rightTuple of rightExpr) {
+        const key = rightTuple[0];
+        if (!rightIndex.has(key)) {
+            rightIndex.set(key, []);
+        }
+        rightIndex.get(key).push(rightTuple);
+    }
     const result = [];
-    leftExpr.forEach((leftTuple) => {
-        rightExpr.forEach((rightTuple) => {
-            if (leftTuple[leftTuple.length - 1] === rightTuple[0]) {
+    for (const leftTuple of leftExpr) {
+        const joinKey = leftTuple[leftTuple.length - 1];
+        const matchingRightTuples = rightIndex.get(joinKey);
+        if (matchingRightTuples) {
+            for (const rightTuple of matchingRightTuples) {
                 result.push([
                     ...leftTuple.slice(0, leftTuple.length - 1),
                     ...rightTuple.slice(1),
                 ]);
             }
-        });
-    });
+        }
+    }
     if (result.some(tuple => tuple.length === 0)) {
         throw new Error("Join would create a relation of arity 0");
     }
@@ -48628,7 +48659,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     constructFreeVariableKey(freeVarValues) {
         const keys = Object.keys(freeVarValues);
         keys.sort(); // sort the keys to ensure consistent ordering
-        return keys.map((key) => `${key}=${freeVarValues[key]}`).join("|");
+        // Use JSON.stringify for complex values to ensure proper serialization
+        return keys.map((key) => {
+            const value = freeVarValues[key];
+            const valueStr = Array.isArray(value) ? JSON.stringify(value) : String(value);
+            return `${key}=${valueStr}`;
+        }).join("|");
     }
     // helper function to get the label for a value (used for @: operator)
     getLabelForValue(value) {
@@ -48650,11 +48686,23 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     }
     // helper function to get the label as string (used for @: and @str: operators)
     getLabelAsString(value) {
+        // Optimization: for primitive types, convert directly
+        if (typeof value === "number" || typeof value === "boolean") {
+            return String(value);
+        }
         const label = this.getLabelForValue(value);
         return String(label);
     }
     // helper function to get the label as boolean (used for @bool: operator)
     getLabelAsBoolean(value) {
+        // Optimization: for boolean values, return directly
+        if (typeof value === "boolean") {
+            return value;
+        }
+        // Optimization: for number values, apply rule directly
+        if (typeof value === "number") {
+            return value !== 0;
+        }
         const label = this.getLabelForValue(value);
         const labelStr = String(label).toLowerCase();
         // Convert string representations to boolean
@@ -48672,6 +48720,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
     }
     // helper function to get the label as number (used for @num: operator)
     getLabelAsNumber(value) {
+        // Optimization: if value is already a number, return it directly
+        if (typeof value === "number") {
+            return value;
+        }
         const label = this.getLabelForValue(value);
         const labelNum = Number(label);
         if (isNaN(labelNum)) {
@@ -48849,6 +48901,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             const result = [];
             let foundTrue = false;
             let foundFalse = false;
+            // Optimize: create environment once and reuse it
+            const quantDeclEnv = {
+                env: {},
+                type: "quantDecl",
+            };
+            this.environmentStack.push(quantDeclEnv);
             for (let i = 0; i < product.length; i++) {
                 const tuple = product[i];
                 if (isDisjoint) {
@@ -48866,16 +48924,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                         continue;
                     }
                 }
-                const quantDeclEnv = {
-                    env: {},
-                    type: "quantDecl",
-                };
+                // Update environment values in place
                 for (let j = 0; j < varNames.length; j++) {
-                    const varName = varNames[j];
-                    const varValue = tuple[j];
-                    quantDeclEnv.env[varName] = varValue;
+                    quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                this.environmentStack.push(quantDeclEnv);
                 // now, we want to evaluate the barExpr
                 const barExprValue = this.visit(barExpr);
                 if (!isBoolean(barExprValue)) {
@@ -48888,14 +48940,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 else {
                     foundFalse = true;
                 }
-                this.environmentStack.pop();
                 // short-circuit if possible
                 if (ctx.quant().ALL_TOK() && foundFalse) {
+                    this.environmentStack.pop();
                     const value = false;
                     this.cacheResult(ctx, freeVarsKey, value);
                     return value;
                 }
                 if (ctx.quant().NO_TOK() && foundTrue) {
+                    this.environmentStack.pop();
                     const value = false;
                     this.cacheResult(ctx, freeVarsKey, value);
                     return value;
@@ -48903,22 +48956,26 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 if (ctx.quant().mult()) {
                     const multExpr = ctx.quant().mult();
                     if (multExpr.LONE_TOK() && result.length > 1) {
+                        this.environmentStack.pop();
                         const value = false;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                     if (multExpr.SOME_TOK() && foundTrue) {
+                        this.environmentStack.pop();
                         const value = true;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                     if (multExpr.ONE_TOK() && result.length > 1) {
+                        this.environmentStack.pop();
                         const value = false;
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
                 }
             }
+            this.environmentStack.pop();
             if (ctx.quant().ALL_TOK()) {
                 const value = !foundFalse;
                 this.cacheResult(ctx, freeVarsKey, value);
@@ -49418,7 +49475,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return leftChildValue;
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    return leftChildValue.filter((tuple) => !rightChildValue.some((rightTuple) => areTuplesEqual(tuple, rightTuple)));
+                    // Optimize set difference using Set for O(n+m) instead of O(n*m)
+                    const rightSet = new Set(rightChildValue.map(tupleToKey));
+                    return leftChildValue.filter(tuple => !rightSet.has(tupleToKey(tuple)));
                 }
             }
             else {
@@ -49491,7 +49550,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return [];
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    return leftChildValue.filter((tuple) => rightChildValue.some((rightTuple) => areTuplesEqual(tuple, rightTuple)));
+                    // Optimize set intersection using Set for O(n+m) instead of O(n*m)
+                    const rightSet = new Set(rightChildValue.map(tupleToKey));
+                    return leftChildValue.filter(tuple => rightSet.has(tupleToKey(tuple)));
                 }
             }
             else {
@@ -49708,7 +49769,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             if (isTupleArray(childrenResults)) {
                 const transitiveClosureResult = transitiveClosure(childrenResults);
                 const idenResult = this.getIden();
-                return deduplicateTuples([...idenResult, ...transitiveClosureResult]);
+                // Optimize: Use Set for efficient deduplication instead of deduplicateTuples
+                const resultSet = new Set();
+                for (const tuple of idenResult) {
+                    resultSet.add(tupleToKey(tuple));
+                }
+                for (const tuple of transitiveClosureResult) {
+                    resultSet.add(tupleToKey(tuple));
+                }
+                return Array.from(resultSet).map(key => JSON.parse(key));
             }
         }
         return childrenResults;
@@ -49833,18 +49902,18 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             }
             const product = getCombinations(quantifiedSets);
             const result = [];
+            // Optimize: create environment once and reuse it
+            const quantDeclEnv = {
+                env: {},
+                type: "quantDecl",
+            };
+            this.environmentStack.push(quantDeclEnv);
             for (let i = 0; i < product.length; i++) {
                 const tuple = product[i];
-                const quantDeclEnv = {
-                    env: {},
-                    type: "quantDecl",
-                };
+                // Update environment values in place
                 for (let j = 0; j < varNames.length; j++) {
-                    const varName = varNames[j];
-                    const varValue = tuple[j];
-                    quantDeclEnv.env[varName] = varValue;
+                    quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                this.environmentStack.push(quantDeclEnv);
                 // now, we want to evaluate the barExpr
                 const barExprValue = this.visit(barExpr);
                 if (!isBoolean(barExprValue)) {
@@ -49854,9 +49923,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     // will error if not boolean val, which we want
                     result.push(tuple);
                 }
-                this.environmentStack.pop();
             }
-            return result;
+            this.environmentStack.pop();
+            // Deduplicate results to ensure set semantics
+            return deduplicateTuples(result);
         }
         if (ctx.LEFT_PAREN_TOK()) {
             // NOTE: we just return the result of evaluating the expr that is inside
@@ -61125,6 +61195,8 @@ class SimpleGraphQueryEvaluator {
     constructor(datum) {
         this.forgeListener = new ForgeListenerImpl_1.ForgeListenerImpl();
         this.walker = new ParseTreeWalker_1.ParseTreeWalker();
+        // Cache for parsed expressions to avoid re-parsing the same expression
+        this.parseTreeCache = new Map();
         this.datum = datum;
     }
     getExpressionParseTree(forgeExpr) {
@@ -61138,18 +61210,28 @@ class SimpleGraphQueryEvaluator {
         return tree;
     }
     evaluateExpression(forgeExpr) {
-        try { // now, we can actually evaluate the expression
-            var tree = this.getExpressionParseTree(forgeExpr);
+        // Check cache first
+        let tree;
+        if (this.parseTreeCache.has(forgeExpr)) {
+            tree = this.parseTreeCache.get(forgeExpr);
         }
-        catch (e) {
-            // if we can't parse the expression, we return an error
-            return {
-                error: new Error(`Error parsing expression "${forgeExpr}"`)
-            };
+        else {
+            try { // now, we can actually evaluate the expression
+                const parsedTree = this.getExpressionParseTree(forgeExpr);
+                tree = parsedTree instanceof ForgeParser_1.ExprContext ? parsedTree : parsedTree.getChild(0);
+                // Cache the parsed tree
+                this.parseTreeCache.set(forgeExpr, tree);
+            }
+            catch (e) {
+                // if we can't parse the expression, we return an error
+                return {
+                    error: new Error(`Error parsing expression "${forgeExpr}"`)
+                };
+            }
         }
         const evaluator = new ForgeExprEvaluator_1.ForgeExprEvaluator(this.datum);
         try {
-            let result = evaluator.visit(tree instanceof ForgeParser_1.ExprContext ? tree : tree.getChild(0));
+            let result = evaluator.visit(tree);
             // ensure we're visiting an ExprContext
             return result;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.0.2",
+  "version": "2.1.2",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",