@minnowdb/core 0.5.0 → 0.6.1

package/dist/engine/optimizer.js

@@ -1,5 +1,5 @@
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
-import { childExpressions, expressionAliases, forEachBlockExpression, forEachNestedBlock, isScalarFunctionName, scalarFunctionNames, scalarFunctionValue, splitCondition, volatileScalarFunctionNames, } from "./query.js";
+import { blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, volatileScalarFunctionNames, } from "./query.js";
 import { isSqlDomainValue } from "./sql-domains.js";
 /**
  * Deterministic plan-to-plan rewrites over the shared compiled representation. Every rule
@@ -9,9 +9,117 @@ import { isSqlDomainValue } from "./sql-domains.js";
  */
 export function optimizePlan(plan) {
     const optimized = structuredClone(plan);
-    optimizeBlock(optimized);
+    const aliases = new Set();
+    collectPlanAliases(optimized, aliases);
+    optimizeBlock(optimized, correlationAliasFactory(aliases));
     return optimized;
 }
+/**
+ * Resolves an unqualified column in a nested block against the nearest enclosing query scope
+ * when that name does not exist in the nested block itself. Compilation has no catalog, so this
+ * SQL name-resolution step runs later for database-backed plans and returns the original plan
+ * unchanged when it finds nothing to qualify.
+ */
+export function qualifyCorrelatedReferences(plan, tableColumns) {
+    if (!blockHasSubqueries(plan))
+        return plan;
+    const qualified = structuredClone(plan);
+    const changedReferences = [];
+    const outputColumns = (source) => {
+        if (source.columnAliases !== undefined)
+            return source.columnAliases;
+        if (source.derived !== undefined)
+            return source.derived.select.map(({ alias }) => alias);
+        if (source.union !== undefined) {
+            return source.union.blocks[0]?.select.map(({ alias }) => alias) ?? [];
+        }
+        if (source.windowed !== undefined) {
+            return [
+                ...source.windowed.block.select.map(({ alias }) => alias),
+                ...source.windowed.windows.map(({ alias }) => alias),
+            ];
+        }
+        if (source.recursive !== undefined) {
+            return source.recursive.base.select.map(({ alias }) => alias);
+        }
+        return tableColumns.get(source.table) ?? [];
+    };
+    const blockScope = (block) => {
+        const byColumn = new Map();
+        for (const source of [block.base, ...block.joins]) {
+            for (const column of outputColumns(source)) {
+                const aliases = byColumn.get(column) ?? [];
+                aliases.push(source.alias);
+                byColumn.set(column, aliases);
+            }
+        }
+        return byColumn;
+    };
+    const resolveBlock = (block, outerScopes) => {
+        const local = blockScope(block);
+        const rewrite = (expression) => {
+            if (expression.kind === "column" && !expression.reference.includes(".")) {
+                if ((local.get(expression.reference)?.length ?? 0) > 0)
+                    return expression;
+                for (const outer of outerScopes) {
+                    const aliases = outer.get(expression.reference) ?? [];
+                    if (aliases.length === 0)
+                        continue;
+                    if (aliases.length > 1) {
+                        throw new TypeError(`Ambiguous outer column: ${expression.reference}`);
+                    }
+                    changedReferences.push(expression.reference);
+                    return { kind: "column", reference: `${aliases[0] ?? ""}.${expression.reference}` };
+                }
+                return expression;
+            }
+            if (expression.kind === "subquery" || expression.kind === "exists") {
+                resolveBlock(expression.block, [local, ...outerScopes]);
+                return expression;
+            }
+            if (expression.kind === "window") {
+                expression.partitionBy = expression.partitionBy.map(rewrite);
+                for (const order of expression.orderBy)
+                    order.expression = rewrite(order.expression);
+                if (expression.argument !== undefined)
+                    expression.argument = rewrite(expression.argument);
+                return expression;
+            }
+            return mapChildExpressions(expression, rewrite);
+        };
+        mapBlockExpressions(block, rewrite);
+        for (const source of [block.base, ...block.joins]) {
+            const sourceOuter = source.lateral === true ? [local, ...outerScopes] : outerScopes;
+            if (source.derived !== undefined)
+                resolveBlock(source.derived, sourceOuter);
+            source.union?.blocks.forEach((member) => resolveBlock(member, sourceOuter));
+            if (source.windowed !== undefined)
+                resolveBlock(source.windowed.block, sourceOuter);
+            if (source.recursive !== undefined) {
+                resolveBlock(source.recursive.base, sourceOuter);
+                resolveBlock(source.recursive.step, sourceOuter);
+            }
+        }
+    };
+    resolveBlock(qualified, []);
+    return changedReferences.length > 0 ? qualified : plan;
+}
+/** Every source alias in a plan tree, including blocks nested inside expressions. */
+function collectPlanAliases(block, aliases) {
+    aliases.add(block.base.alias);
+    for (const join of block.joins)
+        aliases.add(join.alias);
+    const visitExpression = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            collectPlanAliases(expression.block, aliases);
+            return;
+        }
+        for (const child of childExpressions(expression))
+            visitExpression(child);
+    };
+    forEachBlockExpression(block, visitExpression);
+    forEachNestedBlock(block, (nested) => collectPlanAliases(nested, aliases));
+}
 /**
  * Cost-based build-side selection using prepared or catalog-derived row counts. A single inner
  * equi-join probes from the base into an index over the joined table, so a joined input more than
@@ -38,20 +146,30 @@ export function chooseJoinOrder(plan, inputs) {
         joins: [{ ...plan.base, kind: "inner", left, right }],
     };
 }
-function optimizeBlock(block) {
+function optimizeBlock(block, nextCorrelationAlias) {
     decorrelateLateralSources(block);
-    decorrelateBlock(block);
+    decorrelateBlock(block, nextCorrelationAlias);
     for (const source of [block.base, ...block.joins]) {
         if (source.derived !== undefined)
-            optimizeBlock(source.derived);
-        source.union?.blocks.forEach(optimizeBlock);
-        if (source.windowed !== undefined)
-            optimizeBlock(source.windowed.block);
+            optimizeBlock(source.derived, nextCorrelationAlias);
+        source.union?.blocks.forEach((member) => optimizeBlock(member, nextCorrelationAlias));
+        if (source.windowed !== undefined) {
+            optimizeBlock(source.windowed.block, nextCorrelationAlias);
+        }
         if (source.recursive !== undefined) {
-            optimizeBlock(source.recursive.base);
-            optimizeBlock(source.recursive.step);
+            optimizeBlock(source.recursive.base, nextCorrelationAlias);
+            optimizeBlock(source.recursive.step, nextCorrelationAlias);
         }
     }
+    const optimizeExpressionBlock = (expression) => {
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            optimizeBlock(expression.block, nextCorrelationAlias);
+            return;
+        }
+        for (const child of childExpressions(expression))
+            optimizeExpressionBlock(child);
+    };
+    forEachBlockExpression(block, optimizeExpressionBlock);
     foldBlockConstants(block);
     extractJoinKeys(block);
     normalizeBooleanPredicates(block);
@@ -60,7 +178,7 @@ function optimizeBlock(block) {
     pruneDerivedProjections(block);
     combineDerivedLimit(block);
 }
-/** Converts equality-correlated LATERAL derived tables into ordinary set-at-a-time joins. */
+/** Converts correlated LATERAL derived tables into ordinary set-at-a-time joins. */
 function decorrelateLateralSources(block) {
     if (block.base.lateral === true) {
         throw new TypeError("LATERAL needs a source to its left");
@@ -85,14 +203,14 @@ function decorrelateLateralSources(block) {
             inner.limit !== undefined) {
             throw new TypeError("Correlated LATERAL queries cannot use grouping, HAVING, ORDER BY, or LIMIT");
         }
-        const keys = extractCorrelation(inner, available, "LATERAL");
+        const keys = extractCorrelation(inner, available, "LATERAL", true);
         const keyAliases = keys.map((_, index) => `\u0000lateral_key_${String(index + 1)}`);
         keys.forEach((key, index) => {
             inner.select.push({ expression: key.inner, alias: keyAliases[index] ?? "" });
         });
         const correlations = keys.map((key, index) => ({
             kind: "condition",
-            operator: key.operator,
+            operator: reverseComparison(key.operator),
             left: key.outer,
             right: { kind: "column", reference: `${join.alias}.${keyAliases[index] ?? ""}` },
         }));
@@ -371,10 +489,19 @@ function coalesceOrEqualityLists(block) {
     });
 }
 const comparisonOperators = new Set(["=", "!=", "<>", ">", ">=", "<", "<="]);
-const aggregateCallNames = new Set(["COUNT", "SUM", "AVG", "MIN", "MAX"]);
-function decorrelateBlock(block) {
+const correlationKeyAlias = (index) => `\0correlation_key_${String(index)}`;
+const correlationProbeAlias = (index) => `\0correlation_probe_${String(index)}`;
+const correlationInputAlias = (index) => `\0correlation_input_${String(index)}`;
+const correlationOrderAlias = (index) => `\0correlation_order_${String(index)}`;
+const correlationValueAlias = "\0correlation_value";
+const correlationMarkerAlias = "\0correlation_match";
+const correlationRowNumberAlias = "\0correlation_row_number";
+const correlationCountAlias = "\0correlation_count";
+const correlationNonNullCountAlias = "\0correlation_non_null_count";
+const correlationDecisionCountAlias = "\0correlation_decision_count";
+const correlationTruthCountAlias = "\0correlation_truth_count";
+function decorrelateBlock(block, nextAlias) {
     const scope = new Set([block.base.alias, ...block.joins.map((join) => join.alias)]);
-    const nextAlias = correlationAliasFactory(scope);
     const rewritten = [];
     for (const predicate of block.predicates) {
         const replacement = decorrelatePredicate(block, predicate, scope, nextAlias);
@@ -382,57 +509,93 @@ function decorrelateBlock(block) {
             continue;
         rewritten.push(replacement ?? predicate);
     }
-    block.predicates = rewritten;
+    block.predicates = rewritten.map((predicate) => ({
+        ...predicate,
+        left: rewriteCorrelatedExpression(block, predicate.left, scope, nextAlias),
+        right: rewriteCorrelatedExpression(block, predicate.right, scope, nextAlias),
+    }));
     const grouped = block.groupBy.length > 0 || block.select.some((item) => containsAggregateCall(item.expression));
     for (const item of block.select) {
         if (!expressionHasCorrelatedSubquery(item.expression))
             continue;
         if (grouped) {
-            throw new TypeError("Correlated select-list subqueries are not supported with grouping or aggregates");
+            const groupedExpressions = new Set(block.groupBy.map((group) => JSON.stringify(group)));
+            const outerReferences = correlatedOuterReferences(item.expression);
+            if (containsAggregateCall(item.expression) ||
+                outerReferences.some((reference) => !groupedExpressions.has(JSON.stringify({ kind: "column", reference })))) {
+                throw new TypeError("A grouped correlated select-list subquery must reference only GROUP BY columns and cannot be nested inside an aggregate");
+            }
         }
-        item.expression = rewriteCorrelatedScalars(block, item.expression, scope, nextAlias);
+        item.expression = rewriteCorrelatedExpression(block, item.expression, scope, nextAlias);
+        // The decorrelated value is functionally determined by the outer grouping keys. Carrying it
+        // as one additional key makes that dependency explicit to both grouped executors.
+        if (grouped)
+            block.groupBy.push(structuredClone(item.expression));
     }
     assertNoCorrelation(block);
 }
 function containsAggregateCall(expression) {
-    if (expression.kind === "call" && aggregateCallNames.has(expression.name))
-        return true;
-    return childExpressions(expression).some(containsAggregateCall);
+    return hasAggregate(expression);
 }
 function expressionHasCorrelatedSubquery(expression) {
-    if (expression.kind === "subquery")
+    if (expression.kind === "subquery" || expression.kind === "exists") {
         return blockReferencesOutside(expression.block);
-    if (expression.kind === "exists")
-        return false;
+    }
     return childExpressions(expression).some(expressionHasCorrelatedSubquery);
 }
-/** Replaces correlated scalar subqueries inside one select expression with decorrelated joins. */
-function rewriteCorrelatedScalars(block, expression, scope, nextAlias) {
+/** Qualified outer references used by correlated scalar subqueries inside one expression. */
+function correlatedOuterReferences(expression) {
+    if ((expression.kind === "subquery" || expression.kind === "exists") &&
+        blockReferencesOutside(expression.block)) {
+        const references = [];
+        collectOutsideReferences(expression.block, new Set(), references);
+        return references;
+    }
+    return childExpressions(expression).flatMap(correlatedOuterReferences);
+}
+/** Replaces every supported correlated subquery leaf inside an arbitrary expression. */
+function rewriteCorrelatedExpression(block, expression, scope, nextAlias) {
+    if (expression.kind === "exists" && blockReferencesOutside(expression.block)) {
+        return decorrelateExistsExpression(block, expression, scope, nextAlias);
+    }
+    if (expression.kind === "condition") {
+        expression.left = rewriteCorrelatedExpression(block, expression.left, scope, nextAlias);
+        if (expression.right.kind === "subquery" && blockReferencesOutside(expression.right.block)) {
+            if (expression.operator === "IN" || expression.operator === "NOT IN") {
+                const value = decorrelateQuantifiedExpression(block, expression.left, expression.right.block, { comparison: "=", quantifier: "any" }, scope, nextAlias, "IN");
+                return expression.operator === "NOT IN" ? { kind: "not", operand: value } : value;
+            }
+            const quantified = parseQuantified(expression.operator);
+            if (quantified !== undefined) {
+                return decorrelateQuantifiedExpression(block, expression.left, expression.right.block, quantified, scope, nextAlias, "ANY/ALL");
+            }
+        }
+        expression.right = rewriteCorrelatedExpression(block, expression.right, scope, nextAlias);
+        return expression;
+    }
     if (expression.kind === "subquery" && blockReferencesOutside(expression.block)) {
         return decorrelateScalarSubquery(block, expression, scope, nextAlias);
     }
-    if (expression.kind === "binary" ||
-        expression.kind === "condition" ||
-        expression.kind === "logical") {
-        expression.left = rewriteCorrelatedScalars(block, expression.left, scope, nextAlias);
-        expression.right = rewriteCorrelatedScalars(block, expression.right, scope, nextAlias);
+    if (expression.kind === "binary" || expression.kind === "logical") {
+        expression.left = rewriteCorrelatedExpression(block, expression.left, scope, nextAlias);
+        expression.right = rewriteCorrelatedExpression(block, expression.right, scope, nextAlias);
         return expression;
     }
     if (expression.kind === "call") {
-        expression.arguments = expression.arguments.map((argument) => rewriteCorrelatedScalars(block, argument, scope, nextAlias));
+        expression.arguments = expression.arguments.map((argument) => rewriteCorrelatedExpression(block, argument, scope, nextAlias));
         return expression;
     }
     if (expression.kind === "not") {
-        expression.operand = rewriteCorrelatedScalars(block, expression.operand, scope, nextAlias);
+        expression.operand = rewriteCorrelatedExpression(block, expression.operand, scope, nextAlias);
         return expression;
     }
     if (expression.kind === "case") {
         for (const branch of expression.branches) {
-            branch.when = rewriteCorrelatedScalars(block, branch.when, scope, nextAlias);
-            branch.then = rewriteCorrelatedScalars(block, branch.then, scope, nextAlias);
+            branch.when = rewriteCorrelatedExpression(block, branch.when, scope, nextAlias);
+            branch.then = rewriteCorrelatedExpression(block, branch.then, scope, nextAlias);
         }
         if (expression.otherwise !== undefined) {
-            expression.otherwise = rewriteCorrelatedScalars(block, expression.otherwise, scope, nextAlias);
+            expression.otherwise = rewriteCorrelatedExpression(block, expression.otherwise, scope, nextAlias);
         }
         return expression;
     }
@@ -444,8 +607,10 @@ function correlationAliasFactory(scope) {
         for (;;) {
             sequence += 1;
             const alias = `corr_${String(sequence)}`;
-            if (!scope.has(alias))
+            if (!scope.has(alias)) {
+                scope.add(alias);
                 return alias;
+            }
         }
     };
 }
@@ -466,14 +631,24 @@ function decorrelatePredicate(block, predicate, scope, nextAlias) {
         if (!blockReferencesOutside(inner))
             return undefined;
         rejectGroupedInner(inner, "EXISTS");
-        guardWildcard(block);
+        if (!canExtractCorrelation(inner, scope, "EXISTS", true)) {
+            const replacement = decorrelateExistsWithProbes(block, { ...node, negated }, scope, nextAlias);
+            return {
+                left: replacement,
+                operator: "IS TRUE",
+                right: { kind: "literal", value: true },
+            };
+        }
         const keys = extractCorrelation(inner, scope, "EXISTS", true);
         const alias = nextAlias();
         const derived = {
             sql: "(correlated exists)",
             base: inner.base,
             joins: inner.joins,
-            select: keys.map((key, index) => ({ expression: key.inner, alias: `k${String(index)}` })),
+            select: keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
             predicates: inner.predicates,
             // Grouping by the keys deduplicates, so the join multiplies no outer row. The parser's
             // injected LIMIT 1 and any ORDER BY are dropped: existence ignores both.
@@ -488,7 +663,7 @@ function decorrelatePredicate(block, predicate, scope, nextAlias) {
         if (!negated)
             return "consumed";
         return {
-            left: { kind: "column", reference: `${alias}.k0` },
+            left: { kind: "column", reference: `${alias}.${correlationKeyAlias(0)}` },
             operator: "IS NULL",
             right: { kind: "literal", value: null },
         };
@@ -504,8 +679,11 @@ function decorrelatePredicate(block, predicate, scope, nextAlias) {
         if (inner.select.length !== 1 || item === undefined || item.expression.kind === "wildcard") {
             throw new TypeError("An IN subquery must select exactly one column");
         }
-        guardWildcard(block);
-        const keys = extractCorrelation(inner, scope, "IN");
+        const keys = extractCorrelation(inner, scope, "IN", true);
+        const general = keys.some((key) => key.operator !== "=");
+        if (predicate.operator === "NOT IN" && general) {
+            return decorrelateRangeNotIn(block, predicate.left, inner, item.expression, keys, nextAlias);
+        }
         if (predicate.operator === "NOT IN") {
             return decorrelateNotIn(block, predicate.left, inner, item.expression, keys, nextAlias);
         }
@@ -515,21 +693,113 @@ function decorrelatePredicate(block, predicate, scope, nextAlias) {
             base: inner.base,
             joins: inner.joins,
             select: [
-                ...keys.map((key, index) => ({ expression: key.inner, alias: `k${String(index)}` })),
-                { expression: item.expression, alias: "v" },
+                ...keys.map((key, index) => ({
+                    expression: key.inner,
+                    alias: correlationKeyAlias(index),
+                })),
+                { expression: item.expression, alias: correlationValueAlias },
             ],
             predicates: inner.predicates,
             groupBy: [...keys.map((key) => key.inner), item.expression],
             having: [],
             orderBy: [],
         };
+        if (general) {
+            const join = generalCorrelationJoin(alias, derived, [
+                ...keys.map((_, index) => ({
+                    kind: "column",
+                    reference: `${alias}.${correlationKeyAlias(index)}`,
+                })),
+                { kind: "column", reference: `${alias}.${correlationValueAlias}` },
+            ], [...keys.map((key) => key.outer), predicate.left], [...keys.map((key) => key.operator), "="]);
+            join.kind = "semi";
+            block.joins.push(join);
+            return "consumed";
+        }
         pushCorrelationJoin(block, alias, derived, keys, "inner");
         return {
             left: predicate.left,
             operator: "=",
-            right: { kind: "column", reference: `${alias}.v` },
+            right: { kind: "column", reference: `${alias}.${correlationValueAlias}` },
         };
     }
+    // outer comparison ANY / ALL (correlated subquery). At top-level WHERE, ANY is existence of a
+    // true comparison; ALL is absence of a false or unknown comparison. Empty sets therefore keep
+    // their standard false/true answers without materializing a per-row value list.
+    const quantified = parseQuantified(predicate.operator);
+    if (quantified !== undefined && predicate.right.kind === "subquery") {
+        const inner = predicate.right.block;
+        if (!blockReferencesOutside(inner))
+            return undefined;
+        rejectGroupedInner(inner, "ANY/ALL");
+        const item = inner.select[0];
+        if (inner.select.length !== 1 || item === undefined || item.expression.kind === "wildcard") {
+            throw new TypeError("An ANY/ALL subquery must select exactly one column");
+        }
+        const keys = extractCorrelation(inner, scope, "ANY/ALL", true);
+        const alias = nextAlias();
+        const derived = {
+            sql: "(correlated quantified comparison)",
+            base: inner.base,
+            joins: inner.joins,
+            select: [
+                ...keys.map((key, index) => ({
+                    expression: key.inner,
+                    alias: correlationKeyAlias(index),
+                })),
+                { expression: item.expression, alias: correlationValueAlias },
+            ],
+            predicates: inner.predicates,
+            groupBy: [...keys.map((key) => key.inner), item.expression],
+            having: [],
+            orderBy: [],
+        };
+        const join = generalCorrelationJoin(alias, derived, keys.map((_, index) => ({
+            kind: "column",
+            reference: `${alias}.${correlationKeyAlias(index)}`,
+        })), keys.map((key) => key.outer), keys.map((key) => key.operator));
+        const value = {
+            kind: "column",
+            reference: `${alias}.${correlationValueAlias}`,
+        };
+        const comparison = {
+            kind: "condition",
+            operator: quantified.comparison,
+            left: structuredClone(predicate.left),
+            right: value,
+        };
+        let quantifiedCondition = comparison;
+        if (quantified.quantifier === "all") {
+            quantifiedCondition = {
+                kind: "logical",
+                operator: "or",
+                left: {
+                    kind: "logical",
+                    operator: "or",
+                    left: {
+                        kind: "condition",
+                        operator: "IS NULL",
+                        left: structuredClone(predicate.left),
+                        right: { kind: "literal", value: null },
+                    },
+                    right: {
+                        kind: "condition",
+                        operator: "IS NULL",
+                        left: value,
+                        right: { kind: "literal", value: null },
+                    },
+                },
+                right: { kind: "not", operand: comparison },
+            };
+        }
+        join.on =
+            join.on === undefined
+                ? quantifiedCondition
+                : { kind: "logical", operator: "and", left: join.on, right: quantifiedCondition };
+        join.kind = quantified.quantifier === "all" ? "anti" : "semi";
+        block.joins.push(join);
+        return "consumed";
+    }
     // comparison against a correlated scalar aggregate
     if (!comparisonOperators.has(predicate.operator))
         return undefined;
@@ -566,9 +836,9 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
         select: [
             ...keys.map((key, index) => ({
                 expression: structuredClone(key.inner),
-                alias: `k${String(index)}`,
+                alias: correlationKeyAlias(index),
             })),
-            { expression: structuredClone(item), alias: "v" },
+            { expression: structuredClone(item), alias: correlationValueAlias },
         ],
         predicates: structuredClone(inner.predicates),
         groupBy: [...keys.map((key) => structuredClone(key.inner)), structuredClone(item)],
@@ -589,9 +859,9 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
         right: tuple([
             ...keys.map((_, index) => ({
                 kind: "column",
-                reference: `${valuesAlias}.k${String(index)}`,
+                reference: `${valuesAlias}.${correlationKeyAlias(index)}`,
             })),
-            { kind: "column", reference: `${valuesAlias}.v` },
+            { kind: "column", reference: `${valuesAlias}.${correlationValueAlias}` },
         ]),
     });
     const flagsAlias = nextAlias();
@@ -602,15 +872,15 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
         select: [
             ...keys.map((key, index) => ({
                 expression: structuredClone(key.inner),
-                alias: `k${String(index)}`,
+                alias: correlationKeyAlias(index),
             })),
             {
                 expression: { kind: "call", name: "COUNT", arguments: [{ kind: "wildcard" }] },
-                alias: "n",
+                alias: correlationCountAlias,
             },
             {
                 expression: { kind: "call", name: "COUNT", arguments: [structuredClone(item)] },
-                alias: "nn",
+                alias: correlationNonNullCountAlias,
             },
         ],
         predicates: structuredClone(inner.predicates),
@@ -619,8 +889,14 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
         orderBy: [],
     };
     pushCorrelationJoin(block, flagsAlias, flags, keys, "left");
-    const total = { kind: "column", reference: `${flagsAlias}.n` };
-    const nonNull = { kind: "column", reference: `${flagsAlias}.nn` };
+    const total = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationCountAlias}`,
+    };
+    const nonNull = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationNonNullCountAlias}`,
+    };
     const safe = {
         kind: "logical",
         operator: "or",
@@ -648,6 +924,265 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
         right: { kind: "literal", value: true },
     };
 }
+/**
+ * Range-correlated NOT IN uses a general anti-join for exact matches, then joins back one flag row
+ * per distinct outer probe tuple. The counts preserve empty-set and NULL poisoning semantics.
+ */
+function decorrelateRangeNotIn(block, probe, inner, item, keys, nextAlias) {
+    const valuesAlias = nextAlias();
+    const values = {
+        sql: "(range-correlated not in values)",
+        base: structuredClone(inner.base),
+        joins: structuredClone(inner.joins),
+        select: [
+            ...keys.map((key, index) => ({
+                expression: structuredClone(key.inner),
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: structuredClone(item), alias: correlationValueAlias },
+        ],
+        predicates: structuredClone(inner.predicates),
+        groupBy: [...keys.map((key) => structuredClone(key.inner)), structuredClone(item)],
+        having: [],
+        orderBy: [],
+    };
+    const exactMatch = generalCorrelationJoin(valuesAlias, values, [
+        ...keys.map((_, index) => ({
+            kind: "column",
+            reference: `${valuesAlias}.${correlationKeyAlias(index)}`,
+        })),
+        { kind: "column", reference: `${valuesAlias}.${correlationValueAlias}` },
+    ], [...keys.map((key) => structuredClone(key.outer)), structuredClone(probe)], [...keys.map((key) => key.operator), "="]);
+    exactMatch.kind = "anti";
+    block.joins.push(exactMatch);
+    const probes = outerProbeBlock(block, keys);
+    const probesAlias = nextAlias();
+    const innerRowsAlias = nextAlias();
+    const innerRows = {
+        sql: "(range-correlated not in rows)",
+        base: inner.base,
+        joins: inner.joins,
+        select: [
+            ...keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: item, alias: correlationValueAlias },
+        ],
+        predicates: inner.predicates,
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    const probeReferences = keys.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    const flags = {
+        sql: "(range-correlated not in flags)",
+        base: { table: probesAlias, alias: probesAlias, derived: probes },
+        joins: [
+            generalCorrelationJoin(innerRowsAlias, innerRows, keys.map((_, index) => ({
+                kind: "column",
+                reference: `${innerRowsAlias}.${correlationKeyAlias(index)}`,
+            })), probeReferences, keys.map(({ operator }) => operator)),
+        ],
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            {
+                expression: { kind: "call", name: "COUNT", arguments: [{ kind: "wildcard" }] },
+                alias: correlationCountAlias,
+            },
+            {
+                expression: {
+                    kind: "call",
+                    name: "COUNT",
+                    arguments: [{ kind: "column", reference: `${innerRowsAlias}.${correlationValueAlias}` }],
+                },
+                alias: correlationNonNullCountAlias,
+            },
+        ],
+        predicates: [],
+        groupBy: probeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const flagsAlias = nextAlias();
+    pushCorrelationJoin(block, flagsAlias, flags, keys.map((key) => ({ ...key, operator: "=" })), "left");
+    const total = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationCountAlias}`,
+    };
+    const nonNull = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationNonNullCountAlias}`,
+    };
+    return {
+        left: {
+            kind: "logical",
+            operator: "or",
+            left: {
+                kind: "condition",
+                operator: "IS NULL",
+                left: total,
+                right: { kind: "literal", value: null },
+            },
+            right: {
+                kind: "logical",
+                operator: "and",
+                left: {
+                    kind: "condition",
+                    operator: "IS NOT NULL",
+                    left: structuredClone(probe),
+                    right: { kind: "literal", value: null },
+                },
+                right: { kind: "condition", operator: "=", left: total, right: nonNull },
+            },
+        },
+        operator: "IS TRUE",
+        right: { kind: "literal", value: true },
+    };
+}
+/**
+ * Produces the three-valued result of a correlated IN/ANY/ALL expression at any expression
+ * position. Distinct outer probe tuples join the correlated set once, and grouped counts retain
+ * the difference between true, false, unknown, and an empty set. Top-level WHERE predicates keep
+ * their cheaper semi/anti-join rewrites; this path exists for OR, NOT, CASE, and select items.
+ */
+function decorrelateQuantifiedExpression(block, probe, inner, quantified, scope, nextAlias, label) {
+    rejectGroupedInner(inner, label);
+    const item = inner.select[0];
+    if (inner.select.length !== 1 || item === undefined || item.expression.kind === "wildcard") {
+        throw new TypeError(label === "IN"
+            ? "An IN subquery must select exactly one column"
+            : "An ANY/ALL subquery must select exactly one column");
+    }
+    const keys = extractCorrelation(inner, scope, label, true);
+    const outerExpressions = [
+        ...keys.map((key) => structuredClone(key.outer)),
+        structuredClone(probe),
+    ];
+    const probes = outerProbeBlockForExpressions(block, outerExpressions);
+    const probesAlias = nextAlias();
+    const probeReferences = outerExpressions.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    const innerRowsAlias = nextAlias();
+    const innerRows = {
+        sql: `(nested correlated ${label.toLowerCase()} rows)`,
+        base: inner.base,
+        joins: inner.joins,
+        select: [
+            ...keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: item.expression, alias: correlationValueAlias },
+            { expression: { kind: "literal", value: 1 }, alias: correlationMarkerAlias },
+        ],
+        predicates: inner.predicates,
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    const setJoin = generalCorrelationJoin(innerRowsAlias, innerRows, keys.map((_, index) => ({
+        kind: "column",
+        reference: `${innerRowsAlias}.${correlationKeyAlias(index)}`,
+    })), probeReferences.slice(0, keys.length), keys.map(({ operator }) => operator));
+    setJoin.kind = "left";
+    const comparison = {
+        kind: "condition",
+        operator: quantified.comparison,
+        left: probeReferences[keys.length] ?? { kind: "literal", value: null },
+        right: { kind: "column", reference: `${innerRowsAlias}.${correlationValueAlias}` },
+    };
+    const decisiveComparison = quantified.quantifier === "any"
+        ? structuredClone(comparison)
+        : { kind: "not", operand: structuredClone(comparison) };
+    const truthMarker = {
+        kind: "case",
+        branches: [{ when: decisiveComparison, then: { kind: "literal", value: 1 } }],
+        otherwise: { kind: "literal", value: null },
+    };
+    const flags = {
+        sql: `(nested correlated ${label.toLowerCase()} flags)`,
+        base: { table: probesAlias, alias: probesAlias, derived: probes },
+        joins: [setJoin],
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            {
+                expression: {
+                    kind: "call",
+                    name: "COUNT",
+                    arguments: [{ kind: "column", reference: `${innerRowsAlias}.${correlationMarkerAlias}` }],
+                },
+                alias: correlationCountAlias,
+            },
+            {
+                expression: { kind: "call", name: "COUNT", arguments: [comparison] },
+                alias: correlationDecisionCountAlias,
+            },
+            {
+                expression: { kind: "call", name: "COUNT", arguments: [truthMarker] },
+                alias: correlationTruthCountAlias,
+            },
+        ],
+        predicates: [],
+        groupBy: probeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const flagsAlias = nextAlias();
+    pushNullSafeProbeJoin(block, flagsAlias, flags, outerExpressions);
+    const total = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationCountAlias}`,
+    };
+    const decisions = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationDecisionCountAlias}`,
+    };
+    const truths = {
+        kind: "column",
+        reference: `${flagsAlias}.${correlationTruthCountAlias}`,
+    };
+    const defaultValue = quantified.quantifier === "all";
+    return {
+        kind: "case",
+        branches: [
+            {
+                when: {
+                    kind: "condition",
+                    operator: ">",
+                    left: truths,
+                    right: { kind: "literal", value: 0 },
+                },
+                then: { kind: "literal", value: !defaultValue },
+            },
+            {
+                when: {
+                    kind: "condition",
+                    operator: "=",
+                    left: total,
+                    right: { kind: "literal", value: 0 },
+                },
+                then: { kind: "literal", value: defaultValue },
+            },
+            {
+                when: { kind: "condition", operator: "<", left: decisions, right: total },
+                then: { kind: "literal", value: null },
+            },
+        ],
+        otherwise: { kind: "literal", value: defaultValue },
+    };
+}
 /**
  * Rewrites one correlated scalar-aggregate subquery into a left join against the grouped
  * aggregate, returning the expression that replaces the subquery node (COUNT wraps in COALESCE
@@ -655,27 +1190,41 @@ function decorrelateNotIn(block, probe, inner, item, keys, nextAlias) {
  */
 function decorrelateScalarSubquery(block, subquery, scope, nextAlias) {
     const inner = subquery.block;
+    const passthrough = scalarPassthrough(inner);
+    if (passthrough !== undefined)
+        return passthrough;
     const item = inner.select[0];
-    const isAggregate = item?.expression.kind === "call" && aggregateCallNames.has(item.expression.name);
-    if (inner.select.length !== 1 || item === undefined || !isAggregate) {
-        throw new TypeError("A correlated scalar subquery must select exactly one aggregate expression");
-    }
-    if (inner.groupBy.length > 0 ||
+    if (inner.select.length !== 1 ||
+        item === undefined ||
+        !isAggregateCall(item.expression) ||
+        inner.groupBy.length > 0 ||
         inner.having.length > 0 ||
         inner.orderBy.length > 0 ||
-        inner.limit !== undefined) {
-        throw new TypeError("A correlated scalar subquery cannot use GROUP BY, HAVING, ORDER BY, or LIMIT");
+        inner.limit !== undefined ||
+        inner.offset !== undefined ||
+        !canExtractCorrelation(inner, scope, "scalar", true)) {
+        return decorrelateGeneralScalar(block, inner, scope, nextAlias);
+    }
+    const previewKeys = extractCorrelation(structuredClone(inner), scope, "scalar", true);
+    if (previewKeys.some((key) => key.operator !== "=") &&
+        (item.expression.arguments.length !== 1 || item.expression.aggregateOrderBy !== undefined)) {
+        return decorrelateGeneralScalar(block, inner, scope, nextAlias);
+    }
+    const keys = extractCorrelation(inner, scope, "scalar", true);
+    if (keys.some((key) => key.operator !== "=")) {
+        return decorrelateNonEqualityScalar(block, inner, item.expression, keys, nextAlias);
     }
-    guardWildcard(block);
-    const keys = extractCorrelation(inner, scope, "scalar");
     const alias = nextAlias();
     const derived = {
         sql: "(correlated scalar)",
         base: inner.base,
         joins: inner.joins,
         select: [
-            ...keys.map((key, index) => ({ expression: key.inner, alias: `k${String(index)}` })),
-            { expression: item.expression, alias: "v" },
+            ...keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: item.expression, alias: correlationValueAlias },
         ],
         predicates: inner.predicates,
         groupBy: keys.map((key) => key.inner),
@@ -683,18 +1232,730 @@ function decorrelateScalarSubquery(block, subquery, scope, nextAlias) {
         orderBy: [],
     };
     pushCorrelationJoin(block, alias, derived, keys, "left");
-    let value = { kind: "column", reference: `${alias}.v` };
-    if (item.expression.kind === "call" && item.expression.name === "COUNT") {
+    let value = {
+        kind: "column",
+        reference: `${alias}.${correlationValueAlias}`,
+    };
+    if (item.expression.name === "COUNT") {
         // COUNT over an empty group is 0, but the unmatched left-join side is NULL.
         value = { kind: "call", name: "COALESCE", arguments: [value, { kind: "literal", value: 0 }] };
     }
     return value;
 }
+/** A SELECT without a row source is already the scalar expression from its enclosing scope. */
+function scalarPassthrough(inner) {
+    const item = inner.select[0];
+    if (inner.base.table !== DUAL_TABLE ||
+        inner.base.derived !== undefined ||
+        inner.joins.length > 0 ||
+        inner.select.length !== 1 ||
+        item === undefined ||
+        inner.predicates.length > 0 ||
+        inner.groupBy.length > 0 ||
+        inner.having.length > 0 ||
+        inner.orderBy.length > 0 ||
+        inner.offset !== undefined ||
+        (inner.limit !== undefined && inner.limit < 1)) {
+        return undefined;
+    }
+    return structuredClone(item.expression);
+}
+/**
+ * Pulls a scalar expression through projection-only derived wrappers. The parser uses these
+ * wrappers to hide ORDER BY support columns, and Kysely's JSON helpers use one to turn an
+ * explicitly selected row into JSON. Row-affecting clauses remain on the deepest block, where
+ * the probe rewrite can apply them once per outer key.
+ */
+function scalarShape(inner) {
+    const item = inner.select[0];
+    if (inner.select.length !== 1 || item === undefined || item.expression.kind === "wildcard") {
+        throw new TypeError("A scalar subquery must select exactly one column");
+    }
+    let rows = inner;
+    let expression = structuredClone(item.expression);
+    for (;;) {
+        const derived = rows.base.derived;
+        if (derived === undefined ||
+            rows.joins.length > 0 ||
+            rows.predicates.length > 0 ||
+            rows.groupBy.length > 0 ||
+            rows.having.length > 0 ||
+            rows.orderBy.length > 0 ||
+            rows.limit !== undefined ||
+            rows.limitParameter !== undefined ||
+            rows.offset !== undefined ||
+            rows.offsetParameter !== undefined ||
+            rows.distinctWildcard === true) {
+            break;
+        }
+        expression = inlineDerivedProjection(expression, rows.base.alias, derived);
+        rows = derived;
+    }
+    return { rows, expression };
+}
+/** Replaces references to a derived row with the expressions that produced its named columns. */
+function inlineDerivedProjection(expression, alias, derived) {
+    const rewrite = (node) => {
+        if (node.kind === "column") {
+            const parts = node.reference.split(".");
+            if (parts.length === 2 && parts[0] !== alias)
+                return node;
+            const name = parts.length === 2 ? (parts[1] ?? "") : (parts[0] ?? "");
+            const matches = derived.select.filter((item) => item.alias === name);
+            if (matches.length === 1)
+                return structuredClone(matches[0]?.expression ?? node);
+            return node;
+        }
+        return mapChildExpressions(node, rewrite);
+    };
+    return rewrite(expression);
+}
+/** ORDER BY may name a hidden or visible select alias; recover its row-level expression. */
+function scalarOrderExpression(expression, rows) {
+    if (expression.kind !== "column" || expression.reference.includes(".")) {
+        return structuredClone(expression);
+    }
+    const matches = rows.select.filter((item) => item.alias === expression.reference);
+    return matches.length === 1
+        ? structuredClone(matches[0]?.expression ?? expression)
+        : structuredClone(expression);
+}
+/** The value a scalar aggregate expression produces for an empty correlated input. */
+function emptyScalarExpression(expression) {
+    if (isAggregateCall(expression)) {
+        return { kind: "literal", value: expression.name === "COUNT" ? 0 : null };
+    }
+    if (expression.kind === "column" || expression.kind === "wildcard") {
+        return { kind: "literal", value: null };
+    }
+    return mapChildExpressions(expression, emptyScalarExpression);
+}
+/**
+ * General correlated scalar rewrite. Distinct outer probe tuples join the inner rows once,
+ * ORDER BY/LIMIT rank within each probe, and one grouped result joins back by NULL-safe equality.
+ * Aggregate expressions retain their empty-input rules; ordinary scalar rows use the internal
+ * single-value aggregate, which raises the same cardinality error as an uncorrelated scalar.
+ */
+function decorrelateGeneralScalar(block, inner, scope, nextAlias) {
+    const shape = scalarShape(inner);
+    const rows = shape.rows;
+    if (rows.groupBy.length > 0 || rows.having.length > 0) {
+        throw new TypeError("A correlated scalar subquery cannot use GROUP BY or HAVING");
+    }
+    if (rows.limitWithTies === true && rows.orderBy.length === 0) {
+        throw new TypeError("A correlated scalar WITH TIES query requires ORDER BY");
+    }
+    const keys = extractCorrelation(rows, scope, "scalar", true);
+    const outerExpressions = keys.map((key) => structuredClone(key.outer));
+    const probes = outerProbeBlockForExpressions(block, outerExpressions);
+    const probesAlias = nextAlias();
+    const probeReferences = outerExpressions.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    const finalRowsAlias = nextAlias();
+    const projected = [];
+    const project = (expression, alias) => {
+        projected.push({ expression: structuredClone(expression), alias });
+        return { kind: "column", reference: `${finalRowsAlias}.${alias}` };
+    };
+    const orderInputs = rows.orderBy.map((order, index) => ({
+        reference: project(scalarOrderExpression(order.expression, rows), correlationOrderAlias(index)),
+        direction: order.direction,
+        ...(order.nulls === undefined ? {} : { nulls: order.nulls }),
+    }));
+    let inputSequence = 0;
+    const aggregateResult = (expression) => {
+        if (isAggregateCall(expression)) {
+            const arguments_ = expression.arguments.map((argument) => argument.kind === "wildcard"
+                ? structuredClone(argument)
+                : project(argument, correlationInputAlias(inputSequence++)));
+            const ownOrder = expression.aggregateOrderBy?.map((order) => ({
+                expression: project(order.expression, correlationInputAlias(inputSequence++)),
+                direction: order.direction,
+                ...(order.nulls === undefined ? {} : { nulls: order.nulls }),
+            }));
+            const inheritedOrder = expression.name === "JSON_ARRAYAGG" || expression.name === "STRING_AGG"
+                ? orderInputs.map(({ reference, direction, nulls }) => ({
+                    expression: structuredClone(reference),
+                    direction,
+                    ...(nulls === undefined ? {} : { nulls }),
+                }))
+                : undefined;
+            const { aggregateOrderBy: ignoredOrder, ...base } = expression;
+            void ignoredOrder;
+            const aggregateOrder = ownOrder !== undefined && ownOrder.length > 0
+                ? ownOrder
+                : inheritedOrder !== undefined && inheritedOrder.length > 0
+                    ? inheritedOrder
+                    : undefined;
+            const rewritten = {
+                ...base,
+                arguments: arguments_,
+                ...(aggregateOrder === undefined ? {} : { aggregateOrderBy: aggregateOrder }),
+            };
+            return rewritten;
+        }
+        if (expression.kind === "column" || expression.kind === "wildcard") {
+            throw new TypeError("A correlated scalar aggregate cannot select an ungrouped inner column");
+        }
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            throw new TypeError("A correlated scalar aggregate cannot contain another subquery");
+        }
+        return mapChildExpressions(expression, aggregateResult);
+    };
+    const grouped = hasAggregate(shape.expression);
+    const valueExpression = grouped
+        ? aggregateResult(shape.expression)
+        : {
+            kind: "call",
+            name: "MINNOW_SINGLE_VALUE",
+            arguments: [project(shape.expression, correlationValueAlias)],
+        };
+    const innerRowsAlias = nextAlias();
+    const rawRows = {
+        sql: "(correlated scalar input rows)",
+        base: rows.base,
+        joins: rows.joins,
+        select: [
+            ...keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
+            ...projected,
+        ],
+        predicates: rows.predicates,
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    const matched = {
+        sql: "(correlated scalar matched probes)",
+        base: { table: probesAlias, alias: probesAlias, derived: probes },
+        joins: [
+            generalCorrelationJoin(innerRowsAlias, rawRows, keys.map((_, index) => ({
+                kind: "column",
+                reference: `${innerRowsAlias}.${correlationKeyAlias(index)}`,
+            })), probeReferences, keys.map(({ operator }) => operator)),
+        ],
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            ...projected.map(({ alias }) => ({
+                expression: { kind: "column", reference: `${innerRowsAlias}.${alias}` },
+                alias,
+            })),
+        ],
+        predicates: [],
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    let finalRows = matched;
+    if (rows.limit !== undefined ||
+        rows.limitParameter !== undefined ||
+        rows.offset !== undefined ||
+        rows.offsetParameter !== undefined) {
+        const rankedAlias = nextAlias();
+        const rankedTable = nextAlias();
+        const ranked = {
+            table: rankedTable,
+            alias: rankedAlias,
+            windowed: {
+                block: matched,
+                windows: [
+                    {
+                        alias: correlationRowNumberAlias,
+                        name: rows.limitWithTies === true ? "RANK" : "ROW_NUMBER",
+                        partitionAliases: keys.map((_, index) => correlationKeyAlias(index)),
+                        orderAliases: rows.orderBy.map((order, index) => ({
+                            alias: correlationOrderAlias(index),
+                            direction: order.direction,
+                            ...(order.nulls === undefined ? {} : { nulls: order.nulls }),
+                        })),
+                    },
+                ],
+            },
+        };
+        const rowNumber = {
+            kind: "column",
+            reference: `${rankedAlias}.${correlationRowNumberAlias}`,
+        };
+        const offset = rows.offsetParameter === undefined
+            ? { kind: "literal", value: rows.offset ?? 0 }
+            : { kind: "parameter", index: rows.offsetParameter };
+        const predicates = [];
+        if ((rows.offset ?? 0) > 0 || rows.offsetParameter !== undefined) {
+            predicates.push({
+                left: rowNumber,
+                operator: ">",
+                right: offset,
+            });
+        }
+        if (rows.limit !== undefined || rows.limitParameter !== undefined) {
+            const limit = rows.limitParameter === undefined
+                ? { kind: "literal", value: rows.limit ?? 0 }
+                : { kind: "parameter", index: rows.limitParameter };
+            predicates.push({
+                left: structuredClone(rowNumber),
+                operator: "<=",
+                right: rows.offset === undefined && rows.offsetParameter === undefined
+                    ? limit
+                    : { kind: "binary", operator: "+", left: structuredClone(offset), right: limit },
+            });
+        }
+        finalRows = {
+            sql: "(correlated scalar limited rows)",
+            base: ranked,
+            joins: [],
+            select: [
+                ...keys.map((_, index) => ({
+                    expression: {
+                        kind: "column",
+                        reference: `${rankedAlias}.${correlationKeyAlias(index)}`,
+                    },
+                    alias: correlationKeyAlias(index),
+                })),
+                ...projected.map(({ alias }) => ({
+                    expression: { kind: "column", reference: `${rankedAlias}.${alias}` },
+                    alias,
+                })),
+            ],
+            predicates,
+            groupBy: [],
+            having: [],
+            orderBy: [],
+            ...(rows.limitParameter === undefined
+                ? {}
+                : { limitValidationParameters: [rows.limitParameter] }),
+            ...(rows.offsetParameter === undefined
+                ? {}
+                : { offsetValidationParameters: [rows.offsetParameter] }),
+        };
+    }
+    const finalProbeReferences = keys.map((_, index) => ({
+        kind: "column",
+        reference: `${finalRowsAlias}.${correlationKeyAlias(index)}`,
+    }));
+    const aggregate = {
+        sql: "(correlated scalar result)",
+        base: { table: finalRowsAlias, alias: finalRowsAlias, derived: finalRows },
+        joins: [],
+        select: [
+            ...finalProbeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: valueExpression, alias: correlationValueAlias },
+            { expression: { kind: "literal", value: 1 }, alias: correlationMarkerAlias },
+        ],
+        predicates: [],
+        groupBy: finalProbeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const resultAlias = nextAlias();
+    pushNullSafeProbeJoin(block, resultAlias, aggregate, outerExpressions);
+    const marker = {
+        kind: "column",
+        reference: `${resultAlias}.${correlationMarkerAlias}`,
+    };
+    return {
+        kind: "case",
+        branches: [
+            {
+                when: {
+                    kind: "condition",
+                    operator: "IS NULL",
+                    left: marker,
+                    right: { kind: "literal", value: null },
+                },
+                then: grouped
+                    ? emptyScalarExpression(structuredClone(shape.expression))
+                    : { kind: "literal", value: null },
+            },
+        ],
+        otherwise: {
+            kind: "column",
+            reference: `${resultAlias}.${correlationValueAlias}`,
+        },
+    };
+}
+/**
+ * Aggregates a range-correlated scalar subquery once per distinct outer probe tuple. The probe
+ * table prevents a general join from multiplying outer rows and lets the final join use equality
+ * keys even when the original correlation uses `<`, `>=`, or another comparison.
+ */
+function decorrelateNonEqualityScalar(block, inner, aggregate, keys, nextAlias) {
+    if (aggregate.aggregateOrderBy !== undefined) {
+        throw new TypeError("A range-correlated scalar aggregate cannot use aggregate ORDER BY");
+    }
+    const argument = aggregate.arguments[0];
+    if (aggregate.arguments.length !== 1 || argument === undefined) {
+        throw new TypeError("A correlated scalar aggregate must have exactly one argument");
+    }
+    const probes = outerProbeBlock(block, keys);
+    const probesAlias = nextAlias();
+    const innerRowsAlias = nextAlias();
+    const innerRows = {
+        sql: "(range-correlated scalar rows)",
+        base: inner.base,
+        joins: inner.joins,
+        select: [
+            ...keys.map((key, index) => ({
+                expression: key.inner,
+                alias: correlationKeyAlias(index),
+            })),
+            {
+                expression: argument.kind === "wildcard" ? { kind: "literal", value: 1 } : argument,
+                alias: correlationValueAlias,
+            },
+        ],
+        predicates: inner.predicates,
+        groupBy: [],
+        having: [],
+        orderBy: [],
+    };
+    const joinedAggregate = {
+        ...aggregate,
+        arguments: [{ kind: "column", reference: `${innerRowsAlias}.${correlationValueAlias}` }],
+    };
+    const probeReferences = keys.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    const aggregateBlock = {
+        sql: "(range-correlated scalar aggregate)",
+        base: { table: probesAlias, alias: probesAlias, derived: probes },
+        joins: [
+            generalCorrelationJoin(innerRowsAlias, innerRows, keys.map((_, index) => ({
+                kind: "column",
+                reference: `${innerRowsAlias}.${correlationKeyAlias(index)}`,
+            })), probeReferences, keys.map(({ operator }) => operator)),
+        ],
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: joinedAggregate, alias: correlationValueAlias },
+        ],
+        predicates: [],
+        groupBy: probeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const aggregateAlias = nextAlias();
+    pushCorrelationJoin(block, aggregateAlias, aggregateBlock, keys.map((key) => ({ ...key, operator: "=" })), "left");
+    let value = {
+        kind: "column",
+        reference: `${aggregateAlias}.${correlationValueAlias}`,
+    };
+    if (aggregate.name === "COUNT") {
+        value = { kind: "call", name: "COALESCE", arguments: [value, { kind: "literal", value: 0 }] };
+    }
+    return value;
+}
+/** Builds the hidden boolean flag used when correlated EXISTS is nested below OR/NOT/CASE. */
+function decorrelateExistsExpression(block, exists, scope, nextAlias) {
+    const inner = exists.block;
+    rejectGroupedInner(inner, "EXISTS");
+    if (!canExtractCorrelation(inner, scope, "EXISTS", true)) {
+        return decorrelateExistsWithProbes(block, exists, scope, nextAlias);
+    }
+    const keys = extractCorrelation(inner, scope, "EXISTS", true);
+    if (keys.every(({ operator }) => operator === "=")) {
+        const flagsAlias = nextAlias();
+        const flags = {
+            sql: "(nested correlated exists flags)",
+            base: inner.base,
+            joins: inner.joins,
+            select: [
+                ...keys.map((key, index) => ({
+                    expression: key.inner,
+                    alias: correlationKeyAlias(index),
+                })),
+                { expression: { kind: "literal", value: 1 }, alias: correlationMarkerAlias },
+            ],
+            predicates: inner.predicates,
+            // EXISTS only needs one flag per correlation tuple. This is the direct equality-key path
+            // used by auth scopes such as `all_access OR EXISTS (...)` and cannot multiply outer rows.
+            groupBy: keys.map((key) => key.inner),
+            having: [],
+            orderBy: [],
+        };
+        pushCorrelationJoin(block, flagsAlias, flags, keys, "left");
+        return {
+            kind: "condition",
+            operator: exists.negated ? "IS NULL" : "IS NOT NULL",
+            left: { kind: "column", reference: `${flagsAlias}.${correlationMarkerAlias}` },
+            right: { kind: "literal", value: null },
+        };
+    }
+    const probes = outerProbeBlock(block, keys);
+    const probesAlias = nextAlias();
+    const innerRowsAlias = nextAlias();
+    const innerRows = {
+        sql: "(nested correlated exists rows)",
+        base: inner.base,
+        joins: inner.joins,
+        select: keys.map((key, index) => ({
+            expression: key.inner,
+            alias: correlationKeyAlias(index),
+        })),
+        predicates: inner.predicates,
+        groupBy: keys.map((key) => key.inner),
+        having: [],
+        orderBy: [],
+    };
+    const probeReferences = keys.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    const flags = {
+        sql: "(nested correlated exists flags)",
+        base: { table: probesAlias, alias: probesAlias, derived: probes },
+        joins: [
+            generalCorrelationJoin(innerRowsAlias, innerRows, keys.map((_, index) => ({
+                kind: "column",
+                reference: `${innerRowsAlias}.${correlationKeyAlias(index)}`,
+            })), probeReferences, keys.map(({ operator }) => operator)),
+        ],
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: { kind: "literal", value: 1 }, alias: correlationMarkerAlias },
+        ],
+        predicates: [],
+        groupBy: probeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const flagsAlias = nextAlias();
+    pushCorrelationJoin(block, flagsAlias, flags, keys.map((key) => ({ ...key, operator: "=" })), "left");
+    return {
+        kind: "condition",
+        operator: exists.negated ? "IS NULL" : "IS NOT NULL",
+        left: { kind: "column", reference: `${flagsAlias}.${correlationMarkerAlias}` },
+        right: { kind: "literal", value: null },
+    };
+}
+/**
+ * Decorrelation fallback for an EXISTS whose outer values occur below another subquery or in a
+ * larger expression instead of as direct inner-column/outer-column predicates. Distinct outer
+ * probe tuples become an ordinary derived source of the EXISTS body, and every outer reference
+ * is rebound to that source. The whole nested tree can then use the normal recursive rewrites.
+ */
+function decorrelateExistsWithProbes(block, exists, scope, nextAlias) {
+    const inner = exists.block;
+    const outside = [];
+    collectOutsideReferences(inner, new Set(), outside);
+    const references = [...new Set(outside)];
+    if (references.length === 0) {
+        throw new TypeError("Correlated EXISTS subquery has no usable outer reference");
+    }
+    for (const reference of references) {
+        const parts = reference.split(".");
+        const alias = parts.length === 2 ? parts[0] : undefined;
+        if (alias === undefined || !scope.has(alias)) {
+            throw new TypeError(`Correlated EXISTS references an unavailable outer source: ${reference}`);
+        }
+    }
+    const outerExpressions = references.map((reference) => ({
+        kind: "column",
+        reference,
+    }));
+    const probes = outerProbeBlockForExpressions(block, outerExpressions);
+    const probesAlias = nextAlias();
+    const probeReferences = references.map((_, index) => ({
+        kind: "column",
+        reference: `${probesAlias}.${correlationProbeAlias(index)}`,
+    }));
+    replacePlanReferences(inner, new Map(references.map((reference, index) => [reference, probeReferences[index] ?? null])));
+    inner.joins.push({
+        table: probesAlias,
+        alias: probesAlias,
+        derived: probes,
+        kind: "inner",
+        left: { kind: "literal", value: null },
+        right: { kind: "literal", value: null },
+        on: {
+            kind: "condition",
+            operator: "=",
+            left: { kind: "literal", value: 1 },
+            right: { kind: "literal", value: 1 },
+        },
+    });
+    const flagsAlias = nextAlias();
+    const flags = {
+        sql: "(probe-lifted correlated exists flags)",
+        base: inner.base,
+        joins: inner.joins,
+        select: [
+            ...probeReferences.map((expression, index) => ({
+                expression,
+                alias: correlationKeyAlias(index),
+            })),
+            { expression: { kind: "literal", value: 1 }, alias: correlationMarkerAlias },
+        ],
+        predicates: inner.predicates,
+        groupBy: probeReferences,
+        having: [],
+        orderBy: [],
+    };
+    const flagKeys = outerExpressions.map((_, index) => ({
+        kind: "column",
+        reference: `${flagsAlias}.${correlationKeyAlias(index)}`,
+    }));
+    const probeConditions = outerExpressions.map((outer, index) => ({
+        kind: "condition",
+        operator: "IS NOT DISTINCT FROM",
+        left: outer,
+        right: flagKeys[index] ?? { kind: "literal", value: null },
+    }));
+    let probeJoin = probeConditions[0];
+    if (probeJoin === undefined)
+        throw new Error("Correlation probe join is missing its key");
+    for (const condition of probeConditions.slice(1)) {
+        probeJoin = {
+            kind: "logical",
+            operator: "and",
+            left: probeJoin,
+            right: condition,
+        };
+    }
+    block.joins.push({
+        table: flagsAlias,
+        alias: flagsAlias,
+        derived: flags,
+        kind: "left",
+        left: { kind: "literal", value: null },
+        right: { kind: "literal", value: null },
+        on: probeJoin,
+    });
+    return {
+        kind: "condition",
+        operator: exists.negated ? "IS NULL" : "IS NOT NULL",
+        left: { kind: "column", reference: `${flagsAlias}.${correlationMarkerAlias}` },
+        right: { kind: "literal", value: null },
+    };
+}
+/** Rebinds qualified references everywhere below one plan without touching the probe definition. */
+function replacePlanReferences(block, replacements) {
+    const rewrite = (expression) => {
+        if (expression.kind === "column") {
+            const replacement = replacements.get(expression.reference);
+            return replacement == null ? expression : structuredClone(replacement);
+        }
+        if (expression.kind === "subquery" || expression.kind === "exists") {
+            replacePlanReferences(expression.block, replacements);
+            return expression;
+        }
+        if (expression.kind === "window") {
+            expression.partitionBy = expression.partitionBy.map(rewrite);
+            for (const order of expression.orderBy)
+                order.expression = rewrite(order.expression);
+            if (expression.argument !== undefined)
+                expression.argument = rewrite(expression.argument);
+            return expression;
+        }
+        return mapChildExpressions(expression, rewrite);
+    };
+    mapBlockExpressions(block, rewrite);
+    forEachNestedBlock(block, (nested) => replacePlanReferences(nested, replacements));
+}
+/** Distinct outer key tuples, preserving the FROM joins needed by every referenced source. */
+function outerProbeBlock(block, keys) {
+    return outerProbeBlockForExpressions(block, keys.map((key) => key.outer));
+}
+function outerProbeBlockForExpressions(block, outerExpressions) {
+    const sources = [block.base, ...block.joins];
+    const sourceIndexes = outerExpressions.flatMap((expression) => {
+        const aliases = [...expressionAliases(expression)];
+        // An unqualified expression can resolve against any visible source. Retaining the whole
+        // prefix is conservative and preserves SQL name resolution without a catalog dependency.
+        if (aliases.length === 0)
+            return [sources.length - 1];
+        return aliases.map((alias) => {
+            const index = sources.findIndex((source) => source.alias === alias);
+            if (index < 0)
+                throw new TypeError(`Cannot resolve correlated outer source: ${alias}`);
+            return index;
+        });
+    });
+    const lastSource = Math.max(...sourceIndexes);
+    const expressions = outerExpressions.map((expression) => structuredClone(expression));
+    return {
+        sql: "(correlation probes)",
+        base: structuredClone(block.base),
+        joins: structuredClone(block.joins.slice(0, lastSource)),
+        select: expressions.map((expression, index) => ({
+            expression,
+            alias: correlationProbeAlias(index),
+        })),
+        predicates: [],
+        groupBy: expressions,
+        having: [],
+        orderBy: [],
+    };
+}
+/** Joins one row per outer probe tuple back with NULL-safe equality. */
+function pushNullSafeProbeJoin(block, alias, derived, outerExpressions) {
+    const conditions = outerExpressions.map((outer, index) => ({
+        kind: "condition",
+        operator: "IS NOT DISTINCT FROM",
+        left: structuredClone(outer),
+        right: { kind: "column", reference: `${alias}.${correlationKeyAlias(index)}` },
+    }));
+    let on = conditions[0];
+    if (on === undefined)
+        throw new Error("Correlation probe join is missing its key");
+    for (const condition of conditions.slice(1)) {
+        on = { kind: "logical", operator: "and", left: on, right: condition };
+    }
+    block.joins.push({
+        table: alias,
+        alias,
+        derived,
+        kind: "left",
+        left: { kind: "literal", value: null },
+        right: { kind: "literal", value: null },
+        on,
+    });
+}
+/** A general ON join carrying one comparison for each corresponding expression pair. */
+function generalCorrelationJoin(alias, derived, inner, outer, operators) {
+    let on;
+    inner.forEach((left, index) => {
+        const right = outer[index];
+        const operator = operators[index];
+        if (right === undefined || operator === undefined)
+            return;
+        const comparison = { kind: "condition", operator, left, right };
+        on =
+            on === undefined
+                ? comparison
+                : { kind: "logical", operator: "and", left: on, right: comparison };
+    });
+    return {
+        table: alias,
+        alias,
+        derived,
+        kind: "inner",
+        left: { kind: "literal", value: null },
+        right: { kind: "literal", value: null },
+        ...(on === undefined ? {} : { on }),
+    };
+}
 function pushCorrelationJoin(block, alias, derived, keys, kind) {
     const source = { table: alias, alias, derived };
     const keyReference = (index) => ({
         kind: "column",
-        reference: `${alias}.k${String(index)}`,
+        reference: `${alias}.${correlationKeyAlias(index)}`,
     });
     const first = keys[0];
     if (keys.length === 1 && first?.operator === "=") {
@@ -766,13 +2027,26 @@ function extractCorrelation(inner, outerScope, label, comparisons = false) {
     const leftover = [];
     collectOutsideReferences(inner, new Set(), leftover);
     if (leftover.length > 0) {
-        throw new TypeError(`Correlated ${label} subqueries support only equality conditions between one inner and one outer qualified column (unsupported reference: ${leftover[0] ?? ""})`);
+        const supported = comparisons ? "comparison" : "equality";
+        throw new TypeError(`Correlated ${label} subqueries support only ${supported} conditions between one inner and one outer qualified column (unsupported reference: ${leftover[0] ?? ""})`);
     }
     if (keys.length === 0) {
         throw new TypeError(`Correlated ${label} subquery has no usable correlation condition`);
     }
     return keys;
 }
+/** Whether the fast correlation-key path can consume every outside reference in this block. */
+function canExtractCorrelation(inner, outerScope, label, comparisons) {
+    try {
+        extractCorrelation(structuredClone(inner), outerScope, label, comparisons);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return false;
+        throw error;
+    }
+}
 function correlationComparison(predicate, innerScope, outerScope, comparisons) {
     if (predicate.operator !== "=" &&
         (!comparisons || !comparisonOperators.has(predicate.operator))) {
@@ -822,11 +2096,6 @@ function rejectGroupedInner(inner, label) {
         throw new TypeError(`Correlated ${label} subqueries cannot use GROUP BY or HAVING`);
     }
 }
-function guardWildcard(block) {
-    if (block.select.some((item) => item.expression.kind === "wildcard")) {
-        throw new TypeError("Correlated subqueries cannot be combined with SELECT *");
-    }
-}
 function assertNoCorrelation(block) {
     const visit = (expression) => {
         if (expression.kind === "subquery" || expression.kind === "exists") {
@@ -1233,8 +2502,10 @@ function referencedOutputAliases(block, source, singleSource) {
             if (expression.otherwise !== undefined)
                 visit(expression.otherwise);
         }
-        else if (expression.kind === "call")
+        else if (expression.kind === "call") {
             expression.arguments.forEach(visit);
+            expression.aggregateOrderBy?.forEach((order) => visit(order.expression));
+        }
         else if (expression.kind === "list")
             expression.items.forEach(visit);
         else if (expression.kind === "fts") {
@@ -1263,6 +2534,8 @@ function referencedOutputAliases(block, source, singleSource) {
     for (const join of block.joins) {
         visit(join.left);
         visit(join.right);
+        if (join.on !== undefined)
+            visit(join.on);
     }
     for (const order of block.orderBy) {
         // An ORDER BY reference may name an output alias of the outer block rather than a source