leangraph 1.0.0 → 1.1.0

package/dist/translator.js

@@ -1278,7 +1278,9 @@ export class Translator {
         const hasVariableLengthPattern = relPatterns?.some(p => p.isVariableLength);
         if (hasVariableLengthPattern && relPatterns) {
             // Use recursive CTE for variable-length paths
-            return this.translateVariableLengthPath(clause, relPatterns, selectParts, returnColumns, exprParams, whereParams);
+            // Pass the limit value for early termination optimization
+            const limitValue = clause.limit !== undefined && typeof clause.limit === 'number' ? clause.limit : undefined;
+            return this.translateVariableLengthPath(clause, relPatterns, selectParts, returnColumns, exprParams, whereParams, limitValue);
         }
         if (relPatterns && relPatterns.length > 0) {
             // Track which node aliases we've already added to FROM/JOIN
@@ -2952,7 +2954,7 @@ export class Translator {
     // ============================================================================
     // Variable-length paths
     // ============================================================================
-    translateVariableLengthPath(clause, relPatterns, selectParts, returnColumns, exprParams, whereParams) {
+    translateVariableLengthPath(clause, relPatterns, selectParts, returnColumns, exprParams, whereParams, limitValue) {
         // For variable-length paths, we use SQLite's recursive CTEs
         // Pattern: WITH RECURSIVE path(start_id, end_id, depth) AS (
         //   SELECT source_id, target_id, 1 FROM edges WHERE ...
@@ -2980,6 +2982,10 @@ export class Translator {
         const edgeProperties = varLengthPattern.edge.properties;
         const varLengthSourceAlias = varLengthPattern.sourceAlias;
         const varLengthTargetAlias = varLengthPattern.targetAlias;
+        // Early termination optimization: if there's a LIMIT clause, use it to bound recursion
+        // This prevents the CTE from generating millions of paths only to return a few
+        const effectiveLimit = limitValue ?? 1000; // Default limit for safety
+        const earlyTerminationLimit = Math.min(effectiveLimit * 10, 10000); // Cap at 10k for safety
         const allParams = [...exprParams];
         // Build edge property conditions for variable-length paths
         // These conditions need to be applied to every edge in the path
@@ -2996,6 +3002,39 @@ export class Translator {
         // Build the condition string for recursive case (with 'e.' table alias)
         const recursivePropConditions = edgePropConditions.map(c => c.replace("properties", "e.properties"));
         const recursivePropCondition = recursivePropConditions.length > 0 ? " AND " + recursivePropConditions.join(" AND ") : "";
+        // Build source node filter for CTE optimization
+        // This pushes the source filter INTO the CTE base case instead of filtering after
+        // which dramatically improves performance for large graphs
+        const sourcePattern = this.ctx[`pattern_${varLengthSourceAlias}`];
+        const sourceFilterParts = [];
+        const sourceFilterParams = [];
+        if (sourcePattern?.label) {
+            const labelMatch = this.generateLabelMatchCondition("src_n", sourcePattern.label);
+            sourceFilterParts.push(labelMatch.sql);
+            sourceFilterParams.push(...labelMatch.params);
+        }
+        if (sourcePattern?.properties) {
+            for (const [key, value] of Object.entries(sourcePattern.properties)) {
+                if (this.isParameterRef(value)) {
+                    sourceFilterParts.push(`json_extract(src_n.properties, '$.${key}') = ?`);
+                    sourceFilterParams.push(this.ctx.paramValues[value.name]);
+                }
+                else {
+                    sourceFilterParts.push(`json_extract(src_n.properties, '$.${key}') = ?`);
+                    sourceFilterParams.push(value);
+                }
+            }
+        }
+        // Build the source filter subquery if there are any constraints
+        // This filters source_id IN (SELECT id FROM nodes WHERE <constraints>)
+        const hasSourceFilter = sourceFilterParts.length > 0;
+        const sourceFilterSubquery = hasSourceFilter
+            ? ` AND source_id IN (SELECT src_n.id FROM nodes src_n WHERE ${sourceFilterParts.join(" AND ")})`
+            : "";
+        // For undirected, we also need to filter target_id for reverse direction
+        const sourceFilterSubqueryReverse = hasSourceFilter
+            ? ` AND target_id IN (SELECT src_n.id FROM nodes src_n WHERE ${sourceFilterParts.join(" AND ")})`
+            : "";
         // Check if a path expression already allocated a CTE name for this variable-length pattern
         // This allows length(p) to reference the correct CTE
         let pathCteName;
@@ -3047,44 +3086,52 @@ export class Translator {
         }
         else if (minHops === 0) {
             // Need to include zero-length paths (source = target) plus longer paths
+            // Build source filter for the base case (filters which nodes we start from)
+            const minHops0SourceFilter = hasSourceFilter
+                ? ` WHERE ${sourceFilterParts.join(" AND ").replace(/src_n\./g, "")}`
+                : "";
             if (isUndirected) {
                 // For undirected with minHops=0, traverse edges in both directions with edge tracking
                 if (edgeType) {
-                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes${minHops0SourceFilter}
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                    allParams.push(maxHops, edgeType);
+                    allParams.push(...sourceFilterParams); // for base case
+                    allParams.push(maxHops, edgeType, earlyTerminationLimit);
                 }
                 else {
-                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes${minHops0SourceFilter}
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                    allParams.push(maxHops);
+                    allParams.push(...sourceFilterParams); // for base case
+                    allParams.push(maxHops, earlyTerminationLimit);
                 }
             }
             else {
-                cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT id, id, 0, json_array() FROM nodes
+                cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT id, id, 0, json_array(), ROW_NUMBER() OVER () FROM nodes${minHops0SourceFilter}
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ?${edgeType ? " AND e.type = ?" : ""}
+  WHERE p.depth < ?${edgeType ? " AND e.type = ?" : ""} AND p.row_num < ?
 )`;
+                allParams.push(...sourceFilterParams); // for base case
                 allParams.push(maxHops);
                 if (edgeType) {
                     allParams.push(edgeType);
                 }
+                allParams.push(earlyTerminationLimit);
             }
         }
         else {
@@ -3100,49 +3147,55 @@ export class Translator {
                 // The base case includes both directions, and recursive step does too
                 // We need to avoid revisiting the same edge (tracked in edge_ids)
                 if (edgeType) {
-                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE ${edgeCondition}
+                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE ${edgeCondition}${sourceFilterSubquery}
   UNION ALL
-  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE type = ?
+  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE type = ?${sourceFilterSubqueryReverse}
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND e.type = ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
+                    allParams.push(...sourceFilterParams); // for forward base case
                     allParams.push(edgeType); // for reverse base case
-                    allParams.push(maxHops, edgeType); // for recursive
+                    allParams.push(...sourceFilterParams); // for reverse base case
+                    allParams.push(maxHops, edgeType, earlyTerminationLimit); // for recursive
                 }
                 else {
-                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges
+                    cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE 1=1${sourceFilterSubquery}
   UNION ALL
-  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges
+  SELECT target_id, source_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE 1=1${sourceFilterSubqueryReverse}
   UNION ALL
-  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, CASE WHEN p.end_id = e.source_id THEN e.target_id ELSE e.source_id END, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON (p.end_id = e.source_id OR p.end_id = e.target_id)
-  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ? AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
-                    allParams.push(maxHops); // for recursive
+                    allParams.push(...sourceFilterParams); // for forward base case
+                    allParams.push(...sourceFilterParams); // for reverse base case
+                    allParams.push(maxHops, earlyTerminationLimit); // for recursive
                 }
             }
             else {
-                cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids) AS (
-  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))) FROM edges WHERE ${edgeCondition}${basePropCondition}
+                cte = `WITH RECURSIVE ${pathCteName}(start_id, end_id, depth, edge_ids, row_num) AS (
+  SELECT source_id, target_id, 1, json_array(json_object('id', id, 'type', type, 'source_id', source_id, 'target_id', target_id, 'properties', json(properties))), ROW_NUMBER() OVER () FROM edges WHERE ${edgeCondition}${basePropCondition}${sourceFilterSubquery}
   UNION ALL
-  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties)))
+  SELECT p.start_id, e.target_id, p.depth + 1, json_insert(p.edge_ids, '$[#]', json_object('id', e.id, 'type', e.type, 'source_id', e.source_id, 'target_id', e.target_id, 'properties', json(e.properties))), p.row_num + 1
   FROM ${pathCteName} p
   JOIN edges e ON p.end_id = e.source_id
-  WHERE p.depth < ?${edgeType ? " AND e.type = ?" : ""}${recursivePropCondition} AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id)
+  WHERE p.depth < ?${edgeType ? " AND e.type = ?" : ""}${recursivePropCondition} AND NOT EXISTS (SELECT 1 FROM json_each(p.edge_ids) WHERE json_extract(value, '$.id') = e.id) AND p.row_num < ?
 )`;
                 // For maxHops=2, we need depth to reach 2, so recursion limit should be maxHops
                 allParams.push(...edgePropParams); // for base case
+                allParams.push(...sourceFilterParams); // for source filter subquery
                 allParams.push(maxHops);
                 if (edgeType) {
                     allParams.push(edgeType);
                 }
                 allParams.push(...edgePropParams); // for recursive case
+                allParams.push(earlyTerminationLimit);
             }
         }
         // Build FROM and JOIN clauses for fixed-length patterns before the variable-length