@quereus/quereus 0.17.0 → 0.18.0

package/dist/src/planner/rules/cache/rule-in-subquery-cache.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Rule: IN-Subquery Cache
+ *
+ * Required Characteristics:
+ * - Node must be an InNode with a subquery source (not a value list)
+ * - Source must be uncorrelated (no outer attribute references)
+ * - Source must be deterministic and read-only (functional)
+ * - Source must not already be cached
+ *
+ * Applied When:
+ * - IN subquery source would be re-executed for every outer row in a filter predicate
+ *
+ * Benefits: Materializes the subquery result once and replays from cache on subsequent
+ * evaluations, reducing O(N * K) CTE/subquery evaluations to O(K + N * K_cached)
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleInSubqueryCache(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-in-subquery-cache.d.ts.map

package/dist/src/planner/rules/cache/rule-in-subquery-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-in-subquery-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-in-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAS7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAoDxF"}

package/dist/src/planner/rules/cache/rule-in-subquery-cache.js

@@ -0,0 +1,53 @@
+/**
+ * Rule: IN-Subquery Cache
+ *
+ * Required Characteristics:
+ * - Node must be an InNode with a subquery source (not a value list)
+ * - Source must be uncorrelated (no outer attribute references)
+ * - Source must be deterministic and read-only (functional)
+ * - Source must not already be cached
+ *
+ * Applied When:
+ * - IN subquery source would be re-executed for every outer row in a filter predicate
+ *
+ * Benefits: Materializes the subquery result once and replays from cache on subsequent
+ * evaluations, reducing O(N * K) CTE/subquery evaluations to O(K + N * K_cached)
+ */
+import { createLogger } from '../../../common/logger.js';
+import { InNode } from '../../nodes/subquery.js';
+import { CacheNode } from '../../nodes/cache-node.js';
+import { CapabilityDetectors, CachingAnalysis, PlanNodeCharacteristics } from '../../framework/characteristics.js';
+import { isCorrelatedSubquery } from '../../cache/correlation-detector.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+const log = createLogger('optimizer:rule:in-subquery-cache');
+export function ruleInSubqueryCache(node, context) {
+    // Guard: must be an InNode with a subquery source
+    if (node.nodeType !== PlanNodeType.In) {
+        return null;
+    }
+    const inNode = node;
+    if (!inNode.source) {
+        return null; // Value-list IN, nothing to cache
+    }
+    const source = inNode.source;
+    // Gate: source must not already be cached
+    if (CapabilityDetectors.isCached(source) && source.isCached()) {
+        log('IN-subquery source already cached, skipping');
+        return null;
+    }
+    // Gate: source must be uncorrelated (no outer attribute references)
+    if (isCorrelatedSubquery(source)) {
+        log('IN-subquery is correlated, skipping cache wrapping');
+        return null;
+    }
+    // Gate: source must be deterministic and read-only
+    if (!PlanNodeCharacteristics.isFunctional(source)) {
+        log('IN-subquery source is not functional, skipping cache wrapping');
+        return null;
+    }
+    log('Wrapping uncorrelated IN-subquery source in CacheNode');
+    const cacheThreshold = Math.min(CachingAnalysis.getCacheThreshold(source), context.tuning.cte.maxCacheThreshold);
+    const cachedSource = new CacheNode(source.scope, source, 'memory', cacheThreshold);
+    return new InNode(inNode.scope, inNode.expression, inNode.condition, cachedSource, inNode.values);
+}
+//# sourceMappingURL=rule-in-subquery-cache.js.map

package/dist/src/planner/rules/cache/rule-in-subquery-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-in-subquery-cache.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-in-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AACnH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,MAAM,GAAG,GAAG,YAAY,CAAC,kCAAkC,CAAC,CAAC;AAE7D,MAAM,UAAU,mBAAmB,CAAC,IAAc,EAAE,OAAmB;IACtE,kDAAkD;IAClD,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY,CAAC,EAAE,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,MAAM,GAAG,IAAc,CAAC;IAC9B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,CAAC,kCAAkC;IAChD,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAE7B,0CAA0C;IAC1C,IAAI,mBAAmB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;QAC/D,GAAG,CAAC,6CAA6C,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,oEAAoE;IACpE,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;QAClC,GAAG,CAAC,oDAAoD,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,mDAAmD;IACnD,IAAI,CAAC,uBAAuB,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;QACnD,GAAG,CAAC,+DAA+D,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,uDAAuD,CAAC,CAAC;IAE7D,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAC9B,eAAe,CAAC,iBAAiB,CAAC,MAAM,CAAC,EACzC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,iBAAiB,CACpC,CAAC;IAEF,MAAM,YAAY,GAAG,IAAI,SAAS,CACjC,MAAM,CAAC,KAAK,EACZ,MAAM,EACN,QAAQ,EACR,cAAc,CACd,CAAC;IAEF,OAAO,IAAI,MAAM,CAChB,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,UAAU,EACjB,MAAM,CAAC,SAAS,EAChB,YAAY,EACZ,MAAM,CAAC,MAAM,CACb,CAAC;AACH,CAAC"}

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-mutating-subquery-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-mutating-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAqD/F"}
+{"version":3,"file":"rule-mutating-subquery-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-mutating-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA2D/F"}

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.js

@@ -21,6 +21,11 @@ export function ruleMutatingSubqueryCache(node, _context) {
     if (!CapabilityDetectors.isJoin(node)) {
         return null;
     }
+    // Skip physical join nodes — they already materialize the build side,
+    // so caching is inherent and we must not replace them with logical JoinNodes.
+    if (!(node instanceof JoinNode)) {
+        return null;
+    }
     log('Checking join operation for side effects on right side');
     // Get join-specific characteristics
     const joinNode = node;

package/dist/src/planner/rules/cache/rule-mutating-subquery-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-mutating-subquery-cache.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-mutating-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,eAAe,EAAoB,MAAM,oCAAoC,CAAC;AAErI,MAAM,GAAG,GAAG,YAAY,CAAC,wCAAwC,CAAC,CAAC;AAEnE,MAAM,UAAU,yBAAyB,CAAC,IAAc,EAAE,QAAoB;IAC7E,2CAA2C;IAC3C,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,wDAAwD,CAAC,CAAC;IAE9D,oCAAoC;IACpC,MAAM,QAAQ,GAAG,IAAmB,CAAC;IACrC,MAAM,SAAS,GAAG,QAAQ,CAAC,cAAc,EAAE,CAAC;IAE5C,4DAA4D;IAC5D,MAAM,cAAc,GAAG,iCAAiC,CAAC,SAAS,CAAC,CAAC;IACpE,IAAI,CAAC,cAAc,EAAE,CAAC;QACrB,GAAG,CAAC,oEAAoE,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC;IACb,CAAC;IAED,wCAAwC;IACxC,IAAI,mBAAmB,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC;QACrE,GAAG,CAAC,wCAAwC,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,8EAA8E,CAAC,CAAC;IAEpF,8DAA8D;IAC9D,MAAM,SAAS,GAAG,eAAe,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAE/D,wCAAwC;IACxC,MAAM,eAAe,GAAG,IAAI,SAAS,CACpC,SAAS,CAAC,KAAK,EACf,SAAS,EACT,QAAQ,EACR,SAAS,CACT,CAAC;IAEF,8CAA8C;IAC9C,iGAAiG;IACjG,MAAM,MAAM,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,KAAK,EACV,QAAQ,CAAC,aAAa,EAAE,EACxB,eAAe,EACf,QAAQ,CAAC,WAAW,EAAE,EACtB,QAAQ,CAAC,gBAAgB,EAAE;IAC3B,+EAA+E;IAC/E,kEAAkE;IAClE,QAAQ,CAAC,eAAe,EAAE,CAC1B,CAAC;IAEF,GAAG,CAAC,8EAA8E,EAAE,SAAS,CAAC,CAAC;IAC/F,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,iCAAiC,CAAC,IAAc;IACxD,oCAAoC;IACpC,IAAI,uBAAuB,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,iCAAiC;IACjC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QACxC,IAAI,iCAAiC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,uEAAuE;IACvE,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;QAC5C,IAAI,iCAAiC,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}
+{"version":3,"file":"rule-mutating-subquery-cache.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-mutating-subquery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,eAAe,EAAoB,MAAM,oCAAoC,CAAC;AAErI,MAAM,GAAG,GAAG,YAAY,CAAC,wCAAwC,CAAC,CAAC;AAEnE,MAAM,UAAU,yBAAyB,CAAC,IAAc,EAAE,QAAoB;IAC7E,2CAA2C;IAC3C,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,sEAAsE;IACtE,8EAA8E;IAC9E,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,wDAAwD,CAAC,CAAC;IAE9D,oCAAoC;IACpC,MAAM,QAAQ,GAAG,IAAmB,CAAC;IACrC,MAAM,SAAS,GAAG,QAAQ,CAAC,cAAc,EAAE,CAAC;IAE5C,4DAA4D;IAC5D,MAAM,cAAc,GAAG,iCAAiC,CAAC,SAAS,CAAC,CAAC;IACpE,IAAI,CAAC,cAAc,EAAE,CAAC;QACrB,GAAG,CAAC,oEAAoE,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC;IACb,CAAC;IAED,wCAAwC;IACxC,IAAI,mBAAmB,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC;QACrE,GAAG,CAAC,wCAAwC,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,8EAA8E,CAAC,CAAC;IAEpF,8DAA8D;IAC9D,MAAM,SAAS,GAAG,eAAe,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAE/D,wCAAwC;IACxC,MAAM,eAAe,GAAG,IAAI,SAAS,CACpC,SAAS,CAAC,KAAK,EACf,SAAS,EACT,QAAQ,EACR,SAAS,CACT,CAAC;IAEF,8CAA8C;IAC9C,iGAAiG;IACjG,MAAM,MAAM,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,KAAK,EACV,QAAQ,CAAC,aAAa,EAAE,EACxB,eAAe,EACf,QAAQ,CAAC,WAAW,EAAE,EACtB,QAAQ,CAAC,gBAAgB,EAAE;IAC3B,+EAA+E;IAC/E,kEAAkE;IAClE,QAAQ,CAAC,eAAe,EAAE,CAC1B,CAAC;IAEF,GAAG,CAAC,8EAA8E,EAAE,SAAS,CAAC,CAAC;IAC/F,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,iCAAiC,CAAC,IAAc;IACxD,oCAAoC;IACpC,IAAI,uBAAuB,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,iCAAiC;IACjC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QACxC,IAAI,iCAAiC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,uEAAuE;IACvE,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;QAC5C,IAAI,iCAAiC,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/src/planner/rules/distinct/rule-distinct-elimination.d.ts

@@ -0,0 +1,18 @@
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+/**
+ * Rule: DISTINCT Elimination
+ *
+ * When a DistinctNode's source already guarantees unique rows (via logical keys
+ * from RelationType or physical uniqueKeys), the DISTINCT is redundant and can
+ * be removed.
+ *
+ * Checks both:
+ * 1. Physical uniqueKeys (from computePhysical, available after physical pass)
+ * 2. Logical keys (from RelationType.keys, available at any time)
+ *
+ * A key that is present in the source proves it already produces unique rows —
+ * DISTINCT is a no-op.
+ */
+export declare function ruleDistinctElimination(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-distinct-elimination.d.ts.map

package/dist/src/planner/rules/distinct/rule-distinct-elimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-distinct-elimination.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAoB7F"}

package/dist/src/planner/rules/distinct/rule-distinct-elimination.js

@@ -0,0 +1,37 @@
+import { createLogger } from '../../../common/logger.js';
+import { DistinctNode } from '../../nodes/distinct-node.js';
+const log = createLogger('optimizer:rule:distinct-elimination');
+/**
+ * Rule: DISTINCT Elimination
+ *
+ * When a DistinctNode's source already guarantees unique rows (via logical keys
+ * from RelationType or physical uniqueKeys), the DISTINCT is redundant and can
+ * be removed.
+ *
+ * Checks both:
+ * 1. Physical uniqueKeys (from computePhysical, available after physical pass)
+ * 2. Logical keys (from RelationType.keys, available at any time)
+ *
+ * A key that is present in the source proves it already produces unique rows —
+ * DISTINCT is a no-op.
+ */
+export function ruleDistinctElimination(node, _context) {
+    if (!(node instanceof DistinctNode))
+        return null;
+    // Check physical uniqueKeys (available if physical pass has run or compute is triggered)
+    const sourcePhys = node.source.physical;
+    if (sourcePhys?.uniqueKeys && sourcePhys.uniqueKeys.length > 0) {
+        log('Eliminating redundant DISTINCT: source has physical uniqueKeys %j', sourcePhys.uniqueKeys);
+        return node.source;
+    }
+    // Check logical keys from RelationType
+    // If the source's logical type declares any key, the source already produces
+    // unique rows (since any superset of a key is also unique).
+    const sourceType = node.source.getType();
+    if (sourceType.keys && sourceType.keys.length > 0) {
+        log('Eliminating redundant DISTINCT: source has logical keys %j', sourceType.keys);
+        return node.source;
+    }
+    return null;
+}
+//# sourceMappingURL=rule-distinct-elimination.js.map

package/dist/src/planner/rules/distinct/rule-distinct-elimination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-distinct-elimination.js","sourceRoot":"","sources":["../../../../../src/planner/rules/distinct/rule-distinct-elimination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,MAAM,GAAG,GAAG,YAAY,CAAC,qCAAqC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAc,EAAE,QAAoB;IAC3E,IAAI,CAAC,CAAC,IAAI,YAAY,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAEjD,yFAAyF;IACzF,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxC,IAAI,UAAU,EAAE,UAAU,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChE,GAAG,CAAC,mEAAmE,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;QAChG,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,uCAAuC;IACvC,6EAA6E;IAC7E,4DAA4D;IAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACzC,IAAI,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnD,GAAG,CAAC,4DAA4D,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QACnF,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC"}

package/dist/src/planner/rules/join/rule-join-key-inference.d.ts

@@ -3,9 +3,14 @@ import type { OptContext } from '../../framework/context.js';
 /**
  * Rule: Join Key Inference
  *
- * Detect simple equi-join predicates (left.col = right.pk) and propagate
- * inner/cross join unique keys (already handled by JoinNode.computePhysical),
- * with a hook for future FK->PK inference (not implemented here yet).
+ * Detects equi-join predicates and FK→PK relationships between join sides.
+ * When an FK→PK alignment is found, the PK side's key is guaranteed to be
+ * covered (each FK row matches ≤1 PK row), so computePhysical already handles
+ * cardinality reduction. This rule logs the detection for diagnostics.
+ *
+ * The real work happens in:
+ * - analyzeJoinKeyCoverage (key-utils.ts): unique key preservation + estimatedRows
+ * - CatalogStatsProvider.joinSelectivity: FK-aware selectivity = 1/ndv_pk
  */
 export declare function ruleJoinKeyInference(node: PlanNode, _context: OptContext): PlanNode | null;
 //# sourceMappingURL=rule-join-key-inference.d.ts.map

package/dist/src/planner/rules/join/rule-join-key-inference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-join-key-inference.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-key-inference.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO7D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAgB1F"}
+{"version":3,"file":"rule-join-key-inference.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-key-inference.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM7D;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4B1F"}

package/dist/src/planner/rules/join/rule-join-key-inference.js

@@ -1,32 +1,43 @@
 import { createLogger } from '../../../common/logger.js';
-import { JoinNode } from '../../nodes/join-node.js';
-import { BinaryOpNode } from '../../nodes/scalar.js';
-import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { JoinNode, extractEquiPairsFromCondition } from '../../nodes/join-node.js';
+import { extractTableSchema, checkFkPkAlignment } from '../../util/key-utils.js';
 const log = createLogger('optimizer:rule:join-key-inference');
 /**
  * Rule: Join Key Inference
  *
- * Detect simple equi-join predicates (left.col = right.pk) and propagate
- * inner/cross join unique keys (already handled by JoinNode.computePhysical),
- * with a hook for future FK->PK inference (not implemented here yet).
+ * Detects equi-join predicates and FK→PK relationships between join sides.
+ * When an FK→PK alignment is found, the PK side's key is guaranteed to be
+ * covered (each FK row matches ≤1 PK row), so computePhysical already handles
+ * cardinality reduction. This rule logs the detection for diagnostics.
+ *
+ * The real work happens in:
+ * - analyzeJoinKeyCoverage (key-utils.ts): unique key preservation + estimatedRows
+ * - CatalogStatsProvider.joinSelectivity: FK-aware selectivity = 1/ndv_pk
  */
 export function ruleJoinKeyInference(node, _context) {
     if (!(node instanceof JoinNode))
         return null;
     if (node.joinType !== 'inner' && node.joinType !== 'cross')
         return null;
-    const cond = node.getJoinCondition();
-    if (!cond || !(cond instanceof BinaryOpNode))
-        return null;
-    if (cond.expression.operator !== '=')
-        return null;
-    // Simple left.col = right.col pattern check; placeholder for future FK->PK detection
-    const leftIsCol = cond.left instanceof ColumnReferenceNode;
-    const rightIsCol = cond.right instanceof ColumnReferenceNode;
-    if (!leftIsCol || !rightIsCol)
+    const leftAttrs = node.left.getAttributes();
+    const rightAttrs = node.right.getAttributes();
+    const pairs = extractEquiPairsFromCondition(node.condition, leftAttrs, rightAttrs);
+    if (pairs.length === 0)
         return null;
-    log('Detected equi-join predicate; JoinNode.computePhysical will preserve side keys');
-    // No structural change needed now; computePhysical on JoinNode already preserves side keys
+    // Check for FK→PK alignment
+    const leftSchema = extractTableSchema(node.left);
+    const rightSchema = extractTableSchema(node.right);
+    if (leftSchema && rightSchema) {
+        const leftFkIndices = pairs.map(p => p.left);
+        const rightFkIndices = pairs.map(p => p.right);
+        if (checkFkPkAlignment(leftSchema, rightSchema, leftFkIndices, rightFkIndices)) {
+            log('FK→PK detected: %s.FK → %s.PK; PK-side key covered by equi-join', leftSchema.name, rightSchema.name);
+        }
+        else if (checkFkPkAlignment(rightSchema, leftSchema, rightFkIndices, leftFkIndices)) {
+            log('FK→PK detected: %s.FK → %s.PK; PK-side key covered by equi-join', rightSchema.name, leftSchema.name);
+        }
+    }
+    // No structural transformation needed — computePhysical handles key preservation
     return null;
 }
 //# sourceMappingURL=rule-join-key-inference.js.map

package/dist/src/planner/rules/join/rule-join-key-inference.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-join-key-inference.js","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-key-inference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAE/D,MAAM,GAAG,GAAG,YAAY,CAAC,mCAAmC,CAAC,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAc,EAAE,QAAoB;IACvE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAExE,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACrC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,YAAY,YAAY,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1D,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,KAAK,GAAG;QAAE,OAAO,IAAI,CAAC;IAElD,qFAAqF;IACrF,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,YAAY,mBAAmB,CAAC;IAC3D,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,YAAY,mBAAmB,CAAC;IAC7D,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAE3C,GAAG,CAAC,gFAAgF,CAAC,CAAC;IACtF,2FAA2F;IAC3F,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"rule-join-key-inference.js","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-key-inference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAEjF,MAAM,GAAG,GAAG,YAAY,CAAC,mCAAmC,CAAC,CAAC;AAE9D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAc,EAAE,QAAoB;IACvE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAExE,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;IAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;IAC9C,MAAM,KAAK,GAAG,6BAA6B,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;IACnF,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpC,4BAA4B;IAC5B,MAAM,UAAU,GAAG,kBAAkB,CAAC,IAAI,CAAC,IAA0B,CAAC,CAAC;IACvE,MAAM,WAAW,GAAG,kBAAkB,CAAC,IAAI,CAAC,KAA2B,CAAC,CAAC;IAEzE,IAAI,UAAU,IAAI,WAAW,EAAE,CAAC;QAC9B,MAAM,aAAa,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,cAAc,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAE/C,IAAI,kBAAkB,CAAC,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,CAAC,EAAE,CAAC;YAC/E,GAAG,CAAC,iEAAiE,EACnE,UAAU,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;aAAM,IAAI,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,CAAC,EAAE,CAAC;YACtF,GAAG,CAAC,iEAAiE,EACnE,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED,iFAAiF;IACjF,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/src/planner/rules/join/rule-join-physical-selection.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rule: Join Physical Selection
+ *
+ * Required Characteristics:
+ * - Node must be a logical JoinNode (not already a physical join)
+ * - Node must have an equi-join predicate for hash/merge join consideration
+ *
+ * Applied When:
+ * - Logical JoinNode with equi-join predicates where hash or merge join is cheaper than nested loop
+ *
+ * Benefits: Replaces O(n*m) nested loop with O(n+m) hash/merge join for equi-joins
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleJoinPhysicalSelection(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-join-physical-selection.d.ts.map

package/dist/src/planner/rules/join/rule-join-physical-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-join-physical-selection.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-physical-selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAiD,MAAM,0BAA0B,CAAC;AACxG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAuI7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAuI/F"}

package/dist/src/planner/rules/join/rule-join-physical-selection.js

@@ -0,0 +1,216 @@
+/**
+ * Rule: Join Physical Selection
+ *
+ * Required Characteristics:
+ * - Node must be a logical JoinNode (not already a physical join)
+ * - Node must have an equi-join predicate for hash/merge join consideration
+ *
+ * Applied When:
+ * - Logical JoinNode with equi-join predicates where hash or merge join is cheaper than nested loop
+ *
+ * Benefits: Replaces O(n*m) nested loop with O(n+m) hash/merge join for equi-joins
+ */
+import { createLogger } from '../../../common/logger.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { BloomJoinNode } from '../../nodes/bloom-join-node.js';
+import { MergeJoinNode } from '../../nodes/merge-join-node.js';
+import { SortNode } from '../../nodes/sort.js';
+import { BinaryOpNode } from '../../nodes/scalar.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
+import { nestedLoopJoinCost, hashJoinCost, mergeJoinCost } from '../../cost/index.js';
+import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+const log = createLogger('optimizer:rule:join-physical-selection');
+/**
+ * Extract equi-join pairs and residual predicates from an ON condition.
+ * Returns null if no equi-pairs found.
+ */
+function extractEquiPairs(condition, leftAttrIds, rightAttrIds) {
+    if (!condition)
+        return null;
+    const norm = normalizePredicate(condition);
+    const equiPairs = [];
+    const residuals = [];
+    // Walk AND-tree and classify each conjunct
+    const stack = [norm];
+    while (stack.length) {
+        const n = stack.pop();
+        if (n instanceof BinaryOpNode && n.expression.operator === 'AND') {
+            stack.push(n.left, n.right);
+            continue;
+        }
+        // Check for equi-join: col_ref = col_ref across left/right
+        let isEqui = false;
+        if (n instanceof BinaryOpNode && n.expression.operator === '=') {
+            if (n.left instanceof ColumnReferenceNode && n.right instanceof ColumnReferenceNode) {
+                const lId = n.left.attributeId;
+                const rId = n.right.attributeId;
+                if (leftAttrIds.has(lId) && rightAttrIds.has(rId)) {
+                    equiPairs.push({ leftAttrId: lId, rightAttrId: rId });
+                    isEqui = true;
+                }
+                else if (leftAttrIds.has(rId) && rightAttrIds.has(lId)) {
+                    equiPairs.push({ leftAttrId: rId, rightAttrId: lId });
+                    isEqui = true;
+                }
+            }
+        }
+        if (!isEqui) {
+            residuals.push(n);
+        }
+    }
+    if (equiPairs.length === 0)
+        return null;
+    // Combine residuals back into an AND-tree
+    let residual;
+    if (residuals.length > 0) {
+        residual = residuals.reduce((acc, cur) => new BinaryOpNode(cur.scope, { type: 'binary', operator: 'AND' }, acc, cur));
+    }
+    return { equiPairs, residual };
+}
+/**
+ * Check if a source's ordering covers the given equi-pair columns.
+ * Returns true if the source is already sorted ascending on the equi-pair
+ * columns in the exact order the equi-pairs specify.  Positional matching
+ * is required because the merge-join emitter compares keys in equi-pair
+ * order; a mismatch (e.g. source sorted (b, a) vs equi-pairs (a, b))
+ * would break the linear-scan invariant.
+ */
+function isOrderedOnEquiPairs(source, equiPairs, side) {
+    const ordering = PlanNodeCharacteristics.getOrdering(source);
+    if (!ordering || ordering.length === 0)
+        return false;
+    if (equiPairs.length > ordering.length)
+        return false;
+    const attrs = source.getAttributes();
+    for (let i = 0; i < equiPairs.length; i++) {
+        const attrId = side === 'left' ? equiPairs[i].leftAttrId : equiPairs[i].rightAttrId;
+        const idx = attrs.findIndex(a => a.id === attrId);
+        if (idx === -1)
+            return false;
+        // Ordering entry at position i must match this equi-pair column and
+        // must be ascending (merge join's compareKeys assumes ASC order).
+        if (ordering[i].column !== idx || ordering[i].desc)
+            return false;
+    }
+    return true;
+}
+/**
+ * Create a SortNode that sorts a source on the equi-pair columns for this side.
+ */
+function createSortForEquiPairs(source, equiPairs, side, scope) {
+    const attrs = source.getAttributes();
+    const sortKeys = equiPairs.map(pair => {
+        const attrId = side === 'left' ? pair.leftAttrId : pair.rightAttrId;
+        const idx = attrs.findIndex(a => a.id === attrId);
+        const attr = attrs[idx];
+        // Create a ColumnReferenceNode for this attribute
+        const colRef = new ColumnReferenceNode(scope, { type: 'column', table: '', column: attr.name, schema: '' }, attr.type, attr.id, idx);
+        return {
+            expression: colRef,
+            direction: 'asc',
+            nulls: undefined
+        };
+    });
+    return new SortNode(scope, source, sortKeys);
+}
+export function ruleJoinPhysicalSelection(node, _context) {
+    // Guard: only apply to logical JoinNode, not already-physical nodes
+    if (!(node instanceof JoinNode))
+        return null;
+    const joinType = node.joinType;
+    // Support INNER, LEFT, SEMI, and ANTI joins
+    if (joinType !== 'inner' && joinType !== 'left' && joinType !== 'semi' && joinType !== 'anti')
+        return null;
+    // Build attribute ID sets for left and right
+    const leftAttrs = node.left.getAttributes();
+    const rightAttrs = node.right.getAttributes();
+    const leftAttrIds = new Set(leftAttrs.map(a => a.id));
+    const rightAttrIds = new Set(rightAttrs.map(a => a.id));
+    // Try to extract equi-join pairs from condition (or USING)
+    let extracted = null;
+    if (node.condition) {
+        extracted = extractEquiPairs(node.condition, leftAttrIds, rightAttrIds);
+    }
+    else if (node.usingColumns) {
+        // Convert USING columns to equi-pairs
+        const equiPairs = [];
+        for (const colName of node.usingColumns) {
+            const lowerName = colName.toLowerCase();
+            const leftAttr = leftAttrs.find(a => a.name.toLowerCase() === lowerName);
+            const rightAttr = rightAttrs.find(a => a.name.toLowerCase() === lowerName);
+            if (leftAttr && rightAttr) {
+                equiPairs.push({ leftAttrId: leftAttr.id, rightAttrId: rightAttr.id });
+            }
+        }
+        if (equiPairs.length > 0) {
+            extracted = { equiPairs, residual: undefined };
+        }
+    }
+    if (!extracted || extracted.equiPairs.length === 0)
+        return null;
+    // Cost comparison: nested loop vs hash join vs merge join
+    const leftRows = node.left.estimatedRows ?? 100;
+    const rightRows = node.right.estimatedRows ?? 100;
+    const nlCost = nestedLoopJoinCost(leftRows, rightRows);
+    // Hash join cost: build side is the smaller input
+    const buildRows = Math.min(leftRows, rightRows);
+    const probeRows = Math.max(leftRows, rightRows);
+    const hashCostValue = hashJoinCost(buildRows, probeRows);
+    // Merge join cost: depends on whether inputs are already sorted
+    const leftOrdered = isOrderedOnEquiPairs(node.left, extracted.equiPairs, 'left');
+    const rightOrdered = isOrderedOnEquiPairs(node.right, extracted.equiPairs, 'right');
+    const mergeCostValue = mergeJoinCost(leftRows, rightRows, !leftOrdered, !rightOrdered);
+    let bestAlgo = 'nested-loop';
+    let bestCost = nlCost;
+    if (hashCostValue < bestCost) {
+        bestAlgo = 'hash';
+        bestCost = hashCostValue;
+    }
+    if (mergeCostValue < bestCost) {
+        bestAlgo = 'merge';
+        bestCost = mergeCostValue;
+    }
+    if (bestAlgo === 'nested-loop') {
+        log('Nested loop cheapest (nl=%.2f, hash=%.2f, merge=%.2f) for %d x %d rows', nlCost, hashCostValue, mergeCostValue, leftRows, rightRows);
+        return null;
+    }
+    log('Selecting %s join (nl=%.2f, hash=%.2f, merge=%.2f) for %d x %d rows', bestAlgo, nlCost, hashCostValue, mergeCostValue, leftRows, rightRows);
+    // Preserve attribute IDs from the logical JoinNode
+    const preserveAttrs = node.getAttributes().slice();
+    if (bestAlgo === 'merge') {
+        // Build merge join, inserting SortNodes if needed
+        let leftSource = node.left;
+        let rightSource = node.right;
+        if (!leftOrdered) {
+            leftSource = createSortForEquiPairs(node.left, extracted.equiPairs, 'left', node.scope);
+            log('Inserted left sort for merge join');
+        }
+        if (!rightOrdered) {
+            rightSource = createSortForEquiPairs(node.right, extracted.equiPairs, 'right', node.scope);
+            log('Inserted right sort for merge join');
+        }
+        return new MergeJoinNode(node.scope, leftSource, rightSource, joinType, extracted.equiPairs, extracted.residual, preserveAttrs);
+    }
+    // Hash join path
+    // Determine build and probe sides: build=smaller, probe=larger
+    // For LEFT JOIN, the left side MUST remain the probe side to preserve
+    // null-padding semantics (all left rows must appear in output).
+    let probeSource = node.left;
+    let buildSource = node.right;
+    let equiPairs = extracted.equiPairs;
+    // For INNER join, swap sides if left is smaller (becomes build side).
+    // For LEFT/SEMI/ANTI, left must remain probe to preserve semantics.
+    if (joinType === 'inner' && leftRows < rightRows) {
+        // Swap: left becomes build, right becomes probe
+        probeSource = node.right;
+        buildSource = node.left;
+        // Flip equi-pair directions
+        equiPairs = extracted.equiPairs.map(p => ({
+            leftAttrId: p.rightAttrId,
+            rightAttrId: p.leftAttrId
+        }));
+    }
+    return new BloomJoinNode(node.scope, probeSource, buildSource, joinType, equiPairs, extracted.residual, preserveAttrs);
+}
+//# sourceMappingURL=rule-join-physical-selection.js.map

package/dist/src/planner/rules/join/rule-join-physical-selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-join-physical-selection.js","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-physical-selection.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/retrieve/rule-grow-retrieve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-grow-retrieve.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/retrieve/rule-grow-retrieve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAoB,KAAK,QAAQ,EAA2B,MAAM,0BAA0B,CAAC;AACpG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAkC7D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAgHrF"}
+{"version":3,"file":"rule-grow-retrieve.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/retrieve/rule-grow-retrieve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAoB,KAAK,QAAQ,EAAgD,MAAM,0BAA0B,CAAC;AACzH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAmC7D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAgHrF"}

package/dist/src/planner/rules/retrieve/rule-grow-retrieve.js

@@ -25,6 +25,7 @@ import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
 import { seqScanCost } from '../../cost/index.js';
 import { extractOrderingFromSortKeys } from '../../framework/physical-utils.js';
 import { PlanNodeType as _PlanNodeType } from '../../nodes/plan-node-type.js';
+import { BinaryOpNode } from '../../nodes/scalar.js';
 import { collectBindingsInPlan } from '../../analysis/binding-collector.js';
 const log = createLogger('optimizer:rule:grow-retrieve');
 function isIndexStyleContext(ctx) {
@@ -177,10 +178,11 @@ function fallbackIndexSupports(node, candidatePipeline, context, tableRef) {
         filters: [],
         requiredOrdering: undefined,
         limit: undefined,
-        estimatedRows: tableRef.estimatedRows ?? context.stats.tableRows(tableSchema) ?? 1000
+        estimatedRows: tableRef.estimatedRows || context.stats.tableRows(tableSchema) || 1000
     };
     // Extract information based on node type
     let residualPredicate;
+    let plannerConstraints;
     if (node instanceof FilterNode) {
         // Extract constraints from filter predicate
         const tableInfo = createTableInfoFromNode(tableRef, tableSchema.name);
@@ -190,9 +192,10 @@ function fallbackIndexSupports(node, candidatePipeline, context, tableRef) {
             log('No extractable constraints from filter predicate');
             return undefined;
         }
-        request.filters = extraction.allConstraints;
+        plannerConstraints = extraction.allConstraints;
+        request.filters = plannerConstraints;
         residualPredicate = extraction.residualPredicate;
-        log('Extracted %d constraints from Filter', extraction.allConstraints.length);
+        log('Extracted %d constraints from Filter', plannerConstraints.length);
     }
     else if (node.nodeType === PlanNodeType.Sort) {
         // Extract ordering requirements from Sort node
@@ -246,12 +249,39 @@ function fallbackIndexSupports(node, candidatePipeline, context, tableRef) {
         return undefined;
     }
     log('Index-style fallback beneficial: cost %d vs %d seq scan', accessPlan.cost, seqCost);
+    // Compute full residual: extraction residual + source expressions of unhandled constraints.
+    // The extractor marks constraints it can decompose (e.g., LIKE), but the module may not
+    // handle them.  Those unhandled constraints must be preserved as a residual filter.
+    if (plannerConstraints && plannerConstraints.length > 0) {
+        const unhandledExprs = [];
+        for (let i = 0; i < plannerConstraints.length; i++) {
+            if (!accessPlan.handledFilters[i] && plannerConstraints[i].sourceExpression) {
+                unhandledExprs.push(plannerConstraints[i].sourceExpression);
+            }
+        }
+        if (unhandledExprs.length > 0) {
+            const parts = residualPredicate ? [residualPredicate, ...unhandledExprs] : unhandledExprs;
+            if (parts.length === 1) {
+                residualPredicate = parts[0];
+            }
+            else {
+                let acc = parts[0];
+                for (let i = 1; i < parts.length; i++) {
+                    const right = parts[i];
+                    const ast = { type: 'binary', operator: 'AND', left: acc.expression, right: right.expression };
+                    acc = new BinaryOpNode(acc.scope, ast, acc, right);
+                }
+                residualPredicate = acc;
+            }
+            log('Added %d unhandled constraint expressions to residual', unhandledExprs.length);
+        }
+    }
     // Store context for later use in ruleSelectAccessPath
     const indexCtx = {
         kind: 'index-style',
         accessPlan,
         residualPredicate,
-        originalConstraints: [...request.filters] // Copy to satisfy mutable type
+        originalConstraints: plannerConstraints ? [...plannerConstraints] : []
     };
     return {
         cost: accessPlan.cost,