@quereus/quereus 3.2.1 → 4.0.0

package/dist/src/planner/mutation/lens-enforcement.js.map

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

package/dist/src/planner/mutation/multi-source.d.ts

@@ -0,0 +1,568 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import type { Scope } from '../scopes/scope.js';
+import type { TableSchema } from '../../schema/table.js';
+import { type RelationalPlanNode, type TableDescriptor, type RelationalComponentRef } from '../nodes/plan-node.js';
+import type { ScalarType } from '../../common/datatype.js';
+import { TableReferenceNode } from '../nodes/reference.js';
+import { InternalRecursiveCTERefNode } from '../nodes/internal-recursive-cte-ref-node.js';
+import { JoinNode } from '../nodes/join-node.js';
+import type { BaseOp, MutableViewLike, MutationRequest } from './propagate.js';
+/**
+ * Multi-source view-mediated DML decomposition — the **key-preserving join**
+ * acceptance case of the view-mutation substrate (docs/view-updateability.md
+ * § Per-Operator Semantics — Inner Join, § Outer Joins, § Multi-Base-Table Mutations).
+ *
+ * Scope: a view body that is an **n-way (≥2) equi-join** of base tables — `inner`,
+ * `left`, or `full` — including composite-PK sides and **self-joins** (one base table
+ * under two or more distinct aliases) — written through with `update` / `delete` /
+ * `insert`. **LEFT** and **RIGHT** outer joins are admitted for the
+ * **statically-expressible** cases: preserved-side update passthrough,
+ * delete-to-the-preserved-side, and insert routing (both-side / preserved-only /
+ * presence-gated non-preserved member). RIGHT is the exact **mirror** of LEFT — the
+ * right operand of a `right` join is preserved, the left operand is null-extended — and
+ * the runtime now executes a RIGHT join (`outer-join-right-full-runtime`), so a
+ * RIGHT-join view is both readable and writable. **FULL** is admitted only to carry its
+ * precise conservative diagnostics (no preserved side, so all writes reject and the
+ * surfaces report all-`NO`; FULL write-through — a preserved anchor for a body that is
+ * null-extended per row — is a separable future concern). The one outer-join case that
+ * needs new runtime — an UPDATE of a **non-preserved** column (a per-row matched-update /
+ * null-extended-insert branch) — defers with `unsupported-outer-join-update`
+ * (`view-write-optional-member-transitions`). The body is
+ * **planned once**
+ * (`analyzeJoinView`); its `PhysicalProperties.updateLineage` (threaded by
+ * `view-mutation-physical-lineage`) routes each output column to its owning base
+ * table. Each per-base SET/value is still lowered to an AST `BaseOp` so the ordinary
+ * base-table builders are reused verbatim (the documented lower-risk path — the base
+ * builders stay untouched), but **row identification no longer round-trips through a
+ * re-planned AST body**: every affected view row's base-PK identities are captured
+ * ONCE up-front, built as plan nodes directly over the already-planned join body
+ * (`Project_{k<side>}(Filter_{idPred}(joinNode))` — the derived backward walk the
+ * docs name, § Round-Trip Laws and the Derived Backward Walk), materialized before
+ * any base op fires, and each base op reads its identifying values back from that
+ * `__vmupd_keys` set:
+ *
+ * ```sql
+ * -- view: select j1.id as id, j1.a as a, j2.c as c
+ * --       from tj1 j1 join tj2 j2 on j2.id = j1.t2id
+ * update jv set a = 5, c = 9 where id = 3
+ *   -- capture (plan nodes over the planned join body, materialized once):
+ *   --   __vmupd_keys = π_{j1.id as k0, j2.id as k1}( σ_{id = 3}( tj1 ⋈ tj2 ) )
+ *   ->  update tj1 set a = 5 where id in (select k0 from __vmupd_keys)
+ *       update tj2 set c = 9 where id in (select k1 from __vmupd_keys)
+ * ```
+ *
+ * The capture reconstructs the row-identifying predicate (each owning side's base PK)
+ * from the planned join body — exactly the predicate the optimizer already proves a
+ * key over — so a side whose own PK is hidden by the projection (`tj2.id` above) is
+ * still addressable, and a both-sides write is mutation-order-independent (the
+ * FK-parent op cannot rewrite a predicate column out from under the FK-child op).
+ * UPDATE RETURNING re-queries the same planned `joinNode` (post-mutation, restricted
+ * to the captured identities); DELETE RETURNING projects the planned body `root` (the
+ * `pre` OLD image). The body is planned once and reused — no second `buildSelectStmt`
+ * / `cloneFromClause` of it for identification or RETURNING.
+ *
+ * Multi-source **`insert`** is analysed here (`analyzeMultiSourceInsert`) but *built* by
+ * `building/view-mutation-builder.ts` (`buildMultiSourceInsert`), because it needs the
+ * plan-level shared-surrogate envelope rather than an AST `BaseOp`: the shared join key is
+ * not a view column, so it is sourced from the anchor key column's declared `default` once
+ * per row at the envelope and threaded into the active base inserts via the equivalence
+ * class (§ Mutation Context). For an outer join the **non-preserved** side is an *optional*
+ * member of the fan-out — dropped when its columns are absent (the preserved-only insert),
+ * presence-gated per row when supplied (the both-side insert).
+ *
+ * **Deferred, rejected here with a structured diagnostic:**
+ * - UPDATE of a non-preserved outer-join column — `unsupported-outer-join-update`.
+ * - INSERT of only non-preserved columns with no preserved anchor — `null-extended-create-conflict`.
+ * - cross / set-op / aggregate / window bodies — `unsupported-*`.
+ * - comma (implicit) joins, `select *` join bodies, and cross-side `set` value
+ *   references — each a precise diagnostic.
+ * - composite **shared-key insert** (the surrogate envelope threads a single-column
+ *   key) — `unsupported-decomposition-key`. (Composite-PK *identification* on the
+ *   update/delete capture path IS supported here; only the insert envelope's shared
+ *   key stays single-column.)
+ */
+/**
+ * The shared identity-capture CTE name for a multi-source (n-way inner-join) UPDATE /
+ * multi-side DELETE fan-out. Each affected view row's base-PK identities are
+ * materialized ONCE — *before* any base op fires — into `rctx.tableContexts` under a
+ * shared descriptor. *Every* per-side base op reads its identifying values back from
+ * this set via a correlated EXISTS (`exists (select 1 from __vmupd_keys k where
+ * k.k<side>_<j> = <side>.<pk<j>> …)`) instead of a live re-query of the join body, so
+ * the first op cannot empty the join — or rewrite a predicate column — out from under
+ * a later op's identifying subquery (a mutation-order-independent identity). The same
+ * capture backs the UPDATE RETURNING re-query (docs/view-updateability.md § Inner Join,
+ * § `returning`).
+ *
+ * The capture relation carries one column **per side per PK column**, named
+ * `k<sideIndex>_<pkColumnOrdinal>` ({@link keyColumnName}) — so a composite-PK side
+ * contributes `k<side>_0, k<side>_1, …`. This flattened per-side-per-column shape is
+ * what generalizes the substrate past the retired single-column `(k0, k1)` tuple.
+ */
+export declare const MS_UPDATE_KEYS_CTE = "__vmupd_keys";
+/**
+ * The capture column name for side `sideIndex`'s `j`-th PK column. A single-column-PK
+ * side yields just `k<side>_0`; a composite-PK side yields `k<side>_0, k<side>_1, …`.
+ */
+export declare function keyColumnName(sideIndex: number, j: number): string;
+/** One base-table side of the join. */
+interface JoinSide {
+    readonly table: TableReferenceNode;
+    readonly schema: TableSchema;
+    /** AST alias (lowercased) the body uses for this source, or the table name. */
+    readonly alias: string;
+    /**
+     * True when this side is **preserved** by the join shape — an inner-join side, or
+     * the preserved side of a LEFT/RIGHT outer join (the left of `left`, the right of
+     * `right`). A **non-preserved** side (`preserved: false`) is potentially
+     * null-extended: the right of a `left`, the left of a `right`, and *both* sides of
+     * a `full` outer join (§ Outer Joins). The per-op routing keys off this: an UPDATE
+     * defers a non-preserved-column write, a DELETE routes to preserved side(s), an
+     * INSERT treats a non-preserved side as an optional (presence-gated) member.
+     */
+    readonly preserved: boolean;
+    /**
+     * The enclosing outer join's ON predicate — the *guard* under which this
+     * non-preserved side's columns are real (the row is null-extended when the guard
+     * fails). Absent for a preserved side, and for an outer join expressed with USING
+     * (no AST `Expression` guard). Surfaced from the planned join shape for future
+     * per-row materialization; v1 routing does not consume it.
+     */
+    readonly guard?: AST.Expression;
+}
+/** One output column of the join view body, by backward lineage. */
+interface OutColumn {
+    /** Output (view) column name, lowercased. */
+    readonly name: string;
+    /** Output (view) column name in its original display spelling (for `returning *`). */
+    readonly displayName: string;
+    /** Index into `sides` of the owning base table (base-writable columns only). */
+    readonly sideIndex?: number;
+    /** Owning base column name (base-writable columns only). */
+    readonly baseColumn?: string;
+    /**
+     * True for a `base` lineage site — an identity/rename projection OR a
+     * non-identity invertible transform (`inverse` present). Writable on update: an
+     * `inverse` column lowers its assigned value through {@link inverse} (§ Scalar
+     * Invertibility). A `computed` / `null-extended` site is read-only (`false`).
+     */
+    readonly writable: boolean;
+    /**
+     * True when the owning site is an outer-join **non-preserved** (null-extended)
+     * base column. Distinguishes a deferred outer-join column (base lineage present,
+     * but the write needs per-row materialization — `unsupported-outer-join-update`)
+     * from a genuinely computed column (no base lineage — `no-inverse`). A
+     * null-extended base column is still **insertable** (the both-sides envelope
+     * supplies it), so it carries {@link sideIndex} / {@link baseColumn}.
+     */
+    readonly nullExtended: boolean;
+    /**
+     * Backward inverse closure for a non-identity invertible base site — maps a
+     * *written* (view-domain) value to the base column's value (e.g. `cv + 1` ⇒
+     * `w ↦ w - 1`). Absent for an identity/rename column. Insert through such a
+     * column is NOT supported (the shared-surrogate envelope writes raw values) —
+     * see {@link analyzeMultiSourceInsert}.
+     */
+    readonly inverse?: (written: AST.Expression) => AST.Expression;
+    /**
+     * Domain predicate (base terms) an `inverse` profile restricts to; conjoined
+     * into the row-identifying predicate on update (§ Scalar Invertibility). No
+     * shipped profile produces one yet (`x ± k` is unrestricted), so it is
+     * currently always absent.
+     */
+    readonly domain?: AST.Expression;
+    /**
+     * Set for an outer-join `existence` (`exists … as`) flag column. It maps to **no
+     * base column** ({@link sideIndex} / {@link baseColumn} stay undefined), so it is
+     * not a base-write target; instead a write to it is a per-row insert/delete of the
+     * named component (§ Existence columns). `existenceSide` is the resolved
+     * non-preserved side it reifies the match of — the side the flag-flip materializes
+     * (`true`) or removes (`false`). The write router keys off this presence.
+     */
+    readonly existenceComponent?: RelationalComponentRef;
+    /** The non-preserved side index the existence flag drives (present iff {@link existenceComponent}). */
+    readonly existenceSide?: number;
+    /**
+     * Set for an authored (`with inverse`) column — writable through the put
+     * expressions, one base assignment per put, each routed to its owning join side
+     * ({@link sideIndex} / {@link baseColumn} stay undefined: there is no single
+     * verbatim base column). `newRefIndex` maps a put's `new.<name>` references to
+     * output column indexes of this analysis's `outColumns`
+     * (docs/view-updateability.md § Authored inverses).
+     */
+    readonly authored?: {
+        readonly puts: ReadonlyArray<{
+            readonly sideIndex: number;
+            readonly baseColumn: string;
+            readonly expr: AST.Expression;
+        }>;
+        readonly newRefIndex: ReadonlyMap<string, number>;
+    };
+}
+export interface JoinViewAnalysis {
+    readonly sel: AST.SelectStmt;
+    /** The base-table sides (≥2), in AST source order; routing is keyed by index 0..n-1. */
+    readonly sides: readonly JoinSide[];
+    /** View column name (lowercased) -> its base-term replacement expression. */
+    readonly viewColToBaseRef: ReadonlyMap<string, AST.Expression>;
+    readonly outColumns: readonly OutColumn[];
+    /**
+     * The planned view body (the source of `updateLineage`). Reused by the DELETE
+     * RETURNING re-query (the OLD view image, projected `pre` over `root`) — so the
+     * body is planned **once** rather than re-expanded through the view name.
+     */
+    readonly root: RelationalPlanNode;
+    /**
+     * The raw `JoinNode` inside {@link root} (the ON-condition join, *before* the
+     * body's σ/projection). The capture's identifying relation and the UPDATE
+     * RETURNING re-query are built directly on top of it (Filter + Project plan
+     * nodes) instead of re-planning a cloned AST body — the derived backward walk
+     * the docs name (§ Round-Trip Laws and the Derived Backward Walk).
+     */
+    readonly joinNode: JoinNode;
+    /**
+     * The join's combined column scope (`ctx.outputScopes.get(joinNode)`), which
+     * resolves both alias-qualified (`j1.id`) and unqualified base columns — the
+     * exact scope `buildSelectStmt` used when planning the body. Reused to build the
+     * identifying predicate / PK projections / RETURNING columns as `ScalarPlanNode`s
+     * over {@link joinNode}, so resolution is byte-identical to the retired re-plan.
+     */
+    readonly joinScope: Scope;
+}
+/**
+ * True when the view body is a join (and so routes to this multi-source path
+ * rather than the single-source spine). Cheap AST peek — no plan built.
+ *
+ * A **compound (set-op) body** returns `false` even when its left-most leg's FROM is a
+ * join (`select … from a join b … union …`): a set-op body routes to the set-op write path
+ * (`set-op.ts`), never this multi-source join spine, whose capture/lineage walk reads only
+ * the leg's `JoinNode` and silently ignores the surrounding compound — mishandling it
+ * (`set-op-write-multisource-leg-reject`). Excluding it here lets such a body fall through to
+ * the single-source spine's clean `classifyViewBody` reject (the intent
+ * `propagate.ts` already documents). The set-op path itself detects a multi-source LEG by
+ * calling this same predicate on the **leg** SELECT (which carries no `compound`).
+ */
+export declare function isJoinBody(selectAst: AST.QueryExpr): boolean;
+/**
+ * Non-throwing AST shape check — the boolean shadow of {@link collectJoinSources}'s
+ * acceptance: `true` iff the body is a single explicit **n-way (≥2) equi-join** — `inner`,
+ * `left`, `right`, or `full` (RIGHT is the exact mirror of LEFT; FULL has no preserved
+ * side, so it self-conservatizes downstream; see {@link collectJoinSources}) with an ON
+ * (or USING) predicate over plain base tables (the
+ * exact multi-source shape `propagate()` decomposes), including **composite-PK sides** and
+ * **self-joins** (one base table under two or more distinct aliases). Every other
+ * multi-table body — cross / comma (implicit) / subquery- or function-source — returns
+ * `false`.
+ *
+ * Shared with the static updateability surfaces (`deriveViewInfo` /
+ * `deriveColumnInfo` in `func/builtins/schema.ts`): they gate on this so they
+ * agree with what a real mutation through the view accepts. An outer join is now
+ * **partially** writable (preserved-side update, delete-to-preserved, insert), so it is
+ * decomposable here; those surfaces read per-column `null-extended` lineage to report a
+ * non-preserved column non-updatable (the matching deferral). The throwing
+ * {@link collectJoinSources} stays the substrate's source of truth; this mirrors only its
+ * AST-level shape gate (it does not re-check DISTINCT/LIMIT/`select *`, which are deeper
+ * semantic rejects handled downstream — PK shape is no longer a reject now that composite
+ * keys are admitted).
+ */
+export declare function isDecomposableJoinBody(selectAst: AST.QueryExpr): boolean;
+/**
+ * True iff `selectAst` is a decomposable join body ({@link isDecomposableJoinBody}) whose
+ * joins are **all INNER**. The set-op join-leg compose
+ * (`set-op-write-multisource-leg-compose`) ships INNER join legs — the gate is purely
+ * `joinType`-based, so a non-equi (theta) INNER join is admitted identically to an equi-join.
+ * An OUTER (left/right/full) join leg's set-op write composition is deferred. The set-op
+ * recognizers gate on this so a body with an outer-join leg reports the conservative
+ * all-`NO` static surface AND rejects the dynamic write cleanly (never an internal error),
+ * matching exactly. A cross / no-ON join (not decomposable) likewise fails this and is
+ * deferred — agreeing with `analyzeJoinView`'s downstream reject.
+ */
+export declare function isInnerJoinBody(selectAst: AST.QueryExpr): boolean;
+/**
+ * Decompose a multi-source (n-way `inner`/`left`/`full` join) view mutation into
+ * an ordered `BaseOp[]`. Throws a structured diagnostic for any unsupported shape.
+ */
+export declare function propagateMultiSource(ctx: PlanningContext, view: MutableViewLike, req: MutationRequest): BaseOp[];
+/**
+ * One base side of a multi-source insert, fully resolved: the base columns it
+ * writes (shared key first, then the supplied view columns it owns) and, for
+ * each, the index into the materialized envelope row supplying the value.
+ */
+export interface MsInsertSide {
+    readonly table: TableReferenceNode;
+    readonly schema: TableSchema;
+    readonly targetColumns: readonly string[];
+    readonly envelopeIndices: readonly number[];
+    /**
+     * Envelope indices whose non-null presence gates this side's insert per row — a
+     * non-preserved (outer-join optional) member inserts only for rows that supply ≥1
+     * of its columns (§ Outer Joins — Inserts). Empty ⇒ unconditional (a preserved /
+     * inner side, always inserted). Reuses the decomposition fan-out's presence gate
+     * (`buildDecompositionMemberInsert`).
+     */
+    readonly presenceGateIndices: readonly number[];
+    /**
+     * Set when this side's shared-key (FK-child) column must be threaded conditionally:
+     * `keyTargetIndex` is its position in `targetColumns` (0 — the key is pushed first
+     * when `needsSharedKey`), and `groups` is an AND-of-(OR-within) list of envelope
+     * indices — one inner group per presence-gated FK-parent partner — that gates the
+     * key. When all referenced presence-gated partners are absent for a row, the key
+     * column projects null (the correct "no partner" marker), so the FK does not dangle
+     * (§ Outer Joins — Inserts). Absent ⇒ the key threads unconditionally (a
+     * parent/anchor side, or a key shared only among always-active sides).
+     */
+    readonly keyGate?: {
+        readonly keyTargetIndex: number;
+        readonly groups: readonly (readonly number[])[];
+    };
+    /**
+     * Per-side constant-FD insert-defaults lifted from the join body's σ (where-clause)
+     * equality constants (§ Inner Join — Inserts; the multi-source analog of the single-
+     * source § Selection rule). Each entry supplies an omitted σ-constrained base column its
+     * σ value, so the inserted row satisfies the view predicate and is visible through the
+     * view. Unlike the minted shared key these are NOT envelope-sourced — they are per-row
+     * **constants**, so they carry their literal node directly and ride the side's
+     * `ProjectNode` as a compiled constant (`buildExpression`), needing no envelope column.
+     * Because the projection rides the side (not the VALUES rows), this also supports a
+     * **SELECT-source** insert (a strict capability gain over the single-source path, which
+     * defers σ-defaulting for SELECT sources). Empty/absent ⇒ no σ-constrained columns this
+     * side. A σ over the side's shared join key is skipped (the EC thread owns that value).
+     */
+    readonly sigmaDefaults?: readonly {
+        readonly baseColumn: string;
+        readonly valueExpr: AST.Expression;
+    }[];
+}
+/**
+ * The plan-agnostic decomposition of a multi-source inner-join INSERT, consumed
+ * by `buildMultiSourceInsert`. The **envelope** is the per-row augmented source:
+ * its leading columns are the supplied view columns (`suppliedColumns`, in
+ * user-source order), optionally followed by a surrogate shared key sourced from
+ * the anchor key column's declared `default` (`keyDefault`). Each side reads its
+ * values back out of that one materialized envelope, so the default is evaluated
+ * exactly once per row and the value threads across both base inserts via the
+ * equivalence class (docs/view-updateability.md § Mutation Context).
+ */
+export interface MsInsertAnalysis {
+    readonly suppliedColumns: readonly {
+        readonly name: string;
+        readonly type: ScalarType;
+    }[];
+    /** Sides ordered FK-parent before FK-child (the FK-safe insert order). */
+    readonly orderedSides: readonly MsInsertSide[];
+    /**
+     * The anchor key column's declared `default`, evaluated once per produced row at
+     * the envelope (with `mutation_ordinal()` in scope) and threaded into every side's
+     * key column via the equivalence class. Set only when the shared key is **not**
+     * directly supplied; absent ⇒ a supplied view column threads the key.
+     */
+    readonly keyDefault?: AST.Expression;
+}
+/**
+ * Decompose an n-way key-preserving INSERT into the per-side base inserts plus the
+ * shared-surrogate envelope they fan out from. Throws a structured diagnostic for any
+ * unsupported shape (computed target column, a not-null base column with no value, a
+ * non-equi-join key, …). The shared key remains **single-column**: a side contributing a
+ * composite shared key to the join's equivalence class is rejected with
+ * `unsupported-decomposition-key` (the envelope threads one key value per row).
+ *
+ * **Outer joins** (§ Outer Joins — Inserts): a **non-preserved** side is an *optional*
+ * member of the fan-out. A side whose columns are all absent emits no insert (it is
+ * dropped); a non-preserved side that IS supplied is presence-gated per row (it inserts
+ * only for rows supplying ≥1 of its columns). The shared key is minted/threaded only when
+ * ≥2 sides are active (the preserved-only case is a single preserved insert — the row
+ * reads back null-extended); an insert supplying *only* non-preserved columns, with no
+ * preserved anchor row to attach to, is rejected `null-extended-create-conflict` (v1).
+ */
+export declare function analyzeMultiSourceInsert(ctx: PlanningContext, view: MutableViewLike, stmt: AST.InsertStmt): MsInsertAnalysis;
+export declare function analyzeJoinView(ctx: PlanningContext, view: MutableViewLike): JoinViewAnalysis;
+/**
+ * A partner-side base column a cross-source SET value reads (`update v set a.x = b.y`),
+ * captured into `__vmupd_keys` so the lowered single-table UPDATE can read it back. The
+ * `expr` is the read column in base terms (alias-qualified — `b.y`), projected into the
+ * capture over the join body's scope under the stable `alias` (`src0`, `src1`, …); the
+ * rewritten value (`select <alias> from __vmupd_keys k where <ownerPk = capture>`) reads
+ * it correlated by the owning side's PK. Because the capture materializes **before** any
+ * base op fires, the read-back value is the **pre-mutation** partner value — robust to a
+ * both-sides update that also rewrites it (docs/view-updateability.md § Inner Join).
+ */
+export interface CrossSourceValue {
+    readonly alias: string;
+    readonly expr: AST.Expression;
+}
+export declare function decomposeUpdate(ctx: PlanningContext, view: MutableViewLike, analysis: JoinViewAnalysis, stmt: AST.UpdateStmt, sourceValues?: CrossSourceValue[], captureRelationName?: string): BaseOp[];
+/**
+ * The up-front base-PK identity capture for a multi-source (n-way inner-join) UPDATE or
+ * multi-side DELETE fan-out (docs/view-updateability.md § Inner Join, § `returning`).
+ * Built ONCE and shared between the per-side base ops' identifying subqueries and (for
+ * an UPDATE with RETURNING) the RETURNING re-query.
+ *
+ *  - `source`: the capture SELECT `select s0.pk0 as k0_0[, s0.pk1 as k0_1], s1.pk0 as
+ *    k1_0, … from <body> where <idPredicate>` — the emitter materializes it into
+ *    `rctx.tableContexts` under {@link descriptor} **before** any base op runs.
+ *  - `descriptor`: the identity stitch shared between the materialized capture rows
+ *    and every {@link InternalRecursiveCTERefNode} that reads them back.
+ *  - `keyColumns`: the flattened `k<side>_<j>` column shape (one entry per requested
+ *    side per PK column) each reader mints a key ref over.
+ *  - `relationName`: the AST relation name this capture is injected under in `cteNodes`
+ *    (and that every base-op predicate reads back via `from <relationName> k`). Absent ⇒
+ *    {@link MS_UPDATE_KEYS_CTE} — the standalone multi-source / decomposition / set-op /
+ *    CTE-self-read paths all use the shared default. A **nested** capture mints a fresh
+ *    name so two captures can coexist by name in one lowered statement
+ *    (`set-op-write-multisource-leg-compose`): the inner per-branch capture's readers and
+ *    its injected ref agree on the fresh name while shadowing nothing under the default.
+ */
+export interface MultiSourceKeyCapture {
+    readonly source: RelationalPlanNode;
+    readonly descriptor: TableDescriptor;
+    readonly keyColumns: readonly {
+        readonly name: string;
+        readonly type: ScalarType;
+    }[];
+    readonly relationName?: string;
+}
+/**
+ * Mint a context-backed key relation (`InternalRecursiveCTERefNode`) over a
+ * capture's descriptor — what a multi-side base op's identifying `in`-subquery or
+ * the RETURNING re-query's EXISTS scans `__vmupd_keys` through. Fresh attribute ids
+ * per call (each ref lives in its own subtree); the **descriptor** identity is what
+ * ties it to the rows the emitter materializes.
+ *
+ * `captureRelationName` is used for BOTH the node's display CTE name and every
+ * attribute's `sourceRelation`, so a half-updated node can never keep the constant as
+ * `sourceRelation` while the caller injects under a fresh name. It defaults to the
+ * capture's own {@link MultiSourceKeyCapture.relationName} (falling back to
+ * {@link MS_UPDATE_KEYS_CTE}), so a ref minted from a fresh-named capture is
+ * self-consistent without the caller re-passing the name.
+ */
+export declare function makeMultiSourceKeyRef(scope: Scope, capture: MultiSourceKeyCapture, captureRelationName?: string): InternalRecursiveCTERefNode;
+/**
+ * A planning context with `capture` injected into `cteNodes` under its relation name (the
+ * capture's {@link MultiSourceKeyCapture.relationName}, defaulting to {@link MS_UPDATE_KEYS_CTE}),
+ * so a base op's / inner capture's `from <relationName> k` reference resolves to the capture's
+ * context-backed key relation (over the shared capture descriptor). The injected ref's own
+ * name is pinned to the SAME `relationName` so the map key and the ref agree — a nested capture
+ * injects under its fresh `__vmupd_keys$N` name while shadowing nothing under the default. A
+ * fresh ref per call keeps each consumer's subtree from sharing a node instance.
+ *
+ * Shared by the multi-source UPDATE/DELETE builder (`view-mutation-builder.ts`) and the set-op
+ * join-leg compose (`set-op.ts`, which injects the OUTER set-op capture so an inner per-branch
+ * capture's `memberExists` filter resolves against it).
+ */
+export declare function withKeyCapture(ctx: PlanningContext, capture: MultiSourceKeyCapture): PlanningContext;
+/**
+ * The distinct join-side indices the emitted base ops target (each base op carries the
+ * planned side's `TableReferenceNode`), sorted ascending — the sides whose PKs the capture
+ * must project so each op's `select k<side> from <relationName>` resolves. Shared by the
+ * standalone multi-source UPDATE/DELETE builder (`view-mutation-builder.ts`) and the set-op
+ * join-leg compose (`set-op.ts`), which each pass it straight to
+ * {@link buildMultiSourceKeyCapture}.
+ */
+export declare function capturedSideIndices(baseOps: readonly BaseOp[], analysis: JoinViewAnalysis): number[];
+/**
+ * Build the up-front identity capture: each affected view row's base-PK identities,
+ * by the same identifying predicate the base ops route on (user WHERE → base ∧ body
+ * WHERE). Built as **plan nodes directly over the ALREADY-planned join body**
+ * (`analysis.joinNode` + `analysis.joinScope`) — `Project_{k<side>_<j>}(Filter_{idPred}
+ * (joinNode))` — instead of re-planning a cloned AST FROM, so the body is planned
+ * ONCE (§ Round-Trip Laws and the Derived Backward Walk). `preserveInputColumns=false`
+ * ⇒ the materialized rows are exactly the requested key columns, positionally aligned
+ * to the `k<side>_<j>` columns every reader scans back (`keyColumns` and the projection
+ * derive from the same `sideIndices` order; a composite-PK side contributes one column
+ * per PK column).
+ *
+ * `sideIndices` selects which sides' PKs to capture (each requires ≥1 PK column via
+ * {@link requireKeyColumns}; a keyless side is rejected with `unsupported-join`). The
+ * builder passes exactly the sides whose base ops read the capture (plus all sides, for
+ * an UPDATE with RETURNING whose EXISTS correlates the full joined row), so a single-
+ * side write never forces a PK on an untouched side.
+ *
+ * Op-agnostic: takes the user `where` directly (an UPDATE's or a DELETE's) — the
+ * identifying predicate is the same either way.
+ *
+ * `captureRelationName` is the AST relation name the resulting capture is injected
+ * under (and that the base-op predicates `decomposeUpdate`/`decomposeDelete` emit read
+ * back); it is stamped onto the returned {@link MultiSourceKeyCapture.relationName} so
+ * downstream injection/RETURNING read it from the capture object rather than
+ * re-deriving the literal. Defaults to {@link MS_UPDATE_KEYS_CTE} — the standalone
+ * multi-source path is byte-identical; a nested capture passes a fresh name.
+ */
+export declare function buildMultiSourceKeyCapture(ctx: PlanningContext, view: MutableViewLike, where: AST.Expression | undefined, analysis: JoinViewAnalysis, sideIndices: readonly number[], sourceValues?: readonly CrossSourceValue[], captureRelationName?: string): MultiSourceKeyCapture;
+/**
+ * Build the post-mutation RETURNING re-query for a multi-source UPDATE
+ * (docs/view-updateability.md § `returning`). A re-query that matched by the *user
+ * predicate* cannot recapture a row whose predicate column the update itself
+ * rewrote (the changed row no longer matches), so this matches by the captured
+ * **identity** instead: project the view-spelled, base-term RETURNING columns over
+ * the post-mutation join body, restricted to the captured identities by a correlated
+ * `exists (select 1 from __vmupd_keys k where <per-side identity>)` — so a row the
+ * update pushed *out* of the view's filter (or whose predicate column it rewrote) is
+ * still returned (single-source NEW semantics). It keeps only the structural join
+ * ON-condition; the body/user WHERE is intentionally NOT re-applied.
+ *
+ * The per-side identity is **preserved-keyed**: a preserved side matches by exact
+ * per-PK-column equality (`k.k<p>_<j> = s<p>.pk<j>`), while a non-preserved (outer-join
+ * null-extended) side uses a matched-OR-null disjunction `(AND_j k.k<np>_<j> =
+ * s<np>.pk<j>) OR (AND_j k.k<np>_<j> is null)`. This re-keys the re-query off the
+ * **stable preserved-side identity** so a freshly-materialized null-extended row (whose
+ * non-preserved PK was captured NULL) surfaces via its preserved-side equalities alone,
+ * rather than being silently dropped by a `NULL = <minted pk>` match. For an all-
+ * preserved (inner) join every side is exact equality — byte-identical to the prior
+ * behavior, so inner-join RETURNING is unchanged.
+ *
+ * Reads the shared {@link MultiSourceKeyCapture} the builder materializes
+ * before the base ops fire (via its own freshly-minted key ref over the same
+ * descriptor). The capture covers ALL sides for an UPDATE with RETURNING, so this
+ * correlates the full joined row's identity.
+ */
+export declare function buildMultiSourceUpdateReturning(ctx: PlanningContext, view: MutableViewLike, stmt: AST.UpdateStmt, capture: MultiSourceKeyCapture, analysis: JoinViewAnalysis): RelationalPlanNode;
+/**
+ * Build the pre-mutation RETURNING re-query for a multi-source DELETE
+ * (docs/view-updateability.md § `returning`). The OLD view image of the rows about
+ * to vanish: project the view-spelled, base-term RETURNING columns over the raw
+ * `analysis.joinNode` restricted to the identifying predicate (user WHERE → base ∧
+ * body WHERE — the same predicate the key capture and base ops route on). Captured
+ * `pre` (before the base ops fire) so it reads the live base tables through the join.
+ *
+ * Building the projection in **base terms** (rather than referencing the planned
+ * body `root`'s output attribute ids) is what fixes a computed view column: a
+ * computed column has no surviving intermediate attribute id after project-merge, so
+ * a by-id reference dangles — recomputing from base columns has nothing fragile to
+ * reference. Mirrors {@link buildMultiSourceUpdateReturning}; they differ only in the
+ * filter + timing.
+ */
+export declare function buildMultiSourceDeleteReturning(ctx: PlanningContext, view: MutableViewLike, stmt: AST.DeleteStmt, analysis: JoinViewAnalysis): RelationalPlanNode;
+export declare function decomposeDelete(_ctx: PlanningContext, view: MutableViewLike, analysis: JoinViewAnalysis, stmt: AST.DeleteStmt, captureRelationName?: string): BaseOp[];
+/**
+ * The correlated scalar read a cross-source SET value lowers to:
+ * `(select <srcAlias> from __vmupd_keys k where k.k<owningSide>_0 = <pk0> [and …])`
+ * — `<srcAlias>` is the capture projection of the partner base column; the unqualified
+ * `<pk_j>` bind to the lowered UPDATE's own target row (the owning side), matching the
+ * per-side identifying EXISTS so each target row reads the captured pre-mutation partner
+ * value of its joined row. Composite owning keys conjoin one equality per PK column.
+ *
+ * `dedupAggregate` wraps the projection in that aggregate (`min(k.<srcAlias>)`) so the
+ * correlated read is single-valued even when the owning PK matches MORE THAN ONE capture
+ * row — the non-preserved-side fan-out case, where N preserved rows share one non-preserved
+ * partner so its PK matches all N captures (§ Outer Joins). For a constant / np-only SET the
+ * captured value is identical across the group so `min` is an exact no-op de-dup; for a
+ * value that genuinely differs per preserved row it resolves the ambiguity deterministically
+ * rather than erroring at runtime. The cross-source `set` callers leave it off (their gate
+ * already proves at-most-one partner), keeping the bare-column form byte-identical.
+ *
+ * `correlationAlias` qualifies each owning-PK right operand (`<pk_j>` → `<alias>.<pk_j>`).
+ * When this read-back nests inside a user value subquery whose own FROM introduces a
+ * column named like the owning PK, a **bare** `<pk_j>` would re-bind to that inner column
+ * by innermost-scope SQL rules (keying the read-back on the wrong value); qualifying it with
+ * the lowered per-side UPDATE's collision-proof alias ({@link SELF_ALIAS}) binds the outer
+ * target row instead. The multi-source per-side callers pass `SELF_ALIAS`; `decomposition.ts`
+ * and any caller that omits it keep the bare form (byte-identical — composite keys still
+ * qualify every conjunct only when supplied).
+ *
+ * `captureRelationName` is the relation the correlated read scans (`from <name> k`); it
+ * defaults to {@link MS_UPDATE_KEYS_CTE} so the standalone multi-source and decomposition
+ * callers are byte-identical, while a nested multi-source capture threads its fresh name.
+ */
+export declare function capturedValueSubquery(srcAlias: string, owningSideIndex: number, owningPk: readonly string[], dedupAggregate?: string, correlationAlias?: string, captureRelationName?: string): AST.Expression;
+export {};
+//# sourceMappingURL=multi-source.d.ts.map

package/dist/src/planner/mutation/multi-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-source.d.ts","sourceRoot":"","sources":["../../../../src/planner/mutation/multi-source.ts"],"names":[],"mappings":"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"}