@quereus/quereus 4.3.2 → 4.4.1

package/dist/src/core/database-materialized-views-apply.d.ts

@@ -6,15 +6,26 @@
  * resolvers, derived-row and parent-side referential enforcement, and the small key-compare
  * helpers they share. Extracted from database-materialized-views.ts as free functions over
  * {@link MaterializedViewManagerContext}; the manager's orchestration methods
- * (`maintainRowTime`, `flushDeferredRebuilds`, `lookupCoveringConflicts`) call in.
+ * (`maintainRowTime`, `flushDeferredMaintenance`, `lookupCoveringConflicts`) call in.
  */
 import { type SqlValue, type Row } from '../common/types.js';
 import { Scheduler } from '../runtime/scheduler.js';
 import { type DerivedRowConstraintValidator } from './derived-row-validator.js';
-import type { BackingHost, BackingRowChange } from '../vtab/backing-host.js';
+import type { BackingHost, BackingRowChange, MaintenanceOp } from '../vtab/backing-host.js';
 import type { VirtualTableConnection } from '../vtab/connection.js';
 import type { TableSchema } from '../schema/table.js';
-import type { MaterializedViewManagerContext, MaintenancePlan, InverseProjectionPlan, ForwardResidualPlan, JoinResidualPlan, PrefixDeletePlan, BackingConnectionCache, BackingPkColumn } from './database-materialized-views-plans.js';
+import type { MaterializedViewManagerContext, MaintenancePlan, InverseProjectionPlan, ForwardResidualPlan, JoinResidualPlan, PrefixDeletePlan, ResidualMaintenancePlan, ResidualRecomputePlan, ForwardResidualKey, PrefixDeleteKey, ResidualKeyBatch, ResidualKeyBatchEntry, BackingConnectionCache, BackingPkColumn } from './database-materialized-views-plans.js';
+/**
+ * Resolve a plan's backing table to its {@link BackingHost} + coordinated
+ * {@link VirtualTableConnection} — the two handles every apply path writes through.
+ * Shared by the per-row appliers, the batched residual flush, and the full-rebuild
+ * `'replace-all'` diff; throws INTERNAL when the backing table has vanished (an MV in a
+ * broken state).
+ */
+export declare function resolveBackingApplyTarget(ctx: MaterializedViewManagerContext, plan: Pick<MaintenancePlan, 'mv' | 'backingSchema' | 'backingTableName'>, cache?: BackingConnectionCache): Promise<{
+    host: BackingHost;
+    connection: VirtualTableConnection;
+}>;
 /**
  * Compute an `'inverse-projection'` plan's per-row backing delta, apply it, and
  * return the **effective** {@link BackingRowChange}(s) the backing layer realized.
@@ -167,13 +178,29 @@ export declare function runScheduler(ctx: MaterializedViewManagerContext, schedu
  * joined row per key) arms — both bind on the forward driving source via
  * {@link ForwardResidualPlan}; the only difference is the binding (group vs PK).
  *
- * Per-row recompute is correct without per-statement batching: every change to a key
- * triggers a full recompute of that key's slice from live (reads-own-writes) state, so
- * the last change to touch a key writes the authoritative backing row. Batching/dedup
- * across a whole statement is an affordability optimization deferred with the
- * statement-flush boundary (see the ticket handoff).
+ * This is the **cold** (no statement batch in scope) inline path. A statement-batched
+ * caller instead accumulates the same deduped keys via
+ * {@link collectForwardResidualKeys} and recomputes each distinct key once at the
+ * end-of-statement flush ({@link computeForwardResidualOps}) — sound for the same
+ * last-write-wins reason: every recompute reads live (reads-own-writes) state, so
+ * running it once at flush produces exactly what the last per-row run would have.
  */
 export declare function applyForwardResidual(ctx: MaterializedViewManagerContext, plan: ForwardResidualPlan, change: BackingRowChange, cache?: BackingConnectionCache): Promise<BackingRowChange[]>;
+/**
+ * Derive one changed source row's affected forward binding key(s) (OLD ∪ NEW) and add
+ * them to `into`, deduped on the canonical backing-key values: a non-key-changing update
+ * recomputes the group once; a key-changing update recomputes both the old and the new
+ * group. `into` may span a whole statement (the per-statement {@link ResidualKeyBatch})
+ * or a single change (the cold inline path) — the dedup is identical either way.
+ */
+export declare function collectForwardResidualKeys(plan: ForwardResidualPlan, change: BackingRowChange, into: Map<string, ForwardResidualKey>): void;
+/**
+ * Run the forward key-filtered residual once per affected key and build the keyed-diff
+ * ops: upsert the recomputed slice, or point-delete an emptied key. Pure op computation —
+ * the caller owns connection resolution and the single {@link BackingHost.applyMaintenance}
+ * call, so a statement flush can batch many keys' ops into one host call.
+ */
+export declare function computeForwardResidualOps(ctx: MaterializedViewManagerContext, plan: ForwardResidualPlan, keys: Iterable<ForwardResidualKey>): Promise<MaintenanceOp[]>;
 /**
  * True iff `row`'s backing primary-key columns equal `keyVals` (the affected binding
  * key, in `backingPkDefinition` order), under each column's collation. Used to keep
@@ -225,10 +252,26 @@ export declare function applyJoinResidual(ctx: MaterializedViewManagerContext, p
  *
  * A `T`-side membership change (insert/delete/FK-move) is the *forward* path's job and fires
  * its own maintenance. Returns the effective {@link BackingRowChange}(s) for the MV-over-MV
- * cascade. Per-row recompute is correct without batching for the same
- * last-write-wins-against-live-state reason as {@link applyForwardResidual}.
+ * cascade. This is the cold inline path; a statement-batched caller accumulates via
+ * {@link collectLookupResidualKeys} and recomputes at flush ({@link computeLookupResidualOps})
+ * — sound for the same last-write-wins-against-live-state reason as
+ * {@link applyForwardResidual}.
  */
 export declare function applyLookupResidual(ctx: MaterializedViewManagerContext, plan: JoinResidualPlan, change: BackingRowChange, cache?: BackingConnectionCache): Promise<BackingRowChange[]>;
+/**
+ * Derive one changed lookup-side (`P`) row's affected lookup key(s) (OLD ∪ NEW) and add
+ * them to `into`, deduped on `P`'s canonical PK values. The statement-batch counterpart
+ * of the derivation inside {@link applyLookupResidual}.
+ */
+export declare function collectLookupResidualKeys(plan: JoinResidualPlan, change: BackingRowChange, into: Map<string, SqlValue[]>): void;
+/**
+ * Run the lookup-keyed residual variant once per affected `P` key and build the ops —
+ * the delete-capable membership diff when the plan carries
+ * `lookupMembershipResidualScheduler`, upsert-only otherwise (see
+ * {@link applyLookupResidual} for the soundness argument). Pure op computation; the
+ * caller owns connection resolution and the single applyMaintenance call.
+ */
+export declare function computeLookupResidualOps(ctx: MaterializedViewManagerContext, plan: JoinResidualPlan, keys: Iterable<SqlValue[]>): Promise<MaintenanceOp[]>;
 /**
  * Compute a `'prefix-delete'` plan's per-row backing delta and apply it: derive the
  * affected base key(s) from the changed row (OLD ∪ NEW, deduped on the base key), and
@@ -258,12 +301,30 @@ export declare function applyLookupResidual(ctx: MaterializedViewManagerContext,
  *
  * Structurally the same as {@link applyForwardResidual}, differing only in the
  * **prefix-slice** diff (one base row owns N backing rows sharing the prefix) and the
- * **N-row** residual. Per-row recompute is correct without per-statement batching: the
- * residual reads live (reads-own-writes) state, so the last write to a base key produces
- * the authoritative slice. (Statement-level dedup of distinct base keys is the same
- * affordability optimization deferred for the aggregate arm.)
+ * **N-row** residual. This is the cold inline path; a statement-batched caller
+ * accumulates the same deduped base keys via {@link collectPrefixDeleteKeys} and diffs
+ * each distinct key once at flush ({@link computePrefixDeleteOps}) — sound because the
+ * residual and the effective-slice read both see live (reads-own-writes) state, so the
+ * flush-time diff is exactly what the last per-row diff would have produced.
  */
 export declare function applyPrefixDelete(ctx: MaterializedViewManagerContext, plan: PrefixDeletePlan, change: BackingRowChange, cache?: BackingConnectionCache): Promise<BackingRowChange[]>;
+/**
+ * Derive one changed base row's affected base key(s) (OLD ∪ NEW) and add them to
+ * `into`, deduped on the canonical base-PK values. `keyTuple` binds the residual
+ * (`pk{i}`); `prefix` is the slice's leading-PK equality key (the base-PK values in
+ * backing-PK order — identical here since the base PK leads the backing PK, but kept
+ * distinct for clarity). The statement-batch counterpart of the derivation inside
+ * {@link applyPrefixDelete}.
+ */
+export declare function collectPrefixDeleteKeys(plan: PrefixDeletePlan, change: BackingRowChange, into: Map<string, PrefixDeleteKey>): void;
+/**
+ * Per affected base key: run the fan-out residual, read the existing effective slice for
+ * the base prefix, and build the keyed-diff ops (delete disappeared keys, upsert the
+ * recomputed rows). Pure op computation over the supplied host/connection; the caller
+ * owns the single applyMaintenance call, so a statement flush batches many base keys'
+ * ops into one host call.
+ */
+export declare function computePrefixDeleteOps(ctx: MaterializedViewManagerContext, plan: PrefixDeletePlan, keys: Iterable<PrefixDeleteKey>, host: BackingHost, connection: VirtualTableConnection): Promise<MaintenanceOp[]>;
 /**
  * True iff two backing rows agree on every backing-PK column under that column's
  * collation — the btree's key identity. Pairs an existing slice row with the
@@ -277,4 +338,85 @@ export declare function backingPkEqual(pkDef: ReadonlyArray<BackingPkColumn>, a:
  * {@link applyPrefixDelete}.
  */
 export declare function residualRowMatchesBasePrefix(plan: PrefixDeletePlan, row: Row, prefixVals: readonly SqlValue[]): boolean;
+/**
+ * Accumulate one source change's affected binding key(s) for a residual-arm plan into
+ * the per-statement {@link ResidualKeyBatch}, deduped across the whole statement —
+ * the deferred-accumulate counterpart of the cold per-row appliers above. Which
+ * variant map receives the keys follows the plan kind; a `'join-residual'` change
+ * routes on **which source changed** (forward for the driving `T`, lookup for `P`),
+ * exactly as {@link applyJoinResidual} dispatches. `planKey` is the MV key
+ * (lowercased `schema.name`) the manager indexes the plan under.
+ */
+export declare function accumulateResidualKeys(plan: ResidualMaintenancePlan, change: BackingRowChange, changedBase: string, batch: ResidualKeyBatch, planKey: string): void;
+/**
+ * Compute the flush-time ops for one residual-arm MV's accumulated statement keys: run
+ * the appropriate residual variant once per distinct key against live post-statement
+ * state and concatenate the keyed-diff ops. Distinct keys touch disjoint backing slices
+ * — except a `'join-residual'` statement that accumulated both forward and lookup keys,
+ * where an overlapping backing row is recomputed twice from the SAME live state, so the
+ * duplicate upsert is value-identical and the host suppresses it. The caller owns the
+ * single {@link BackingHost.applyMaintenance} call over the combined array — one host
+ * round-trip per (MV, flush round) instead of one per source row.
+ */
+export declare function computeResidualBatchOps(ctx: MaterializedViewManagerContext, plan: ResidualMaintenancePlan, entry: ResidualKeyBatchEntry, host: BackingHost, connection: VirtualTableConnection): Promise<MaintenanceOp[]>;
+/**
+ * Fold one source change's per-column aggregate contributions into the statement's
+ * delta accumulation ({@link ResidualKeyBatchEntry.delta}) — the delta-aggregate
+ * counterpart of {@link collectForwardResidualKeys}, called right after it (the
+ * residual keys remain the fallback record). Per contributing row image:
+ * `step(identity, row[arg])` (zero-arg → `step(identity)`) is the row's contribution;
+ * an insert `merge`s it in, a delete `merge`s its `negate`, an update retracts the OLD
+ * image into its group and inserts the NEW into its (possibly different) group. A row
+ * whose body-WHERE predicate is not unambiguously TRUE contributes nothing — but the
+ * raw column value (including NULL) IS fed to `step`, never pre-filtered: NULL-handling
+ * is the aggregate's own (law 2), and the row still counts toward the zero-arg
+ * multiplicity witness.
+ */
+export declare function accumulateDeltaAggregates(plan: ResidualRecomputePlan, change: BackingRowChange, entry: ResidualKeyBatchEntry): void;
+/**
+ * Flush-time op computation for a delta-aggregate MV's accumulated statement deltas —
+ * the arithmetic read-modify-write that replaces the per-group residual re-execution.
+ * Per affected group:
+ *  1. read the group's current EFFECTIVE backing row by its full PK (the host's
+ *     `scanEffective` equality-prefix point read — pending over committed, so a group
+ *     written by an earlier statement of this transaction folds correctly);
+ *  2. per aggregate column: base = stored ? `decode(stored[col])` : a fresh identity
+ *     accumulator; finalized = `finalize(merge(base, delta))`;
+ *  3. the multiplicity witness finalizing to 0 ⇔ the group emptied → `delete-key`
+ *     (skipped when no row was stored); otherwise upsert the rebuilt row (group-key
+ *     values + finalized aggregates) — the host's value-identical skip suppresses a
+ *     net-identity delta (MV-016).
+ *
+ * **Retraction fallback.** A group that accumulated a retraction re-derives from its
+ * residual key (always accumulated alongside, same canonical map key) instead of the
+ * arithmetic, in two cases:
+ *  - the descriptor has a **tighten** column (min/max — merge, no negate): a retraction
+ *    cannot be undone by merge, so the whole group re-derives from live source state
+ *    **whether or not a row is stored** (an intra-statement delete of the extreme poisons
+ *    even a from-identity net-fold). The residual recomputes every column of the row
+ *    (count/sum included), so a mixed group+tighten row is maintained by ONE path — no
+ *    double-maintenance;
+ *  - otherwise the descriptor is not retraction-safe (an abelian column whose decode is
+ *    only an insert-observational witness — a nullable-argument sum) AND a stored row
+ *    exists: the stored value cannot prove the true contribution count survives the
+ *    retraction, so decoding it is unsound. A group with no stored row needs no fallback
+ *    here — a pure abelian net-fold from identity is exact.
+ *
+ * Zero source reads, no residual execution on the arithmetic path — this is why the
+ * delta path also BYPASSES the per-statement degrade-to-rebuild crossover (it is
+ * already O(affected groups)).
+ */
+export declare function computeDeltaAggregateOps(ctx: MaterializedViewManagerContext, plan: ResidualRecomputePlan, entry: ResidualKeyBatchEntry, host: BackingHost, connection: VirtualTableConnection): Promise<MaintenanceOp[]>;
+/**
+ * Invalidate every accumulated delta in the per-statement batch — called by the DML
+ * executor when an OR FAIL per-row savepoint ROLLS BACK: the savepoint undoes the
+ * failing row's source (and backing) writes, but the JS-side accumulation cannot be
+ * unwound, so the folded deltas may carry the reverted row's contribution. The residual
+ * keys are unaffected (a reverted key's recompute reads surviving live state and is
+ * value-identical → suppressed), so poisoning simply drops the fast path: the flush in
+ * the executor's catch routes those entries through the plain residual. One-way for the
+ * statement — `deltaPoisoned` also stops later (cascade-driven) delta re-accumulation
+ * into the same entry from mixing with an already-flushed-around state.
+ */
+export declare function poisonResidualDeltaAccumulations(batch: ResidualKeyBatch): void;
 //# sourceMappingURL=database-materialized-views-apply.d.ts.map

package/dist/src/core/database-materialized-views-apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database-materialized-views-apply.d.ts","sourceRoot":"","sources":["../../../src/core/database-materialized-views-apply.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"database-materialized-views-apply.d.ts","sourceRoot":"","sources":["../../../src/core/database-materialized-views-apply.ts"],"names":[],"mappings":"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"}