@quereus/quereus 3.2.1 → 4.0.0

package/dist/src/planner/mutation/decomposition.d.ts

@@ -0,0 +1,273 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import type { TableReferenceNode } from '../nodes/reference.js';
+import type { RelationalPlanNode } from '../nodes/plan-node.js';
+import type { Scope } from '../scopes/scope.js';
+import type { StorageShape, DecompositionMember } from '../../vtab/mapping-advertisement.js';
+import type { ScalarType } from '../../common/datatype.js';
+import type { TableSchema } from '../../schema/table.js';
+import type { SqlValue } from '../../common/types.js';
+import type { BaseOp, MutableViewLike, MutationRequest } from './propagate.js';
+import { type BackwardColumn } from './backward-body.js';
+import { type MultiSourceKeyCapture } from './multi-source.js';
+/**
+ * Advertisement-driven **put** fan-out for a logical table backed by an n-way
+ * decomposition (columnar split / column-family / EAV), the write dual of the
+ * `get` join `schema/lens-compiler.ts` synthesizes (`compileDecompositionBody`).
+ * See `docs/lens.md` § The Default Mapper and `docs/view-updateability.md`
+ * § Decomposition put fan-out.
+ *
+ * A decomposition lens is registered as an ordinary view whose `selectAst` is the
+ * synthesized `anchor ⋈ members` join, so writing it would otherwise route to the
+ * generic two-table-inner-join `multi-source.ts` path — which has the **wrong**
+ * semantics for a decomposition (it picks a single delete side, rejects > 2
+ * members, and rejects the outer joins optional members ride). `propagate()`
+ * intercepts a decomposition body (the slot carries a `primary-storage`
+ * advertisement and no override) and routes it here instead.
+ *
+ * **Scope shipped here (DELETE / UPDATE in this module; INSERT off the envelope
+ * built in `building/view-mutation-builder.ts`):**
+ *
+ * - **DELETE** fans out to *every* member (mandatory, optional, and EAV pivot) so
+ *   the logical row ceases to exist across the whole decomposition. Members are
+ *   ordered **anchor-last**; each non-anchor member's identifying set is read from
+ *   the **anchor alone** (never the full join), so an earlier member's delete can
+ *   never shrink a later member's identifying set. This is what keeps the fan-out
+ *   sound without the snapshot-consistent multi-member execution substrate.
+ * - **UPDATE** routes each assignment to the member that backs it, keyed off the
+ *   anchor the same anchor-last way. A **mandatory, non-EAV** member takes one base
+ *   UPDATE. An **optional columnar** member's write is a per-row materialization
+ *   transition realized as plain AST base ops over the anchor, routed by the assigned
+ *   **value shape** ({@link lowerMaterializedValue}): a **constant** value takes the
+ *   matched base UPDATE + an absent null-extended INSERT (anchor-keyed insert-select
+ *   `… on conflict (<memberKey>) do nothing`, which cedes the matched rows to the
+ *   UPDATE without the insert source scanning its own target), or — when every value
+ *   column is assigned null — a base DELETE instead; an **anchor-resolvable** value
+ *   (`set c = a + 1`, every leaf lowers to an anchor base column) collapses both
+ *   branches into a single `… on conflict (<memberKey>) do update set c = excluded.c`
+ *   upsert (the value computed once over the anchor scan, matched rows reading it via
+ *   `excluded.<col>`); a **member self-reference** (`set c = c + 1`, `set c = coalesce(c, 0)
+ *   + 1`) keeps the matched UPDATE for present rows **and** adds a materialize INSERT for absent
+ *   rows that projects the self-expression with the owner's own columns substituted to NULL,
+ *   gated by a runtime non-empty filter (so a null-propagating expression materializes nothing
+ *   while a null→non-null one does) and `on conflict (<memberKey>) do nothing` to cede matched
+ *   rows — the two ops stay distinct because the matched and materialize values are computed over
+ *   different scans. An **arbitrary** columnar value — one that embeds a subquery, reads a
+ *   *different* member's column, or mixes anchor + self leaves (`set c = b + 1`, `set c = c + a`,
+ *   `set c = (select …)`) — now rides a **single-identity (anchor-key) per-row capture** instead
+ *   of rejecting: every affected row's value is materialized ONCE over the planned get body (which
+ *   null-extends an absent optional member, so the captured value already encodes per-row presence)
+ *   into the multi-source `__vmupd_keys` substrate, and the matched UPDATE reads it back keyed by
+ *   the member key while a filtered materialize INSERT reads it keyed by the anchor key, gated on a
+ *   **runtime** non-null (the value is data-dependent, so the plan-time `foldsConstantFalse` of the
+ *   `self` fast-lane cannot decide it). Capturing the value pre-mutation is what makes a both-sides
+ *   write (`set c = b + 1, b = b + 100`) read `c` from the *pre-mutation* `b`
+ *   ({@link emitCapturedMemberUpdate} / {@link buildCapturedMaterializeInsert}; the capture relation
+ *   is {@link buildDecompositionKeyCapture}). A mixed anchor+self group rides this path too — it
+ *   subsumes the retired same-statement reject. An
+ *   **EAV pivot** member's write is the triple analogue, per attribute: a null deletes
+ *   the triple, an anchor-resolvable value upserts it via `do update`, a constant value
+ *   upserts it via matched UPDATE + `do nothing` materialize INSERT, and an **arbitrary EAV**
+ *   value (a subquery, a cross-member column, an anchor+self mix, or any EAV self-reference —
+ *   which an EAV value column lowers to a subquery for) rides the **same single-identity capture**
+ *   as the columnar arbitrary case: the captured value substitutes the get-body projection over the
+ *   anchor scan, the matched UPDATE reads it back by the entity column, and a non-null-filtered
+ *   materialize INSERT reads it back by the anchor key (`on conflict (entity, attr) do nothing`).
+ * - **INSERT** fans out to one insert per member, **anchor first** (FK-order root).
+ *   It rides the shared-surrogate mutation envelope `view-mutation-shared-surrogate-insert`
+ *   ships (`ViewMutationNode.envelope` + `EnvelopeScanNode`): the user source is
+ *   materialized once, the surrogate value is sourced from the **anchor key column's
+ *   declared `default`** — evaluated once per row at the envelope (with
+ *   `mutation_ordinal()` in scope), so the basis author chooses the ID policy and the
+ *   engine invents nothing — and threaded into every member's key column(s) via the
+ *   equivalence class, with each member reading the identical rows back.
+ *   `logical-tuple` keys thread the supplied logical PK; no default. Optional members are inserted only for rows that
+ *   supply ≥1 of their columns (a per-row presence filter — the outer-join
+ *   semantics the read preserves); EAV pivot members emit one triple insert per
+ *   supplied attribute, gated on a non-null value. The plan-agnostic decomposition
+ *   is {@link analyzeDecompositionInsert} here; the plan-node build (envelope +
+ *   per-member projections) is `buildDecompositionInsert` in the builder, mirroring
+ *   the multi-source insert split.
+ *
+ * **Deferred (raised here with a precise diagnostic), because each rides a
+ * substrate that is not yet present:**
+ *
+ * - A DELETE/UPDATE **WHERE that references a non-anchor member** (an EAV pivot, or an
+ *   embedded subquery) — needs the snapshot-consistent multi-member base-op execution
+ *   the predicate-honest multi-side fan-out is deferred onto (see `multi-source.ts`
+ *   § delete + the `view-mutation-lenient-multiside-delete-fanout` backlog ticket). A
+ *   WHERE that is **anchor-resolvable** — an anchor identity column **or** a computed
+ *   mapping whose basis lives on the anchor (`bumped = a + 1`, `combined = a || b`) —
+ *   is *supported*: it substitutes into a predicate over the anchor's own base columns,
+ *   which the anchor subquery already evaluates, so it does not defer.
+ * - **UPDATE of a shared-key column** — a key write is an identity change, not a
+ *   value write. (Optional-member and EAV value writes — including arbitrary captured
+ *   values — are **supported**, see the UPDATE bullet above; only a key/identity write
+ *   stays rejected.)
+ * - **composite shared keys** — v1 threads a single-column key (mirrors the
+ *   single-column-PK boundary in `multi-source.ts`).
+ */
+/**
+ * Resolved view of one decomposition for the put fan-out. Its backward decisions
+ * are derived from the **threaded plan-node `updateLineage`** read through the
+ * shared backward-walk consumer (`analyzeBodyLineage`) — the same n-way reader the
+ * multi-source join walk consumes — rather than a parallel AST scan of the
+ * synthesized body's projection list (docs/view-updateability.md § Round-Trip Laws
+ * and the Derived Backward Walk, docs/lens.md § The Default Mapper).
+ */
+export interface DecompShape {
+    readonly storage: StorageShape;
+    readonly anchor: DecompositionMember;
+    /** logical-column-name (lowercased) → its backing expression in the get body (from the shared consumer). */
+    readonly viewColToBaseRef: ReadonlyMap<string, AST.Expression>;
+    /** Per logical column, its backward lineage off the planned body (shared with multi-source). */
+    readonly columns: readonly BackwardColumn[];
+    /** Planned-body `TableReferenceNode` id → the decomposition member it realizes (join members only). */
+    readonly memberByTableId: ReadonlyMap<number, DecompositionMember>;
+    /**
+     * The planned get body's relational source (the `anchor ⋈ members` join for a columnar
+     * body) + its combined column scope — the source/scope {@link buildDecompositionKeyCapture}
+     * builds the single-identity value capture over, resolving the member-relationId-qualified
+     * base columns the lowered captured values carry (the decomposition dual of
+     * `analyzeJoinView`'s `joinNode` / `joinScope`). Threaded from the shared body lineage.
+     */
+    readonly bodySource: RelationalPlanNode;
+    readonly bodyScope: Scope | undefined;
+}
+/**
+ * Plan the synthesized get body **once** and read its threaded `updateLineage`
+ * into a {@link DecompShape}: the per-column backward lineage (column → owning base
+ * relation) plus a `TableReferenceNode`-id → member map, so the routing / anchor
+ * gate decide off the plan-node backward walk shared with the multi-source path
+ * (not a parallel projection-AST scan). EAV pivot members are correlated subqueries,
+ * not join sources, so they carry no planned `TableReferenceNode` and are absent
+ * from {@link DecompShape.memberByTableId} (resolved off the advertisement instead).
+ */
+export declare function analyzeDecomposition(ctx: PlanningContext, view: MutableViewLike, storage: StorageShape): DecompShape;
+/**
+ * Decompose a mutation through a decomposition-backed logical table into an
+ * ordered `BaseOp[]`. Throws a structured diagnostic for any deferred shape.
+ */
+export declare function propagateDecomposition(ctx: PlanningContext, view: MutableViewLike, storage: StorageShape, req: MutationRequest): BaseOp[];
+/**
+ * One target column of a member insert: its value comes from the materialized
+ * envelope (by index) or is a constant literal (the EAV attribute name).
+ */
+export interface DecompInsertColumn {
+    readonly baseColumn: string;
+    /** Index into the materialized envelope row supplying the value. */
+    readonly envelopeIndex?: number;
+    /** Constant value (the EAV attribute literal) when no envelope column supplies it. */
+    readonly literal?: SqlValue;
+}
+/**
+ * One base insert a decomposition insert fans out to — one per columnar member,
+ * or one per supplied EAV attribute (a triple).
+ */
+export interface DecompInsertOp {
+    readonly table: TableReferenceNode;
+    readonly schema: TableSchema;
+    readonly columns: readonly DecompInsertColumn[];
+    /**
+     * Envelope indices whose non-null presence gates this op per-row: an optional
+     * member inserts only for rows that supply ≥1 of its columns; an EAV triple only
+     * when its value is non-null (the outer-join absence semantics the read
+     * preserves). Empty ⇒ unconditional (mandatory member / singleton).
+     */
+    readonly presenceGateIndices: readonly number[];
+}
+/**
+ * The plan-agnostic decomposition of a decomposition INSERT, consumed by
+ * `buildDecompositionInsert` (`building/view-mutation-builder.ts`). The **envelope**
+ * leading columns are the supplied logical columns (in user-source order),
+ * optionally followed by a surrogate shared key sourced from the anchor key
+ * column's declared `default` (`keyDefault`). Each member op reads its values back
+ * out of that one materialized envelope, so the default is evaluated once per
+ * produced row and the value threads across every member insert via the
+ * equivalence class (docs/view-updateability.md § Mutation Context, docs/lens.md § The Default Mapper).
+ */
+export interface DecompInsertAnalysis {
+    readonly suppliedColumns: readonly {
+        readonly name: string;
+        readonly type: ScalarType;
+    }[];
+    /** Member base inserts, anchor first (then advertisement order). */
+    readonly ops: readonly DecompInsertOp[];
+    /**
+     * The anchor key column's declared `default` — the surrogate's per-row source.
+     * Set only for a surrogate shared key (the engine evaluates it once per produced
+     * row at the envelope, with `mutation_ordinal()` in scope, and threads the value
+     * into every member's key column via the equivalence class). Absent for a
+     * logical-tuple (supplied) key.
+     */
+    readonly keyDefault?: AST.Expression;
+}
+/**
+ * Decompose an INSERT through a decomposition-backed logical table into the
+ * per-member base inserts plus the shared-surrogate envelope they fan out from
+ * (anchor first — the FK-order root). Throws a structured diagnostic for any
+ * deferred shape (composite/absent key, non-integer surrogate, an uncoverable
+ * not-null member column, a computed/unbacked logical column).
+ */
+export declare function analyzeDecompositionInsert(ctx: PlanningContext, view: MutableViewLike, storage: StorageShape, stmt: AST.InsertStmt): DecompInsertAnalysis;
+/**
+ * Route each assignment to the member that backs it and emit the per-member base
+ * ops, anchor-last (so a member whose column the predicate reads is not mutated
+ * before a sibling's identifying set is computed, and so every materialization
+ * branch reads the still-intact anchor). A **mandatory, non-EAV** member takes one
+ * base UPDATE (the legacy path). An **optional columnar** member's write is a per-row
+ * materialization transition — matched → base UPDATE, absent → null-extended INSERT,
+ * all value columns set null → base DELETE — and an **EAV pivot** member's write is
+ * the per-attribute triple analogue (non-null → upsert, null → delete). The branches
+ * are ordinary AST base ops keyed off the anchor subquery, not a new plan-node
+ * substrate (the same realization consumer 1 used for the outer-join dual). Shared-key
+ * (identity) / computed targets stay rejected.
+ *
+ * `capturedValues` is the optional **capture carrier** the builder threads (parallel to
+ * `decomposeUpdate`'s `sourceValues` in multi-source.ts): when present, an **arbitrary**
+ * value on an *optional columnar* member OR an **EAV** member (a subquery, cross-member, or
+ * mixed anchor+self — and, for EAV, any self-reference, since an EAV value column lowers to a
+ * subquery — otherwise rejected) is lowered to base terms and accumulated as a `srcN`
+ * projection, and its cell rides the per-row capture two-op path
+ * ({@link emitCapturedMemberUpdate} for columnar, {@link emitEavCapturedAttr} for EAV); the
+ * builder then materializes the values once over the planned body
+ * ({@link buildDecompositionKeyCapture}) and every base op reads them back through the
+ * context-injected `__vmupd_keys`. Absent the carrier (the legacy `propagateDecomposition`
+ * path, unreachable from build), an arbitrary value stays rejected — the defensive legacy
+ * behaviour, exactly as `propagateMultiSource`'s update path does.
+ */
+export declare function decomposeUpdate(ctx: PlanningContext, view: MutableViewLike, shape: DecompShape, stmt: AST.UpdateStmt, capturedValues?: CapturedDecompValue[]): BaseOp[];
+/**
+ * One arbitrary optional-columnar value captured into the up-front `__vmupd_keys` set: the
+ * `expr` is the assigned value lowered to base terms (member-relationId-qualified, over the
+ * planned get body), projected into the capture under the stable `alias` (`src0`, `src1`, …).
+ * Each base op reads it back correlated by the stitch key — by the member key (matched UPDATE)
+ * or the anchor key (materialize INSERT) — so the value is the **pre-mutation** one regardless
+ * of base-op order (the decomposition analogue of multi-source.ts `CrossSourceValue`).
+ */
+export interface CapturedDecompValue {
+    readonly alias: string;
+    readonly expr: AST.Expression;
+}
+/**
+ * Build the single-identity (anchor-key) per-row value capture for a decomposition columnar
+ * UPDATE — the decomposition dual of `buildMultiSourceKeyCapture` (multi-source.ts), reusing the
+ * shared `__vmupd_keys` substrate ({@link MultiSourceKeyCapture} / `makeMultiSourceKeyRef` /
+ * `keyColumnName`). Built as plan nodes directly over the **already-planned get body**
+ * (`shape.bodySource` + `shape.bodyScope`) — `Project_{k0_0, srcN…}(Filter_{anchorPred}(body))` —
+ * so the body is planned once and the captured value already encodes per-row presence (the body
+ * null-extends an absent optional member).
+ *
+ *  - `k0_0` (the only identity column) := the anchor key, read back by every base op (by the
+ *    member key in the matched UPDATE, the anchor key in the materialize INSERT — both correlate
+ *    `k.k0_0`, which holds the shared stitch-key value, since each member is keyed 1:1 to the
+ *    anchor).
+ *  - one `srcN` per {@link CapturedDecompValue}, in registration (= read-back) order, so the
+ *    flattened `keyColumns` align positionally with the projections every reader scans back.
+ *
+ * The identity predicate is the same anchor-resolvable lowering the base ops route on
+ * ({@link anchorPredicate}, re-validated here — idempotent); a non-anchor WHERE has already
+ * thrown in `decomposeUpdate` before any capture is requested (atomic).
+ */
+export declare function buildDecompositionKeyCapture(ctx: PlanningContext, view: MutableViewLike, shape: DecompShape, where: AST.Expression | undefined, capturedValues: readonly CapturedDecompValue[]): MultiSourceKeyCapture;
+//# sourceMappingURL=decomposition.d.ts.map

package/dist/src/planner/mutation/decomposition.d.ts.map

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