@quereus/quereus 4.4.1 → 4.6.0

package/dist/src/planner/rules/subquery/rule-anti-join-fk-empty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-anti-join-fk-empty.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-anti-join-fk-empty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA6CzF"}
+{"version":3,"file":"rule-anti-join-fk-empty.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-anti-join-fk-empty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAuDzF"}

package/dist/src/planner/rules/subquery/rule-anti-join-fk-empty.js

@@ -33,7 +33,7 @@ import { createLogger } from '../../../common/logger.js';
 import { JoinNode, extractEquiPairsFromCondition } from '../../nodes/join-node.js';
 import { EmptyRelationNode } from '../../nodes/empty-relation-node.js';
 import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
-import { lookupCoveringFK, isRowPreservingPathToTable, tableSchemaOf } from '../../util/ind-utils.js';
+import { lookupCoveringFK, isRowPreservingPathToTable, resolveTableColumnMapping, mapColumnsToTable } from '../../util/ind-utils.js';
 import { isAndOfColumnEqualities } from '../join/rule-join-elimination.js';
 import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
 const log = createLogger('optimizer:rule:anti-join-fk-empty');
@@ -52,12 +52,20 @@ export function ruleAntiJoinFkEmpty(node, _context) {
     const pairs = extractEquiPairsFromCondition(node.condition, leftAttrs, rightAttrs);
     if (pairs.length === 0)
         return null;
-    const leftSchema = tableSchemaOf(node.left);
-    const rightSchema = tableSchemaOf(node.right);
-    if (!leftSchema || !rightSchema)
+    // Equi-pairs index each side's OUTPUT columns; the FK lookup speaks base-table
+    // column indices. Translate before comparing — a projection on either side can
+    // rename, reorder, or drop columns, and a derived column has no table origin
+    // at all (mapColumnsToTable then declines).
+    const leftMapping = resolveTableColumnMapping(node.left);
+    const rightMapping = resolveTableColumnMapping(node.right);
+    if (!leftMapping || !rightMapping)
         return null;
-    const childEquiCols = pairs.map(p => p.left);
-    const parentEquiCols = pairs.map(p => p.right);
+    const childEquiCols = mapColumnsToTable(pairs.map(p => p.left), leftMapping);
+    const parentEquiCols = mapColumnsToTable(pairs.map(p => p.right), rightMapping);
+    if (!childEquiCols || !parentEquiCols)
+        return null;
+    const leftSchema = leftMapping.schema;
+    const rightSchema = rightMapping.schema;
     const match = lookupCoveringFK(leftSchema, rightSchema, childEquiCols, parentEquiCols);
     if (!match)
         return null;
@@ -66,8 +74,10 @@ export function ruleAntiJoinFkEmpty(node, _context) {
     if (match.nullable)
         return null;
     // The parent side must expose the full base-table row set — otherwise the
-    // IND `L.fk ⊆ R.pk` doesn't guarantee a match in the filtered relation.
-    if (!isRowPreservingPathToTable(node.right))
+    // IND `L.fk ⊆ R.pk` doesn't guarantee a match in the filtered relation. A
+    // projection is peeled (it never drops rows); its column renaming is already
+    // accounted for by the mapping above.
+    if (!isRowPreservingPathToTable(node.right, { throughProject: true }))
         return null;
     // Refuse to fold to Empty when either participating subtree carries a write —
     // the anti-join collapses to EmptyRelation(L's attrs), dropping both sides.

package/dist/src/planner/rules/subquery/rule-anti-join-fk-empty.js.map

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

package/dist/src/planner/rules/subquery/rule-semi-join-fk-trivial.d.ts

@@ -8,7 +8,9 @@
  *   SemiJoin(L, R, p)
  *     where p is an AND-of-column-equalities,
  *     L's equi columns form a declared FK referencing R's PK, and
- *     R is a row-preserving path to its base table.
+ *     R is a row-preserving path to its base table (projections included — the
+ *     uncorrelated `IN` arm hands the join the subquery's SELECT list verbatim,
+ *     so R is typically `Project(parent)`).
  *
  * Rewrite:
  *   - FK columns all NOT NULL → replace the SemiJoin with L (every L row matches

package/dist/src/planner/rules/subquery/rule-semi-join-fk-trivial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-semi-join-fk-trivial.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-semi-join-fk-trivial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAA6B,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAc7D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA+C3F"}
+{"version":3,"file":"rule-semi-join-fk-trivial.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-semi-join-fk-trivial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAA6B,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAc7D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA8D3F"}

package/dist/src/planner/rules/subquery/rule-semi-join-fk-trivial.js

@@ -8,7 +8,9 @@
  *   SemiJoin(L, R, p)
  *     where p is an AND-of-column-equalities,
  *     L's equi columns form a declared FK referencing R's PK, and
- *     R is a row-preserving path to its base table.
+ *     R is a row-preserving path to its base table (projections included — the
+ *     uncorrelated `IN` arm hands the join the subquery's SELECT list verbatim,
+ *     so R is typically `Project(parent)`).
  *
  * Rewrite:
  *   - FK columns all NOT NULL → replace the SemiJoin with L (every L row matches
@@ -27,7 +29,7 @@ import { FilterNode } from '../../nodes/filter.js';
 import { UnaryOpNode, BinaryOpNode } from '../../nodes/scalar.js';
 import { ColumnReferenceNode } from '../../nodes/reference.js';
 import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
-import { lookupCoveringFK, isRowPreservingPathToTable, tableSchemaOf } from '../../util/ind-utils.js';
+import { lookupCoveringFK, isRowPreservingPathToTable, resolveTableColumnMapping, mapColumnsToTable } from '../../util/ind-utils.js';
 import { isAndOfColumnEqualities } from '../join/rule-join-elimination.js';
 import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
 const log = createLogger('optimizer:rule:semi-join-fk-trivial');
@@ -46,18 +48,31 @@ export function ruleSemiJoinFkTrivial(node, _context) {
     const pairs = extractEquiPairsFromCondition(node.condition, leftAttrs, rightAttrs);
     if (pairs.length === 0)
         return null;
-    const leftSchema = tableSchemaOf(node.left);
-    const rightSchema = tableSchemaOf(node.right);
-    if (!leftSchema || !rightSchema)
+    // Equi-pairs index each side's OUTPUT columns; the FK lookup speaks base-table
+    // column indices. Translate before comparing — a projection on either side can
+    // rename, reorder, or drop columns, and a derived column has no table origin
+    // at all (mapColumnsToTable then declines).
+    const leftMapping = resolveTableColumnMapping(node.left);
+    const rightMapping = resolveTableColumnMapping(node.right);
+    if (!leftMapping || !rightMapping)
         return null;
-    const childEquiCols = pairs.map(p => p.left);
-    const parentEquiCols = pairs.map(p => p.right);
+    const childOutputCols = pairs.map(p => p.left);
+    const childEquiCols = mapColumnsToTable(childOutputCols, leftMapping);
+    const parentEquiCols = mapColumnsToTable(pairs.map(p => p.right), rightMapping);
+    if (!childEquiCols || !parentEquiCols)
+        return null;
+    const leftSchema = leftMapping.schema;
+    const rightSchema = rightMapping.schema;
     const match = lookupCoveringFK(leftSchema, rightSchema, childEquiCols, parentEquiCols);
     if (!match)
         return null;
     // The parent side must be the full table — if rows were filtered out, the
     // IND inclusion doesn't preserve "every L row has a match" under filtering.
-    if (!isRowPreservingPathToTable(node.right))
+    // A projection is peeled: `extractUncorrelatedIn` hands the join the IN
+    // subquery verbatim, so R is a `Project` over the parent table, and a
+    // projection never drops rows. Its column renaming is already accounted for
+    // by the mapping above.
+    if (!isRowPreservingPathToTable(node.right, { throughProject: true }))
         return null;
     // Refuse to drop the R side when it carries a write — the rewrite replaces
     // the semi-join with L (or Filter(L)) and the R subtree is dropped entirely.
@@ -70,8 +85,10 @@ export function ruleSemiJoinFkTrivial(node, _context) {
         return node.left;
     }
     // Nullable FK: rows with NULL in any FK column never match in the semi-join.
-    // Replace the join with `Filter(L, fk IS NOT NULL AND …)`.
-    const predicate = buildIsNotNullPredicate(node.scope, leftAttrs, childEquiCols);
+    // Replace the join with `Filter(L, fk IS NOT NULL AND …)`. The predicate is
+    // built over L's OUTPUT columns (`childOutputCols`), not the base-table
+    // indices the FK lookup consumed.
+    const predicate = buildIsNotNullPredicate(node.scope, leftAttrs, childOutputCols);
     if (!predicate)
         return null;
     log('Trivializing semi-join over nullable FK %s → %s to Filter(L, fk IS NOT NULL)', leftSchema.name, rightSchema.name);

package/dist/src/planner/rules/subquery/rule-semi-join-fk-trivial.js.map

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

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

@@ -1,21 +1,39 @@
 /**
  * Rule: Subquery Decorrelation
  *
- * Transforms correlated EXISTS and IN subqueries in WHERE-clause FilterNode
- * predicates into equivalent semi/anti joins, enabling hash join selection
- * and eliminating per-row re-execution of the inner query.
+ * Transforms EXISTS and IN subqueries in WHERE-clause FilterNode predicates
+ * into equivalent semi/anti joins, enabling hash join selection and
+ * eliminating per-row re-execution (correlated) or set-probe evaluation
+ * (uncorrelated) of the inner query.
  *
  * Transformations:
  *   Filter[EXISTS(correlated)](outer)  →  SemiJoin[corr_pred](outer, inner)
  *   Filter[NOT EXISTS(correlated)](outer) → AntiJoin[corr_pred](outer, inner)
  *   Filter[col IN (correlated subquery)](outer) → SemiJoin[col = inner.col](outer, inner)
+ *   Filter[col IN (uncorrelated subquery)](outer) → SemiJoin[col = inner.col0](outer, inner)
  *
  * Applicability:
  * - FilterNode with top-level ExistsNode, NOT ExistsNode, or InNode (subquery variant)
- * - Subquery is correlated (references outer attributes)
- * - Correlation predicate is a simple equi-join condition (col = col across inner/outer)
+ * - Correlated arms: subquery references outer attributes and the correlation
+ *   predicate is a simple equi-join condition (col = col across inner/outer)
+ * - Uncorrelated IN arm: bare outer column on the left of IN, deterministic
+ *   read-only inner, hashable synthesized equi-pair, and agreeing IN/`=`
+ *   collation resolutions (see `extractUncorrelatedIn`). The inner tree is used
+ *   VERBATIM as the join's right side — no descent, so inner LIMIT / DISTINCT /
+ *   set-ops / CTE bodies are preserved as-is.
  *
- * NOT IN is deferred due to NULL semantics complexity.
+ * Why the uncorrelated IN rewrite is sound in WHERE position ONLY: `x IN S` is
+ * three-valued — it yields NULL (not FALSE) when `x` is NULL, or when there is
+ * no match and `S` contains a NULL. A FilterNode predicate collapses NULL to
+ * "drop the row", and a semi join also drops a row with no match (NULL never
+ * equals under `=`), so under a WHERE filter the two agree on every case.
+ * Projection-position IN must keep its three-valued answer and stays on the
+ * runtime set-probe path (`emitIn`), which also remains the fallback whenever
+ * any gate declines.
+ *
+ * NOT IN is deferred due to NULL semantics complexity (the parser builds it as
+ * UnaryOp(NOT) over the InNode, so it never matches these top-level-conjunct
+ * shapes).
  *
  * A SECOND ANCHOR (`ruleExistsInSelectDecorrelation`, ProjectNode) handles the
  * same subqueries appearing in a SELECT list, where a semi/anti join cannot be

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

@@ -1 +1 @@
-{"version":3,"file":"rule-subquery-decorrelation.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-subquery-decorrelation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAAoB,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAgP7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkF/F;AAmCD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkCrG"}
+{"version":3,"file":"rule-subquery-decorrelation.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/subquery/rule-subquery-decorrelation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAIH,OAAO,EAAoB,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAqe7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkB/F;AAmCD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkCrG"}

package/dist/src/planner/rules/subquery/rule-subquery-decorrelation.js

@@ -1,21 +1,39 @@
 /**
  * Rule: Subquery Decorrelation
  *
- * Transforms correlated EXISTS and IN subqueries in WHERE-clause FilterNode
- * predicates into equivalent semi/anti joins, enabling hash join selection
- * and eliminating per-row re-execution of the inner query.
+ * Transforms EXISTS and IN subqueries in WHERE-clause FilterNode predicates
+ * into equivalent semi/anti joins, enabling hash join selection and
+ * eliminating per-row re-execution (correlated) or set-probe evaluation
+ * (uncorrelated) of the inner query.
  *
  * Transformations:
  *   Filter[EXISTS(correlated)](outer)  →  SemiJoin[corr_pred](outer, inner)
  *   Filter[NOT EXISTS(correlated)](outer) → AntiJoin[corr_pred](outer, inner)
  *   Filter[col IN (correlated subquery)](outer) → SemiJoin[col = inner.col](outer, inner)
+ *   Filter[col IN (uncorrelated subquery)](outer) → SemiJoin[col = inner.col0](outer, inner)
  *
  * Applicability:
  * - FilterNode with top-level ExistsNode, NOT ExistsNode, or InNode (subquery variant)
- * - Subquery is correlated (references outer attributes)
- * - Correlation predicate is a simple equi-join condition (col = col across inner/outer)
+ * - Correlated arms: subquery references outer attributes and the correlation
+ *   predicate is a simple equi-join condition (col = col across inner/outer)
+ * - Uncorrelated IN arm: bare outer column on the left of IN, deterministic
+ *   read-only inner, hashable synthesized equi-pair, and agreeing IN/`=`
+ *   collation resolutions (see `extractUncorrelatedIn`). The inner tree is used
+ *   VERBATIM as the join's right side — no descent, so inner LIMIT / DISTINCT /
+ *   set-ops / CTE bodies are preserved as-is.
  *
- * NOT IN is deferred due to NULL semantics complexity.
+ * Why the uncorrelated IN rewrite is sound in WHERE position ONLY: `x IN S` is
+ * three-valued — it yields NULL (not FALSE) when `x` is NULL, or when there is
+ * no match and `S` contains a NULL. A FilterNode predicate collapses NULL to
+ * "drop the row", and a semi join also drops a row with no match (NULL never
+ * equals under `=`), so under a WHERE filter the two agree on every case.
+ * Projection-position IN must keep its three-valued answer and stays on the
+ * runtime set-probe path (`emitIn`), which also remains the fallback whenever
+ * any gate declines.
+ *
+ * NOT IN is deferred due to NULL semantics complexity (the parser builds it as
+ * UnaryOp(NOT) over the InNode, so it never matches these top-level-conjunct
+ * shapes).
  *
  * A SECOND ANCHOR (`ruleExistsInSelectDecorrelation`, ProjectNode) handles the
  * same subqueries appearing in a SELECT list, where a semi/anti join cannot be
@@ -41,6 +59,9 @@ import { PlanNodeType } from '../../nodes/plan-node-type.js';
 import { splitConjuncts, combineConjuncts } from '../../analysis/predicate-conjuncts.js';
 import { isEquiCorrelation, collectDefinedAttrIds, referencesAnyAttr } from '../../analysis/equi-correlation.js';
 import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+import { extractEquiPairs } from '../join/equi-pair-extractor.js';
+import { resolveComparisonCollation, resolveInCollationForNode } from '../../analysis/comparison-collation.js';
+import { coerceComparisonSet } from '../../building/coercion.js';
 const log = createLogger('optimizer:rule:subquery-decorrelation');
 /**
  * Identify a decorrelation candidate from a single conjunct.
@@ -49,7 +70,7 @@ function identifyCandidate(node) {
     // EXISTS(subquery)
     if (node instanceof ExistsNode) {
         if (isCorrelatedSubquery(node.subquery)) {
-            return { subqueryNode: node, joinType: 'semi', predicateNode: node };
+            return { subqueryNode: node, joinType: 'semi' };
         }
         return null;
     }
@@ -58,17 +79,20 @@ function identifyCandidate(node) {
         if (node.operand instanceof ExistsNode) {
             const exists = node.operand;
             if (isCorrelatedSubquery(exists.subquery)) {
-                return { subqueryNode: exists, joinType: 'anti', predicateNode: node };
+                return { subqueryNode: exists, joinType: 'anti' };
             }
         }
         return null;
     }
-    // col IN (correlated subquery)
+    // col IN (subquery) — correlated and uncorrelated take different extractions
     if (node instanceof InNode && node.source && !node.values) {
         if (isCorrelatedSubquery(node.source)) {
-            return { subqueryNode: node, joinType: 'semi', predicateNode: node };
+            return { subqueryNode: node, joinType: 'semi' };
         }
-        return null;
+        // Uncorrelated filter-position IN: semi join ≡ IN under WHERE's NULL
+        // collapse (see the rule header). Gates live in extractUncorrelatedIn;
+        // any decline leaves the InNode on the runtime set-probe path.
+        return { subqueryNode: node, joinType: 'semi', uncorrelatedIn: true };
     }
     return null;
 }
@@ -159,15 +183,13 @@ function extractInCorrelation(inNode, outerAttrIds) {
     if (innerAttrs.length === 0)
         return null;
     const innerFirstAttr = innerAttrs[0];
-    // Build the equi-join condition: outer.col = inner.firstCol
-    // We need a BinaryOpNode with = between the outer column ref and an inner column ref
-    const innerColRef = new ColumnReferenceNode(outerColRef.scope, outerColRef.expression, // reuse expression for formatting
-    innerFirstAttr.type, innerFirstAttr.id, 0 // column index in the inner relation
-    );
-    const equiCondition = new BinaryOpNode(outerColRef.scope, { type: 'binary', operator: '=', left: outerColRef.expression, right: innerColRef.expression }, outerColRef, innerColRef);
     // Walk through the subquery to find any additional correlation filters
     let current = subqueryRoot;
-    // Skip Project and Alias nodes
+    // Skip Project and Alias nodes.
+    // NOTE: every other root (Distinct, SetOperation, Sort, CTE body, Aggregate, …)
+    // is caught only by the post-build external-reference backstop in
+    // decorrelateOneConjunct — widening this descent without keeping that backstop
+    // would silently bury the correlation inside the join's right side again.
     while (current.nodeType === PlanNodeType.Project || current.nodeType === PlanNodeType.Alias) {
         const children = current.getChildren();
         const source = children[0];
@@ -175,9 +197,44 @@ function extractInCorrelation(inNode, outerAttrIds) {
             break;
         current = source;
     }
+    // Gate: a LIMIT/OFFSET reached by the descent sits ABOVE the correlated
+    // filter, so it applies per outer row — a single semi join cannot express
+    // that. (A LIMIT *below* the correlated filter, inside a derived table, is
+    // uncorrelated and never reached here.)
+    if (current.nodeType === PlanNodeType.LimitOffset)
+        return null;
+    // Whatever the descent landed on becomes the join's right side (minus the
+    // correlated filter, when one was found).
+    const innerSource = current instanceof FilterNode ? current.source : current;
+    // Gate: the right side must actually expose the IN comparison target. A bare
+    // column projection preserves the source column's attribute id, but a
+    // COMPUTED projection (`select b.x + 0 …`) mints a fresh id that nothing
+    // below defines — the join condition would reference an attribute no side
+    // provides. Mirrors the SELECT-list sibling's key-attribute lookup.
+    const innerKeyIndex = innerSource.getAttributes().findIndex(a => a.id === innerFirstAttr.id);
+    if (innerKeyIndex < 0)
+        return null;
+    // Build the equi-join condition: outer.col = inner.firstCol. The inner
+    // reference gets its OWN AST — reusing the outer column's expression made
+    // EXPLAIN render every decorrelated IN condition as the nonsense `a.x = a.x`.
+    const innerColRef = new ColumnReferenceNode(outerColRef.scope, { type: 'column', name: innerFirstAttr.name }, innerFirstAttr.type, innerFirstAttr.id, innerKeyIndex);
+    // Reconcile the two operands exactly as a hand-written `=` would be. Building the
+    // BinaryOpNode raw bypassed the plan-build coercion every other comparison site gets,
+    // so `json_col in (select text_col …)` compared a native JS object against a string
+    // and never matched, and `int_col in (select text_col …)` compared a number against a
+    // string. `coerceComparisonSet` is the IN-shaped helper — the same one the IN
+    // value-list and simple-CASE builders call, and the same one `extractUncorrelatedIn`
+    // calls, so the two decorrelation arms and the runtime set probe cannot split.
+    //
+    // The now-CastNode-wrapped side demotes this conjunct out of `extractEquiPairs`
+    // (which requires two bare column references) into the join's residual — the correct
+    // destination, since the residual is where `=`'s own semantics apply, and the join
+    // still keys on the genuine correlation pair.
+    const [coercedOuter, [coercedInner]] = coerceComparisonSet(outerColRef.scope, outerColRef, [innerColRef]);
+    const equiCondition = new BinaryOpNode(outerColRef.scope, { type: 'binary', operator: '=', left: coercedOuter.expression, right: coercedInner.expression }, coercedOuter, coercedInner);
     // If there's a filter with additional correlation, extract it
     if (current instanceof FilterNode) {
-        const innerAttrIds = collectDefinedAttrIds(current.source);
+        const innerAttrIds = collectDefinedAttrIds(innerSource);
         const conjuncts = splitConjuncts(current.predicate);
         const additionalCorrelation = [];
         const innerOnly = [];
@@ -199,77 +256,193 @@ function extractInCorrelation(inNode, outerAttrIds) {
         const correlationCondition = combineConjuncts(allCorrelation);
         const residualInnerFilter = combineConjuncts(innerOnly);
         return {
-            innerSource: current.source,
+            innerSource,
             correlationCondition,
             residualInnerFilter,
         };
     }
     // No inner filter — the only correlation is the IN condition itself
     return {
-        innerSource: current,
+        innerSource,
         correlationCondition: equiCondition,
         residualInnerFilter: null,
     };
 }
-export function ruleSubqueryDecorrelation(node, _context) {
-    if (!(node instanceof FilterNode))
+/**
+ * Recognize an uncorrelated filter-position `col IN (subquery)` and build the
+ * semi-join right side + condition. Every gate declines to `null`, leaving the
+ * InNode on the runtime set-probe path (`emitIn`) — the O(K + N·log K) floor;
+ * a decline only costs the better plan, never correctness.
+ */
+function extractUncorrelatedIn(inNode, outerAttrIds) {
+    const right = inNode.source;
+    if (!right)
+        return null;
+    // Gate: bare outer column on the left of IN. A non-column left side would
+    // fail the equi-pair gate below anyway; requiring it up front keeps the
+    // decline reason in one place.
+    if (!(inNode.condition instanceof ColumnReferenceNode))
+        return null;
+    const outerColRef = inNode.condition;
+    if (!outerAttrIds.has(outerColRef.attributeId))
         return null;
+    // Gate: mirror the runtime set probe's own admission (emitIn's uncorrelated
+    // arm requires a functional source) so the two paths accept the same shapes.
+    // A non-deterministic inner must keep its per-outer-row evaluation
+    // semantics; side effects were already refused by the caller.
+    if (!PlanNodeCharacteristics.isFunctional(right))
+        return null;
+    // Build-time validation guarantees an IN subquery exposes exactly one column.
+    const innerAttr = right.getAttributes()[0];
+    if (!innerAttr)
+        return null;
+    // Synthesize `outer.col = inner.col0`, giving the inner reference its OWN
+    // AST rather than reusing the outer column's expression (which is why the
+    // correlated arm's condition renders as the nonsense `a.x = a.x` in EXPLAIN).
+    const innerColRef = new ColumnReferenceNode(outerColRef.scope, { type: 'column', name: innerAttr.name }, innerAttr.type, innerAttr.id, 0 // column index in the inner relation
+    );
+    // Reconcile the operands exactly as a hand-written `=` would be, for the same
+    // reason `extractInCorrelation` does: this raw BinaryOpNode bypasses the coercion
+    // `buildExpression` applies. When a cast IS inserted (a JSON/TEXT or numeric/TEXT
+    // pair), the wrapper fails the equi-pair gate below and the conjunct declines to
+    // the set-probe path — whose `inMembershipKeys` performs the same conversion per
+    // row. That decline is the point: a hash join keyed on the RAW values would rank a
+    // number against a numeric-looking string by storage class and match nothing,
+    // disagreeing with every other spelling of the comparison.
+    // NOTE: the decline costs the hash-join shape for cross-type uncorrelated INs — the
+    // set probe materializes the inner side once and probes per outer row, which is fine
+    // at current inner sizes. If a cross-type `col in (select …)` over a large inner ever
+    // shows up as slow, the move is a coercion-aware equi-pair (key both sides on the
+    // cast result), not reverting the coercion.
+    const [coercedOuter, [coercedInner]] = coerceComparisonSet(outerColRef.scope, outerColRef, [innerColRef]);
+    const condition = new BinaryOpNode(outerColRef.scope, { type: 'binary', operator: '=', left: coercedOuter.expression, right: coercedInner.expression }, coercedOuter, coercedInner);
+    // Gate (the O(N×K)-floor guardrail): the synthesized condition must survive
+    // the SAME extraction rule-join-physical-selection uses, as exactly one
+    // equi-pair with no residual. That is that rule's only structural
+    // precondition, so the join always reaches its hash/merge/NL cost
+    // comparison with a usable hashable pair — the inner side is materialized
+    // once (hash build) rather than re-driven per outer row. This also folds in
+    // the collation-conflict and semantic-ordering-agreement declines (a mixed
+    // TIMESPAN/TEXT pair keeps the set-probe path, whose semanticKeyTransform
+    // handles it).
+    // NOTE: nested loop can still win the cost comparison when the OUTER is
+    // tiny (L ≤ ~2 under current COST_CONSTANTS); rule-nested-loop-right-cache
+    // then wraps the uncorrelated right in a CacheNode whose abandon threshold
+    // is the subject of backlog/bug-cache-threshold-abandon-cliff. A one-row
+    // outer scanning the inner once is not a cliff, so that interaction is
+    // confined to the harmless quadrant.
+    const rightAttrIds = new Set(right.getAttributes().map(a => a.id));
+    const extraction = extractEquiPairs(condition, outerAttrIds, rightAttrIds);
+    if (!extraction || extraction.equiPairs.length !== 1 || extraction.residual)
+        return null;
+    // Gate: the IN membership collation and the synthesized `=`'s collation
+    // must both resolve (no conflict) to the SAME name — a divergence would
+    // silently change which rows match. `inRhsTypes` reduces a subquery RHS to
+    // its single output column's type, the same operand pair the `=` sees, so
+    // agreement is expected; assert it rather than assume it.
+    const inResolution = resolveInCollationForNode(inNode);
+    const eqResolution = resolveComparisonCollation(inNode.condition.getType(), innerAttr.type);
+    if (inResolution.kind !== 'resolved' || eqResolution.kind !== 'resolved'
+        || inResolution.name !== eqResolution.name) {
+        return null;
+    }
+    return { right, condition };
+}
+/**
+ * Decorrelate the first rewritable EXISTS/IN conjunct of one FilterNode.
+ * Returns the semi/anti join (with any remaining conjuncts re-wrapped in a
+ * FilterNode above it), or null when no conjunct rewrites.
+ */
+function decorrelateOneConjunct(node) {
     const outerSource = node.source;
     const outerAttrIds = new Set(outerSource.getAttributes().map(a => a.id));
     // Split the filter predicate into conjuncts
     const conjuncts = splitConjuncts(node.predicate);
-    // Find the first decorrelation candidate
-    let candidateIndex = -1;
-    let candidate = null;
     for (let i = 0; i < conjuncts.length; i++) {
-        candidate = identifyCandidate(conjuncts[i]);
-        if (candidate) {
-            candidateIndex = i;
-            break;
+        const candidate = identifyCandidate(conjuncts[i]);
+        if (!candidate)
+            continue;
+        // Decorrelating EXISTS/IN into a semi/anti join changes how many times the
+        // inner subquery's subtree executes (per outer row → once per matching outer
+        // row in the semi-join driver). Refuse on impure inners so DML-bearing
+        // subqueries keep their declared per-row firing.
+        const innerRoot = candidate.subqueryNode instanceof ExistsNode
+            ? candidate.subqueryNode.subquery
+            : candidate.subqueryNode.source;
+        if (innerRoot && PlanNodeCharacteristics.subtreeHasSideEffects(innerRoot)) {
+            log('Decorrelation skipped: inner subquery has side effects');
+            continue;
         }
+        log('Found %s decorrelation candidate in filter predicate', candidate.joinType);
+        // Extract the join right side and condition based on the candidate arm
+        let joinRight;
+        let joinCondition;
+        if (candidate.uncorrelatedIn) {
+            const rewrite = extractUncorrelatedIn(candidate.subqueryNode, outerAttrIds);
+            if (!rewrite) {
+                log('Uncorrelated IN gates declined; conjunct keeps the set-probe path');
+                continue;
+            }
+            joinRight = rewrite.right;
+            joinCondition = rewrite.condition;
+        }
+        else {
+            const extraction = candidate.subqueryNode instanceof ExistsNode
+                ? extractExistsCorrelation(candidate.subqueryNode.subquery, outerAttrIds)
+                : extractInCorrelation(candidate.subqueryNode, outerAttrIds);
+            if (!extraction) {
+                log('Could not extract simple equi-correlation; skipping conjunct');
+                continue;
+            }
+            // If there are residual inner-only predicates, wrap the inner in a FilterNode
+            joinRight = extraction.residualInnerFilter
+                ? new FilterNode(extraction.innerSource.scope, extraction.innerSource, extraction.residualInnerFilter)
+                : extraction.innerSource;
+            joinCondition = extraction.correlationCondition;
+            // Correctness backstop: every correlation must have been LIFTED into the
+            // join condition. Anything still referencing an outer scope from inside
+            // the right side would be driven as if uncorrelated (a semi join does not
+            // re-establish the outer row context), so decline and leave the conjunct
+            // on the per-row path. Mirrors the SELECT-list sibling's
+            // `collectExternalReferences(distinctRight)` check.
+            if (collectExternalReferences(joinRight).size !== 0) {
+                log('Right side retains external references after extraction; skipping conjunct');
+                continue;
+            }
+        }
+        // Build the semi/anti join
+        const joinNode = new JoinNode(outerSource.scope, outerSource, joinRight, candidate.joinType, joinCondition);
+        log('Decorrelated %s subquery into %s JOIN', candidate.subqueryNode.nodeType, candidate.joinType.toUpperCase());
+        // If there are remaining conjuncts in the original filter, wrap in a new FilterNode
+        const remainingConjuncts = conjuncts.filter((_, j) => j !== i);
+        if (remainingConjuncts.length > 0) {
+            const residualPredicate = combineConjuncts(remainingConjuncts);
+            return new FilterNode(node.scope, joinNode, residualPredicate);
+        }
+        return joinNode;
     }
-    if (!candidate || candidateIndex === -1)
-        return null;
-    // Decorrelating EXISTS/IN into a semi/anti join changes how many times the
-    // inner subquery's subtree executes (per outer row → once per matching outer
-    // row in the semi-join driver). Refuse on impure inners so DML-bearing
-    // subqueries keep their declared per-row firing.
-    const innerRoot = candidate.subqueryNode instanceof ExistsNode
-        ? candidate.subqueryNode.subquery
-        : candidate.subqueryNode.source;
-    if (innerRoot && PlanNodeCharacteristics.subtreeHasSideEffects(innerRoot)) {
-        log('Decorrelation skipped: inner subquery has side effects');
-        return null;
-    }
-    log('Found %s decorrelation candidate in filter predicate', candidate.joinType);
-    // Extract correlation info based on subquery type
-    let extraction = null;
-    if (candidate.subqueryNode instanceof ExistsNode) {
-        extraction = extractExistsCorrelation(candidate.subqueryNode.subquery, outerAttrIds);
-    }
-    else if (candidate.subqueryNode instanceof InNode) {
-        extraction = extractInCorrelation(candidate.subqueryNode, outerAttrIds);
-    }
-    if (!extraction) {
-        log('Could not extract simple equi-correlation; skipping decorrelation');
+    return null;
+}
+export function ruleSubqueryDecorrelation(node, _context) {
+    if (!(node instanceof FilterNode))
         return null;
+    // The engine never re-offers a rule its own output (see pass.ts), so loop
+    // internally: each iteration decorrelates ONE conjunct, and a residual
+    // FilterNode output feeds the next iteration. Two IN conjuncts in one WHERE
+    // thus become two stacked semi joins (the second joins against the first as
+    // its outer). Terminates: every successful iteration removes one conjunct.
+    let result = null;
+    let current = node;
+    for (;;) {
+        const rewritten = decorrelateOneConjunct(current);
+        if (!rewritten)
+            break;
+        result = rewritten;
+        if (!(rewritten instanceof FilterNode))
+            break;
+        current = rewritten;
     }
-    const { innerSource, correlationCondition, residualInnerFilter } = extraction;
-    // Build the inner side: if there are residual inner-only predicates, wrap in FilterNode
-    let joinRight = innerSource;
-    if (residualInnerFilter) {
-        joinRight = new FilterNode(innerSource.scope, innerSource, residualInnerFilter);
-    }
-    // Build the semi/anti join
-    const joinNode = new JoinNode(outerSource.scope, outerSource, joinRight, candidate.joinType, correlationCondition);
-    log('Decorrelated %s subquery into %s JOIN', candidate.subqueryNode.nodeType, candidate.joinType.toUpperCase());
-    // If there are remaining conjuncts in the original filter, wrap in a new FilterNode
-    const remainingConjuncts = conjuncts.filter((_, i) => i !== candidateIndex);
-    if (remainingConjuncts.length > 0) {
-        const residualPredicate = combineConjuncts(remainingConjuncts);
-        return new FilterNode(node.scope, joinNode, residualPredicate);
-    }
-    return joinNode;
+    return result;
 }
 /* ────────────────────────────────────────────────────────────────────────────
  * SELECT-list EXISTS / IN decorrelation (existence-flag left join)