simple-graph-query 2.1.4 → 2.2.0

package/dist/ForgeExprEvaluator.d.ts

@@ -17,13 +17,17 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     private freeVariables;
     private cachedResults;
     private instanceData;
+    private relationCache;
+    private relationIndexCache;
     constructor(datum: IDataInstance);
+    private buildRelationCache;
     private updateFreeVariables;
     private constructFreeVariableKey;
     private getLabelForValue;
     private getLabelAsString;
     private getLabelAsBoolean;
     private getLabelAsNumber;
+    private dotJoin;
     private cacheResult;
     private getIden;
     protected aggregateResult(aggregate: EvalResult, nextResult: EvalResult): EvalResult;

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

@@ -48570,38 +48570,6 @@ function transitiveClosure(pairs) {
     // convert the result back to a Tuple[] and return
     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 = [];
-    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");
-    }
-    // Deduplicate results to ensure set semantics
-    return deduplicateTuples(result);
-}
 function bitwidthWraparound(value, bitwidth) {
     const modulus = Math.pow(2, bitwidth); // total number of Int values
     const halfValue = Math.pow(2, bitwidth - 1); // halfway point
@@ -48632,11 +48600,61 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         // NOTE: strings will be of the format "<var-name>=<value>|..." sorted in
         // increasing lexicographic order of variable names
         this.cachedResults = new Map();
+        // Cache for relation lookups to avoid O(n) scans
+        this.relationCache = null;
+        // Index for relations: Map<relationName, Map<firstElement, Tuple[]>>
+        // This allows O(1) lookup for patterns like atom.field
+        this.relationIndexCache = null;
         this.instanceData = datum;
         this.environmentStack = [];
         this.freeVariableFinder = new ForgeExprFreeVariableFinder_1.ForgeExprFreeVariableFinder(datum);
         this.freeVariables = new Map();
     }
+    // helper function to build relation cache and indexes
+    buildRelationCache() {
+        if (this.relationCache !== null) {
+            return; // already built
+        }
+        this.relationCache = new Map();
+        this.relationIndexCache = new Map();
+        const relations = this.instanceData.getRelations();
+        const isConvertibleToNumber = (value) => {
+            return typeof value === "string" && !isNaN(Number(value));
+        };
+        const isConvertibleToBoolean = (value) => {
+            if (typeof value === "boolean")
+                return false; // already boolean
+            return value === "true" || value === "#t" || value === "false" || value === "#f";
+        };
+        const convertToBoolean = (value) => {
+            if (typeof value === "boolean")
+                return value;
+            if (value === "true" || value === "#t")
+                return true;
+            if (value === "false" || value === "#f")
+                return false;
+            throw new Error(`Cannot convert ${value} to boolean`);
+        };
+        for (const relation of relations) {
+            let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
+            // Convert numeric and boolean strings to their actual types
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
+            this.relationCache.set(relation.name, relationAtoms);
+            // Build index for this relation: first element -> all tuples starting with that element
+            const relationIndex = new Map();
+            for (const tuple of relationAtoms) {
+                if (tuple.length > 0) {
+                    const key = tuple[0];
+                    if (!relationIndex.has(key)) {
+                        relationIndex.set(key, []);
+                    }
+                    relationIndex.get(key).push(tuple);
+                }
+            }
+            this.relationIndexCache.set(relation.name, relationIndex);
+        }
+    }
     //helper function
     updateFreeVariables(freeVars) {
         if (this.freeVariables.size === 0) {
@@ -48732,6 +48750,45 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         }
         return labelNum;
     }
+    // Optimized dotJoin that can use pre-built relation indexes
+    dotJoin(left, right, rightRelationName) {
+        const leftExpr = isSingleValue(left) ? [[left]] : left;
+        const rightExpr = isSingleValue(right) ? [[right]] : right;
+        // Try to use pre-built index if available
+        let rightIndex;
+        if (rightRelationName && this.relationIndexCache) {
+            rightIndex = this.relationIndexCache.get(rightRelationName);
+        }
+        // If no pre-built index, build one on the fly
+        if (!rightIndex) {
+            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 = [];
+        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");
+        }
+        // Deduplicate results to ensure set semantics
+        return deduplicateTuples(result);
+    }
     // helper function
     cacheResult(ctx, freeVarsKey, result) {
         if (!this.cachedResults.has(ctx)) {
@@ -48862,9 +48919,6 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         if (foundAllVars && this.cachedResults.has(ctx)) {
             if (this.cachedResults.get(ctx).has(freeVarsKey)) {
                 // cache hit!
-                // console.log('cache hit for ctx:', ctx.text);
-                // console.log('freeVarsKey:', freeVarsKey);
-                // console.log('cachedResults:', this.cachedResults.get(ctx));
                 return this.cachedResults.get(ctx).get(freeVarsKey);
             }
         }
@@ -49634,7 +49688,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 }
             }
             // Box join: <expr-a>[<expr-b>] == <expr-b> . <expr-a>
-            return dotJoin(insideBracesExprs, beforeBracesExpr);
+            return this.dotJoin(insideBracesExprs, beforeBracesExpr);
         }
         return this.visitChildren(ctx);
     }
@@ -49647,9 +49701,20 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             }
             const beforeDotExpr = this.visit(ctx.expr15());
             const afterDotExpr = this.visit(ctx.expr16());
-            // console.log('beforeExpr:', beforeDotExpr);
-            // console.log('afterExpr:', afterDotExpr);
-            return dotJoin(beforeDotExpr, afterDotExpr);
+            // Try to extract the relation name if the right side is a simple identifier/relation name
+            let rightRelationName;
+            // Simple heuristic: check if it's a tuple array (likely a relation)
+            // and if so, try to find which relation it matches
+            if (isTupleArray(afterDotExpr) && this.relationCache) {
+                // Check if this matches any cached relation
+                for (const [relName, relTuples] of this.relationCache.entries()) {
+                    if (relTuples === afterDotExpr) {
+                        rightRelationName = relName;
+                        break;
+                    }
+                }
+            }
+            return this.dotJoin(beforeDotExpr, afterDotExpr, rightRelationName);
         }
         if (ctx.LEFT_SQUARE_TOK()) {
             const beforeBracesName = this.visit(ctx.name());
@@ -50092,15 +50157,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             throw new Error(`Cannot convert ${value} to boolean`);
         };
         // end of 3 helper functions
-        // check if it is a relation
-        const relations = this.instanceData.getRelations();
-        for (const relation of relations) {
-            if (relation.name === identifier) {
-                let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
-                relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
-                relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
-                return relationAtoms;
-            }
+        // check if it is a relation - use cache for faster lookups
+        this.buildRelationCache();
+        if (this.relationCache.has(identifier)) {
+            return this.relationCache.get(identifier);
         }
         if (result !== undefined) {
             result = result.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
@@ -50386,6 +50446,9 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
             const quantDeclListVars = this.getQuantDeclListVarNames(ctx.quantDeclList());
             // we need to get all the vars referenced here other than the vars
             // bound by the quantifier (in quantDeclListVars)
+            // First, get free variables from the quantDeclList itself
+            // (e.g., in "some p2 : c.parent | ...", c is a free variable)
+            const quantDeclListFreeVars = this.visit(ctx.quantDeclList());
             const blockOrBar = ctx.blockOrBar();
             if (blockOrBar === undefined) {
                 throw new Error("expected to quantify over something!");
@@ -50394,13 +50457,15 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
                 blockOrBar.expr() === undefined) {
                 throw new Error("Expected the quantifier to have a bar followed by an expr!");
             }
-            let allFreeVars;
+            let barExprFreeVars;
             if (blockOrBar.block() !== undefined) {
-                allFreeVars = this.visit(blockOrBar.block());
+                barExprFreeVars = this.visit(blockOrBar.block());
             }
             else {
-                allFreeVars = this.visit(blockOrBar.expr());
+                barExprFreeVars = this.visit(blockOrBar.expr());
             }
+            // Merge free variables from quantDeclList and barExpr
+            const allFreeVars = this.aggregateResult(barExprFreeVars, quantDeclListFreeVars);
             // the context node for the quantifier as a whole shouldn't have _all_ of these
             // free vars; specifically, it should not include the vars that are being
             // bound by the quantifier

package/package.json

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