@quereus/quereus 3.1.2 → 3.2.1

package/dist/src/planner/rules/parallel/rule-async-gather-zip-by-key.js

@@ -0,0 +1,545 @@
+/**
+ * Rule: Async Gather ZIP BY KEY
+ *
+ * Recognizes a `Project` over a chain of binary full-outer `JoinNode`s that
+ * all equate the **same** key column set across every participating relation,
+ * and folds the whole shape into a single N-ary
+ * `AsyncGatherNode({ kind: 'zipByKey', branchKeyAttrs, outputKeyAttrs })`.
+ *
+ * Generalizes `rule-async-gather-union-all` from the `unionAll` combinator to
+ * `zipByKey`. The recognized SQL is the natural spelling of an N-way
+ * full-outer merge on a shared key:
+ *
+ *   select coalesce(a.k, b.k, c.k) as k, a.av, b.bv, c.cv
+ *     from a full outer join b on a.k = b.k
+ *            full outer join c on a.k = c.k
+ *
+ * which the builder produces as:
+ *
+ *   Project[ coalesce(a.k,b.k,c.k) as k, a.av, b.bv, c.cv ]
+ *     Join(full, on a.k = c.k)
+ *       Join(full, on a.k = b.k)
+ *         <a>  <b>
+ *       <c>
+ *
+ * The binary full-outer chain is O(N²) null-padding and infers worse FDs than
+ * the symmetric N-ary merge; the `zipByKey` gather drives the N branches
+ * concurrently and hash-merges them by key. (Binary FULL JOIN has no runtime
+ * lowering at all — this rewrite is the only execution path for it.)
+ *
+ * ## Recognized shape
+ *
+ *   1. A `ProjectNode` whose `source` is a `JoinNode(joinType='full')`.
+ *   2. The full-join chain flattens (any nesting) into ≥ `minBranches` leaf
+ *      branches. Each join's `ON` condition is a pure conjunction of
+ *      column-ref equalities (no residual / non-equi predicate — those block).
+ *      (`USING`/`NATURAL` full joins carry no synthesized `ON` condition, so the
+ *      chain walk declines them — out of scope; see *Out of scope* below.)
+ *   3. Those equalities partition the branches' key columns into K equivalence
+ *      classes ("key positions"), and **every branch contributes exactly one
+ *      column to every class** (the shared-key precondition). A branch missing
+ *      from any class would be a cross-product, not a zip — block.
+ *   4. The projection list must express, in **any order**:
+ *        - K merged keys, each a `coalesce(...)` whose argument set is exactly
+ *          one key class's per-branch key attrs; and
+ *        - the forwarded non-key column references it selects (a subset is fine),
+ *      plus arbitrary additional pure scalar expressions over those outputs
+ *      (e.g. `coalesce(a.k, b.k) * 10`). The only hard constraint: a branch *key*
+ *      column may appear **only** inside a recognizing full-group `coalesce` — a
+ *      bare/partial reference to it (e.g. `select a.k …`) blocks, because the
+ *      per-branch key is consumed into the single merged key and is unavailable
+ *      above the gather.
+ *
+ *   When the projection happens to be exactly the emitter's canonical order
+ *   (`[K coalesce calls][branch0 non-key][branch1 non-key]…`), the gather
+ *   replaces the `Project` outright (fast path). Otherwise the gather is built
+ *   in canonical layout and wrapped in a thin reordering `Project` that
+ *   reproduces the user's list (rewriting each full-group `coalesce` to a
+ *   reference to the gather's merged-key output).
+ *
+ * ## Gates (mirror `rule-async-gather-union-all`)
+ *
+ *   - **Concurrency safety.** Every branch must declare
+ *     `physical.concurrencySafe === true`.
+ *   - **Uncorrelated branches.** No branch may reference attributes outside its
+ *     own subtree (lateral dependency) — the parallel driver forks independent
+ *     contexts. `isCorrelatedSubquery` on each branch must be false.
+ *   - **Latency win.** The slowest branch's `physical.expectedLatencyMs` must
+ *     meet `tuning.parallel.gatherThresholdMs`. This is 0 on memory-vtab /
+ *     in-process leaves, so the rule is inert by design on local-only plans
+ *     (the golden-plan no-rewrite invariant).
+ *   - **Key collation agreement.** Every key column at a given key position must
+ *     declare the *same* collation across all branches (binary or not). The
+ *     runtime comparator derives from branch 0 only, so a disagreement would
+ *     compare keys under the wrong collation. Non-binary collations are allowed:
+ *     the emitter composes the merged key deterministically from the
+ *     lowest-indexed present branch (`composeMergedKeyCells`), matching
+ *     `coalesce`'s left-to-right pick even when collation-equal keys are
+ *     byte-distinct (e.g. NOCASE merging `'A'`/`'a'`). This mirrors the
+ *     *agreement* invariant `AsyncGatherNode.validateZipByKey` enforces (which
+ *     throws on a true mismatch); checking it here declines gracefully instead.
+ *
+ * ## Attribute provenance (Option A — per-branch refs + minted output keys)
+ *
+ *   - `branchKeyAttrs[b]` — branch b's K key attr ids, in key order (distinct
+ *     per branch; each branch originates its own key id — provenance-clean).
+ *   - `outputKeyAttrs` — the K ids the `Project` minted for its `coalesce`
+ *     outputs (computed expressions → fresh ids, disjoint from all child ids).
+ *     The gather *mints* these, so `preserveAttributeIds[0..K-1] ===
+ *     outputKeyAttrs` and downstream references to the coalesced key resolve.
+ *   - `preserveAttributeIds` — the `Project`'s full output attribute list,
+ *     which (because we matched the canonical order) is exactly
+ *     `[minted keys] ++ [each branch's non-key attrs]`.
+ *
+ * ## Idempotence
+ *
+ * After the rewrite the matched node is an `AsyncGatherNode`, not a
+ * `ProjectNode`, so a second firing's matcher rejects immediately.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { PlanNode, isRelationalNode } from '../../nodes/plan-node.js';
+import { ProjectNode } from '../../nodes/project-node.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { BinaryOpNode } from '../../nodes/scalar.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { ScalarFunctionCallNode } from '../../nodes/function.js';
+import { AsyncGatherNode } from '../../nodes/async-gather-node.js';
+import { isCorrelatedSubquery } from '../../cache/correlation-detector.js';
+const log = createLogger('optimizer:rule:async-gather-zip-by-key');
+export function ruleAsyncGatherZipByKey(node, context) {
+    if (!(node instanceof ProjectNode))
+        return null;
+    if (!(node.source instanceof JoinNode) || node.source.joinType !== 'full')
+        return null;
+    const tuning = context.tuning.parallel;
+    if (tuning.minBranches < 2)
+        return null;
+    // (1) Flatten the full-outer chain into leaf branches + ON conditions.
+    const branches = [];
+    const conditions = [];
+    if (!collectFullJoinChain(node.source, branches, conditions))
+        return null;
+    if (branches.length < tuning.minBranches)
+        return null;
+    // (2) Each ON condition must be a pure AND-of-column-equalities. Collect the
+    // (attrId, attrId) pairs; a residual / non-equi conjunct blocks the rewrite.
+    const equalities = [];
+    for (const cond of conditions) {
+        if (!extractKeyEqualities(cond, equalities)) {
+            log('Aborting: join condition has a residual / non-equi predicate');
+            return null;
+        }
+    }
+    if (equalities.length === 0)
+        return null;
+    // (3) Partition the equated columns into key groups (equivalence classes),
+    // requiring every branch to contribute exactly one column to every group.
+    const branchOfAttr = buildBranchOfAttr(branches);
+    const groups = buildKeyGroups(equalities, branchOfAttr, branches.length);
+    if (!groups)
+        return null;
+    const k = groups.length;
+    // Per-branch key attr ids in key-group order — shared by the gates and the
+    // reordering path. Key-position order is layout-independent here; the
+    // canonical fast path derives its own coalesce-aligned order separately.
+    const branchKeyAttrs = branches.map((_branch, b) => groups.map(g => g.byBranch[b]));
+    // Gates (mirror rule-async-gather-union-all). These are projection-layout
+    // independent, so they run once before deciding canonical-vs-reordered.
+    for (const branch of branches) {
+        if (branch.physical.concurrencySafe !== true) {
+            log('Aborting: branch %s is not concurrencySafe', branch.id);
+            return null;
+        }
+        if (isCorrelatedSubquery(branch)) {
+            log('Aborting: branch %s is correlated (lateral dependency)', branch.id);
+            return null;
+        }
+    }
+    let maxLatency = 0;
+    for (const branch of branches) {
+        const l = branch.physical.expectedLatencyMs ?? 0;
+        if (l > maxLatency)
+            maxLatency = l;
+    }
+    if (maxLatency < tuning.gatherThresholdMs)
+        return null;
+    // Collation agreement per key position (the runtime comparator uses branch
+    // 0's collation only). validateZipByKey also enforces this and *throws* on a
+    // mismatch, but checking here lets the rule decline the rewrite gracefully —
+    // the chain simply stays a JoinNode (which then errors at emit as an
+    // unsupported FULL JOIN, the pre-rule baseline) rather than aborting planning.
+    //
+    // Non-binary collations are permitted as long as every branch agrees on the
+    // collation per key position. The emitter's merged key value is deterministic
+    // (lowest-indexed present branch supplies the key cells — see
+    // `composeMergedKeyCells`), matching `coalesce`'s left-to-right pick even when
+    // collation-equal keys are byte-distinct (e.g. NOCASE merging 'A'/'a'). The
+    // branch-0-derived comparator is correct because the collations agree.
+    if (!keyCollationsAgree(branches, branchKeyAttrs, k)) {
+        log('Aborting: key columns disagree on collation across branches');
+        return null;
+    }
+    // Each branch must be key-unique on its equated key columns. The zipByKey
+    // emitter assumes one row per key per branch (a duplicate silently
+    // overwrites); a true FULL JOIN on a non-unique key would multiply rows, so
+    // folding a non-unique branch would change results. Require the zip key to
+    // cover a declared unique key of every branch.
+    if (!branchesKeyUnique(branches, branchKeyAttrs)) {
+        log('Aborting: a branch is not provably unique on the equated key columns');
+        return null;
+    }
+    const concurrencyCap = Math.max(1, Math.min(tuning.concurrency, branches.length));
+    // (4a) Fast path: the projection is exactly the canonical zipByKey layout, so
+    // the gather replaces the Project outright (no reordering wrapper).
+    const canonical = matchCanonicalProjections(node, branches, groups, branchOfAttr);
+    if (canonical) {
+        log('Folding canonical full-outer zip chain of %d branches (K=%d) into AsyncGather(zipByKey) (cap=%d, maxLatency=%d ms)', branches.length, k, concurrencyCap, maxLatency);
+        return new AsyncGatherNode(node.scope, branches, { kind: 'zipByKey', branchKeyAttrs: canonical.branchKeyAttrs, outputKeyAttrs: canonical.outputKeyAttrs }, concurrencyCap, node.getAttributes());
+    }
+    // (4b) General path: arbitrary projection order / derived scalars over the
+    // merged-key and non-key outputs. Build the gather in its canonical layout
+    // and wrap it in a thin reordering Project reproducing the user's list.
+    const wrapped = buildReorderingGather(node, branches, groups, branchKeyAttrs, concurrencyCap);
+    if (!wrapped) {
+        log('Aborting: a projection references a branch key outside a full-group coalesce');
+        return null;
+    }
+    log('Folding reordered full-outer zip chain of %d branches (K=%d) into AsyncGather(zipByKey)+Project (cap=%d, maxLatency=%d ms)', branches.length, k, concurrencyCap, maxLatency);
+    return wrapped;
+}
+/**
+ * Build the canonical `zipByKey` gather and wrap it in a reordering `Project`
+ * that reproduces the user's projection list against the gather's canonical
+ * output. Each `coalesce(<exactly one full key group>)` sub-expression is
+ * rewritten to a bare reference to that group's merged-key output; non-key
+ * column refs and arbitrary pure scalar expressions over those outputs are
+ * carried through unchanged. Returns null if any branch key column is
+ * referenced outside a recognized full-group coalesce — such a reference is
+ * unavailable above the gather, which consumes each per-branch key into the
+ * single merged key.
+ */
+function buildReorderingGather(proj, branches, groups, branchKeyAttrs, concurrencyCap) {
+    // Mint the K merged-key output ids (key-group order) and build the gather in
+    // its natural [merged keys][branch non-key] layout. preserveAttributeIds is
+    // omitted so the node mints/forwards the canonical ids itself; the wrapper
+    // Project below restores the user's original output attribute ids.
+    const outputKeyAttrs = groups.map(() => PlanNode.nextAttrId());
+    const gather = new AsyncGatherNode(proj.scope, branches, { kind: 'zipByKey', branchKeyAttrs, outputKeyAttrs }, concurrencyCap);
+    const gatherAttrs = gather.getAttributes();
+    const keyAttrIds = new Set();
+    for (const g of groups)
+        for (const id of g.idSet)
+            keyAttrIds.add(id);
+    const outAttrs = proj.getAttributes();
+    const newProjections = [];
+    for (let i = 0; i < proj.projections.length; i++) {
+        const rewritten = rewriteMergedKeyRefs(proj.projections[i].node, groups, outputKeyAttrs, gatherAttrs, keyAttrIds);
+        if (!rewritten)
+            return null;
+        newProjections.push({
+            node: rewritten,
+            alias: proj.projections[i].alias,
+            attributeId: outAttrs[i].id,
+        });
+    }
+    return new ProjectNode(proj.scope, gather, newProjections, undefined, outAttrs, proj.preserveInputColumns);
+}
+/**
+ * Rewrite a projection scalar expression for evaluation above the gather:
+ *   - `coalesce(<exactly one full key group's branch keys>)` → a bare reference
+ *     to that group's merged-key output (`outputKeyAttrs[gi]`);
+ *   - bare non-key column refs are forwarded unchanged (the gather forwards
+ *     their ids); arbitrary pure scalar structure is rebuilt around the above;
+ *   - any other reference to a branch *key* column blocks (returns null) — the
+ *     per-branch key is consumed into the merged key and is unavailable above.
+ * Returns the rewritten expression, or null to decline the whole rewrite.
+ */
+function rewriteMergedKeyRefs(expr, groups, outputKeyAttrs, gatherAttrs, keyAttrIds) {
+    // coalesce over exactly one full key group → merged-key reference.
+    if (expr instanceof ScalarFunctionCallNode && expr.expression.name.toLowerCase() === 'coalesce') {
+        const gi = matchFullGroupCoalesce(expr, groups);
+        if (gi >= 0) {
+            const attr = gatherAttrs[gi];
+            return new ColumnReferenceNode(expr.scope, { type: 'column', name: attr.name }, attr.type, outputKeyAttrs[gi], gi);
+        }
+        // Not a full-group coalesce — fall through to generic child recursion.
+    }
+    if (expr instanceof ColumnReferenceNode) {
+        // A stray reference to a branch key column cannot survive the merge.
+        if (keyAttrIds.has(expr.attributeId))
+            return null;
+        return expr;
+    }
+    const children = expr.getChildren();
+    if (children.length === 0)
+        return expr;
+    const newChildren = [];
+    let changed = false;
+    for (const child of children) {
+        if (isRelationalNode(child)) {
+            // A relational child (e.g. a scalar subquery). Keep it only when it does
+            // not reference a consumed branch key column (conservative — such a
+            // reference would not resolve above the gather).
+            if (subtreeReferencesKey(child, keyAttrIds))
+                return null;
+            newChildren.push(child);
+            continue;
+        }
+        const rewritten = rewriteMergedKeyRefs(child, groups, outputKeyAttrs, gatherAttrs, keyAttrIds);
+        if (!rewritten)
+            return null;
+        if (rewritten !== child)
+            changed = true;
+        newChildren.push(rewritten);
+    }
+    return changed ? expr.withChildren(newChildren) : expr;
+}
+/**
+ * If `call`'s operands are exactly one key group's branch key columns (as bare
+ * column references), return that group's index; otherwise -1.
+ */
+function matchFullGroupCoalesce(call, groups) {
+    const argIds = [];
+    for (const operand of call.operands) {
+        if (!(operand instanceof ColumnReferenceNode))
+            return -1;
+        argIds.push(operand.attributeId);
+    }
+    return groups.findIndex(g => g.idSet.size === argIds.length && argIds.every(id => g.idSet.has(id)));
+}
+/**
+ * Walk a plan subtree (relational + scalar children) for any column reference
+ * to a key attr id the merge consumes.
+ */
+function subtreeReferencesKey(node, keyAttrIds) {
+    if (node instanceof ColumnReferenceNode && keyAttrIds.has(node.attributeId))
+        return true;
+    for (const child of node.getChildren()) {
+        if (subtreeReferencesKey(child, keyAttrIds))
+            return true;
+    }
+    return false;
+}
+/**
+ * Flatten a left-deep (or arbitrarily nested) chain of full-outer `JoinNode`s
+ * into leaf branches and ON conditions. Branch order mirrors the join's
+ * attribute concatenation (left subtree before right), so it lines up with the
+ * canonical projection layout. Returns false if a full join is missing its ON
+ * condition (cross-shaped full join — not recognizable).
+ */
+function collectFullJoinChain(node, branches, conditions) {
+    if (node instanceof JoinNode && node.joinType === 'full') {
+        if (!node.condition)
+            return false;
+        conditions.push(node.condition);
+        return collectFullJoinChain(node.left, branches, conditions)
+            && collectFullJoinChain(node.right, branches, conditions);
+    }
+    branches.push(node);
+    return true;
+}
+/**
+ * Walk a join condition collecting `=`-of-two-column-refs pairs as
+ * (attrId, attrId). Returns false if any conjunct is not an `AND` or a
+ * column=column equality (i.e. a residual predicate the zip can't absorb).
+ */
+function extractKeyEqualities(cond, out) {
+    const stack = [cond];
+    while (stack.length) {
+        const n = stack.pop();
+        if (!(n instanceof BinaryOpNode))
+            return false;
+        const op = n.expression.operator;
+        if (op === 'AND') {
+            stack.push(n.left, n.right);
+            continue;
+        }
+        if (op !== '=')
+            return false;
+        if (!(n.left instanceof ColumnReferenceNode) || !(n.right instanceof ColumnReferenceNode))
+            return false;
+        out.push([n.left.attributeId, n.right.attributeId]);
+    }
+    return true;
+}
+/** Map each branch attribute id to its branch index (for key-group membership). */
+function buildBranchOfAttr(branches) {
+    const map = new Map();
+    branches.forEach((branch, b) => {
+        for (const attr of branch.getAttributes())
+            map.set(attr.id, b);
+    });
+    return map;
+}
+/**
+ * Union-find the equality pairs into key groups, then validate that each group
+ * holds exactly one attr from every branch. Returns null (block) on any
+ * cross-branch shape that isn't a clean shared key.
+ */
+function buildKeyGroups(equalities, branchOfAttr, branchCount) {
+    const parent = new Map();
+    const find = (x) => {
+        let root = x;
+        while (parent.get(root) !== root)
+            root = parent.get(root);
+        let cur = x;
+        while (parent.get(cur) !== root) {
+            const next = parent.get(cur);
+            parent.set(cur, root);
+            cur = next;
+        }
+        return root;
+    };
+    const ensure = (x) => { if (!parent.has(x))
+        parent.set(x, x); };
+    for (const [a, b] of equalities) {
+        // Every equated column must belong to one of the flattened branches.
+        if (!branchOfAttr.has(a) || !branchOfAttr.has(b))
+            return null;
+        ensure(a);
+        ensure(b);
+        parent.set(find(a), find(b));
+    }
+    const byRoot = new Map();
+    for (const id of parent.keys()) {
+        const root = find(id);
+        let members = byRoot.get(root);
+        if (!members) {
+            members = [];
+            byRoot.set(root, members);
+        }
+        members.push(id);
+    }
+    const groups = [];
+    for (const members of byRoot.values()) {
+        const byBranch = new Array(branchCount).fill(-1);
+        for (const id of members) {
+            const b = branchOfAttr.get(id);
+            if (byBranch[b] !== -1)
+                return null; // two key columns from one branch in one group
+            byBranch[b] = id;
+        }
+        if (byBranch.some(v => v === -1))
+            return null; // a branch is missing from this key group
+        groups.push({ byBranch, idSet: new Set(members) });
+    }
+    return groups;
+}
+/**
+ * Fast-path detector: is the projection list *exactly* the canonical zipByKey
+ * layout
+ *   [ K coalesce(group) calls ] ++ [ branch0 non-key refs, branch1 non-key refs, … ]
+ * so the gather can replace the `Project` outright with no reordering wrapper?
+ * If so, derive `branchKeyAttrs` (ordered to match the coalesce order) and
+ * `outputKeyAttrs` (the coalesce output attr ids). Returns null on any mismatch —
+ * the caller then tries the general reordering path (`buildReorderingGather`).
+ */
+function matchCanonicalProjections(proj, branches, groups, branchOfAttr) {
+    const k = groups.length;
+    const projections = proj.projections;
+    const outAttrs = proj.getAttributes();
+    // Expected non-key tail: each branch's non-key attrs, in branch + column order.
+    const keyAttrIds = new Set();
+    for (const g of groups)
+        for (const id of g.idSet)
+            keyAttrIds.add(id);
+    const nonKeyTail = [];
+    for (const branch of branches) {
+        for (const attr of branch.getAttributes()) {
+            if (!keyAttrIds.has(attr.id))
+                nonKeyTail.push(attr.id);
+        }
+    }
+    if (projections.length !== k + nonKeyTail.length)
+        return null;
+    // First K projections: each a coalesce over exactly one (still-unused) group.
+    const orderedGroups = [];
+    const outputKeyAttrs = [];
+    const usedGroup = new Set();
+    for (let p = 0; p < k; p++) {
+        const expr = projections[p].node;
+        if (!(expr instanceof ScalarFunctionCallNode))
+            return null;
+        if (expr.expression.name.toLowerCase() !== 'coalesce')
+            return null;
+        const argIds = [];
+        for (const operand of expr.operands) {
+            if (!(operand instanceof ColumnReferenceNode))
+                return null;
+            argIds.push(operand.attributeId);
+        }
+        const group = groups.find(g => !usedGroup.has(g)
+            && g.idSet.size === argIds.length
+            && argIds.every(id => g.idSet.has(id)));
+        if (!group)
+            return null;
+        usedGroup.add(group);
+        orderedGroups.push(group);
+        outputKeyAttrs.push(outAttrs[p].id);
+    }
+    // Remaining projections: bare column refs matching the non-key tail exactly.
+    for (let i = 0; i < nonKeyTail.length; i++) {
+        const expr = projections[k + i].node;
+        if (!(expr instanceof ColumnReferenceNode))
+            return null;
+        if (expr.attributeId !== nonKeyTail[i])
+            return null;
+        // A non-key projection must forward its source id (ProjectNode does this
+        // for bare column refs); confirm it actually belongs to a branch.
+        if (!branchOfAttr.has(expr.attributeId))
+            return null;
+    }
+    const branchKeyAttrs = branches.map((_branch, b) => orderedGroups.map(g => g.byBranch[b]));
+    return { branchKeyAttrs, outputKeyAttrs };
+}
+/**
+ * Confirm every branch is provably unique on its equated key columns: some
+ * declared unique key of the branch must be covered by (a subset of) the zip's
+ * key-column indices. Branches without statistics-free uniqueness (no covering
+ * key) block the rewrite — the zip's one-row-per-key merge would otherwise
+ * differ from a true full join's per-key product.
+ */
+function branchesKeyUnique(branches, branchKeyAttrs) {
+    for (let b = 0; b < branches.length; b++) {
+        const attrs = branches[b].getAttributes();
+        const keyIndices = new Set();
+        for (const id of branchKeyAttrs[b]) {
+            const ix = attrs.findIndex((a) => a.id === id);
+            if (ix < 0)
+                return false;
+            keyIndices.add(ix);
+        }
+        const declaredKeys = branches[b].getType().keys;
+        const covered = declaredKeys.some(key => key.every(ref => keyIndices.has(ref.index)));
+        if (!covered)
+            return false;
+    }
+    return true;
+}
+/**
+ * Confirm every branch's key column at every key position declares the **same**
+ * collation as branch 0's (absent collation = binary). The runtime comparator
+ * derives solely from branch 0's collations, so a disagreement would silently
+ * compare (and merge) keys under the wrong collation. Agreement is sufficient:
+ * the emitter's merged key value is deterministic (lowest-indexed present branch
+ * wins — see `composeMergedKeyCells`), so any agreed collation, binary or not,
+ * yields a well-defined merged key that matches `coalesce`.
+ */
+function keyCollationsAgree(branches, branchKeyAttrs, k) {
+    const norm = (c) => (c && c.length > 0 ? c.toUpperCase() : 'BINARY');
+    const collationOf = (branch, attrId) => {
+        const attrs = branch.getAttributes();
+        const cols = branch.getType().columns;
+        const ix = attrs.findIndex((a) => a.id === attrId);
+        return ix >= 0 ? norm(cols[ix].type.collationName) : 'BINARY';
+    };
+    for (let pos = 0; pos < k; pos++) {
+        const base = collationOf(branches[0], branchKeyAttrs[0][pos]);
+        for (let b = 1; b < branches.length; b++) {
+            if (collationOf(branches[b], branchKeyAttrs[b][pos]) !== base)
+                return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=rule-async-gather-zip-by-key.js.map

package/dist/src/planner/rules/parallel/rule-async-gather-zip-by-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-async-gather-zip-by-key.js","sourceRoot":"","sources":["../../../../../src/planner/rules/parallel/rule-async-gather-zip-by-key.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/parallel/rule-eager-prefetch-probe.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rule: Eager Prefetch Probe
+ *
+ * Wraps the probe (`left`) input of a physical hash join in an
+ * `EagerPrefetchNode` when the build (`right`) side advertises high first-row
+ * latency, so the buffered pump can pipeline its probe-side reads with the
+ * parent emit's per-row work.
+ *
+ * Target shape: `BloomJoinNode` (physical, `PlanNodeType.HashJoin`). Per the
+ * node contract, **`left` is the probe (streamed) side** and `right` is the
+ * build (materialized) side — opposite of the textbook convention. The wrap
+ * target is therefore `left`.
+ *
+ * Cost gate: anchored on `node.right.physical.expectedLatencyMs`, the same
+ * field consumed by `rule-fanout-lookup-join` and `rule-async-gather-union-all`.
+ * That field is 0 on every in-process / memory-vtab leaf and non-zero only
+ * when a remote vtab plugin declares `expectedLatencyMs` at a leaf. As a
+ * consequence the rule is **inert by design on memory-vtab plans**, preserving
+ * the local-only golden-plan invariant the parallel rules already lock. We gate
+ * on the build side specifically: if `left` were the slow one the consumer
+ * above the join takes the latency hit regardless, so prefetching it doesn't
+ * change first-row time meaningfully.
+ *
+ * Skip predicates (the probe is already pump-driven or pre-materialized):
+ *   - `left` is an `EagerPrefetchNode` — already wrapped (idempotence).
+ *   - `left` is a `Cache` — pre-materialized; a prefetch over a cache buys
+ *     nothing and confuses plan output.
+ *   - `left` is an `AsyncGather` — already drives its branches concurrently;
+ *     inserting a prefetch buffer just adds latency-of-first-row.
+ *
+ * Concurrency gate: as of the eager-start change, the prefetch pump begins on
+ * `run()` (scheduler arg-assembly), so the probe (`left`) subtree iterates
+ * **concurrently** with the build's for-await over `right`. If either side sits
+ * over a non-reentrant (`'serial'`) cursor, concurrent iteration corrupts state.
+ * We therefore only wrap when **both** `node.left` and `node.right` advertise
+ * `physical.concurrencySafe === true` (mirroring `rule-async-gather-union-all`'s
+ * strict `=== true` check — wrap only when *proven* safe; `undefined` blocks).
+ *
+ * Idempotence: after the rewrite `left` is an `EagerPrefetchNode`, so a second
+ * firing hits the first skip predicate and no-ops.
+ */
+import type { OptContext } from '../../framework/context.js';
+import type { PlanNode } from '../../nodes/plan-node.js';
+export declare function ruleEagerPrefetchProbe(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-eager-prefetch-probe.d.ts.map

package/dist/src/planner/rules/parallel/rule-eager-prefetch-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-eager-prefetch-probe.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/parallel/rule-eager-prefetch-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAkC3F"}