@quereus/quereus 3.2.1 → 4.0.0

package/dist/src/vtab/memory/layer/manager.d.ts

@@ -1,14 +1,50 @@
 import type { Database } from '../../../core/database.js';
-import { type TableSchema, type IndexSchema } from '../../../schema/table.js';
+import { type TableSchema, type IndexSchema, type UniqueConstraintSchema } from '../../../schema/table.js';
 import { type BTreeKeyForPrimary } from '../types.js';
 import { type SqlValue, type Row, type UpdateResult } from '../../../common/types.js';
 import type { Layer } from './interface.js';
 import { MemoryTableConnection } from './connection.js';
+import { QuereusError } from '../../../common/errors.js';
 import { ConflictResolution } from '../../../common/constants.js';
-import type { ColumnDef as ASTColumnDef } from '../../../parser/ast.js';
+import type { ColumnDef as ASTColumnDef, TableConstraint as ASTTableConstraint } from '../../../parser/ast.js';
 import type { ScanPlan } from './scan-plan.js';
 import type { VTableEventEmitter } from '../../events.js';
 import type { Expression } from '../../../parser/ast.js';
+import type { MemoryIndex } from '../index.js';
+import type { MaintainedTableSchema } from '../../../schema/derivation.js';
+import type { MaintenanceOp, BackingRowChange } from '../../backing-host.js';
+/**
+ * Unified surface for the structure that enforces a UNIQUE constraint. A
+ * constraint is logical; its backing structure is optional and may take one of
+ * several physical shapes:
+ *
+ *  - `memory-index` — the synchronously-maintained secondary BTree auto-built per
+ *    UNIQUE constraint (reframed as an *implicit* covering structure in the
+ *    materialized-view vocabulary).
+ *  - `materialized-view` — an explicit, **`row-time`** covering MV whose backing
+ *    table is kept consistent synchronously with each source row-write. Now that
+ *    row-time write-through MV maintenance exists, {@link MemoryTableManager.findIndexForConstraint}
+ *    returns this variant *in preference to* `memory-index` whenever a linked,
+ *    non-stale row-time covering MV is present: it makes the MV the live
+ *    conflict-resolution path (physical schemas otherwise never reach it, since
+ *    the auto-index always exists) and is exactly the structure the lens layer
+ *    makes sole once the auto-index is retired. See
+ *    `docs/materialized-views.md` § Covering structures.
+ */
+export type CoveringStructure = {
+    kind: 'memory-index';
+    index: MemoryIndex;
+} | {
+    kind: 'materialized-view';
+    view: MaintainedTableSchema;
+};
+/** Origin + structure name for a UNIQUE constraint's implicit covering structure. */
+export interface ImplicitCoveringStructure {
+    /** Name of the secondary index (the synchronously-maintained BTree) that realizes the constraint. */
+    indexName: string;
+    /** Always `'implicit-from-unique-constraint'` — the auto-built secondary BTree. */
+    origin: 'implicit-from-unique-constraint';
+}
 export declare class MemoryTableManager {
     readonly managerId: number;
     readonly db: Database;
@@ -21,16 +57,67 @@ export declare class MemoryTableManager {
     readonly isReadOnly: boolean;
     tableSchema: TableSchema;
     private primaryKeyFunctions;
+    /**
+     * Implicit covering structures: constraint identity → the auto-index that
+     * realizes it. The physical structure is the synchronously-maintained
+     * secondary BTree; this association lets `findIndexForConstraint` and
+     * introspection speak the materialized-view vocabulary (an `origin`) for the
+     * implicit structure, the same way an explicit covering MV is described.
+     * Keyed by constraint name when present, else by the auto-index name.
+     */
+    private readonly implicitCoveringStructures;
     /** Optional event emitter for mutation and schema hooks */
     private eventEmitter?;
     constructor(db: Database, _moduleName: string, schemaName: string, tableName: string, initialSchema: TableSchema, readOnly?: boolean, eventEmitter?: VTableEventEmitter);
     private initializePrimaryKeyFunctions;
+    /**
+     * One-bit guard on `Schema.kind` (docs/lens.md § Departures): true when this
+     * table belongs to a logical schema. Prefers the table's own `isLogical` flag
+     * and falls back to the owning schema's `kind`, so the gate holds even if a
+     * logical TableSchema were ever (incorrectly) handed to a memory manager.
+     */
+    private isLogicalSchema;
     /**
      * Auto-creates secondary indexes for UNIQUE constraints that don't already
      * have a matching index. This mirrors standard SQL behavior where UNIQUE
      * constraints imply an index for efficient enforcement.
+     *
+     * Alongside each such index, records an *implicit covering structure*
+     * descriptor in {@link implicitCoveringStructures} (the materialized-view
+     * vocabulary) so the implicit BTree and a future explicit covering MV share
+     * one schema shape. The physical structure is unchanged — observation-
+     * equivalent, zero behavioral difference.
      */
     private ensureUniqueConstraintIndexes;
+    /**
+     * Returns the implicit covering structure realizing the given UNIQUE
+     * constraint, or undefined when none was synthesized. Part of the unified
+     * covering-structure surface the lens layer and introspection consume — the
+     * physical structure is the synchronously-maintained secondary BTree named
+     * {@link ImplicitCoveringStructure.indexName}.
+     */
+    getImplicitCoveringStructure(uc: UniqueConstraintSchema): ImplicitCoveringStructure | undefined;
+    /** Conventional auto-index name for an unnamed UNIQUE constraint (mirrors {@link ensureUniqueConstraintIndexes}). */
+    private implicitIndexNameFor;
+    /**
+     * True when a same-column-set index's per-column collations are
+     * collation-equivalent to the constraint's DECLARED column collations.
+     *
+     * Gates REUSE of an existing same-column-set index as a non-derived UNIQUE's
+     * realizing structure. A non-derived (table-level / column) UNIQUE enforces
+     * under the declared column collation, so reusing a finer/coarser-collated
+     * same-column-set index (e.g. a BINARY `create unique index` over a NOCASE
+     * column) would silently enforce under the index's collation instead. When
+     * this returns false the caller builds the distinct `_uc_*` covering index and
+     * lets the user index coexist as an independent constraint (matches SQLite,
+     * where both indexes enforce).
+     *
+     * Positions align because the column SET already matched
+     * (`idx.columns[i]` ↔ `uc.columns[i]`). A plain index column with no explicit
+     * COLLATE has `collation === undefined` and falls back to the declared
+     * collation, so the common case stays reuse-safe.
+     */
+    private indexCollationsMatchDeclared;
     /**
      * Get the event emitter if one was provided.
      */
@@ -89,12 +176,50 @@ export declare class MemoryTableManager {
     /**
      * Checks all UNIQUE constraints for a new/updated row. Returns an UpdateResult
      * if a violation is found (or IGNORE suppresses the insert), or null if all pass.
-     * For REPLACE conflicts, the conflicting rows are deleted from the layer.
+     * For REPLACE conflicts, the conflicting rows are deleted from the layer and
+     * pushed onto `evicted` so the DML executor can run the full delete pipeline
+     * (change-tracking, row-time MV maintenance, FK cascade, auto-events) for each.
      */
     private checkUniqueConstraints;
     private checkSingleUniqueConstraint;
+    /**
+     * Resolves the {@link CoveringStructure} enforcing a UNIQUE constraint. Prefers
+     * a linked, non-stale row-time covering MV when one is present (the live
+     * enforcement path in v1; the sole structure once the auto-index is
+     * retired — see {@link CoveringStructure}), falling back to the auto-built
+     * `memory-index`. The row-time resolution is a synchronous map lookup with an
+     * O(1) negative fast path, so a non-covered table stays on the index path at
+     * effectively no cost.
+     *
+     * `allowMvCovering = false` skips the MV preference: the maintenance-write
+     * enforcement path ({@link enforceSecondaryUniqueOnMaintenance}) checks rows
+     * THIS table's batch just wrote, and a covering MV over this table is
+     * cascade-maintained only after the batch returns — it lags the batch and
+     * would miss a same-batch colliding pair. The synchronously-maintained
+     * auto-index is exact.
+     */
     private findIndexForConstraint;
     private checkUniqueViaIndex;
+    /**
+     * Enforce a UNIQUE constraint through its linked `row-time` covering MV's backing
+     * table (mirrors {@link checkUniqueViaIndex}, but the candidates come from the MV
+     * rather than a secondary BTree). The backing scan yields candidate conflicting
+     * source PKs; each is *validated against the live source row* before acting, since
+     * a backing entry can lag a source row deleted/updated internally within the same
+     * statement (e.g. the PK-changing-UPDATE delete below, or a prior REPLACE eviction)
+     * — the row-time hook only fires for DML-executor row writes, not these internal
+     * mutations. A candidate whose source row is gone or no longer matches the UC is
+     * stale and skipped, so a false conflict is never raised.
+     *
+     * On a REPLACE eviction the conflicting **source** row is deleted directly on the
+     * transaction layer and pushed onto `evicted`; the DML executor then runs the full
+     * delete pipeline for it (change-tracking, FK cascade, auto-events, and the
+     * row-time covering-structure maintenance that removes the evicted row's backing
+     * entry — so a later same-UC row in the statement never sees a phantom). The
+     * executor processes the eviction before the writing row's own bookkeeping, so the
+     * backing delete still lands within this statement.
+     */
+    private checkUniqueViaMaterializedView;
     private checkUniqueByScanning;
     renameTable(newName: string): void;
     /** Iterates all committed rows from the current committed layer (for rebuild). */
@@ -102,7 +227,101 @@ export declare class MemoryTableManager {
     /** Inserts a row directly into the base layer (for rebuild, bypasses transaction).
      *  Throws on duplicate primary key. */
     insertRow(row: Row): void;
-    addColumn(columnDefAst: ASTColumnDef): Promise<void>;
+    /**
+     * Atomically replaces the entire committed contents with `rows` by building a
+     * fresh {@link BaseLayer} and swapping it in under the SchemaChange latch.
+     * Used to (re)materialize a materialized view: callers run the view body to
+     * completion and hand the result rows here. Concurrent readers do NOT block:
+     * each scan reads a base-layer snapshot captured at start-of-call, so an
+     * in-flight scan keeps the pre-swap base while a fresh scan sees the new base
+     * — never a partial state. The swap itself is a single synchronous assignment
+     * performed under the SchemaChange latch (which serializes swaps with `alter
+     * table` and other refreshes, not with readers).
+     *
+     * Throws on a duplicate primary key among `rows` (the caller rolls back).
+     * Callers may pass `onDuplicateKey` to substitute a purpose-built diagnostic
+     * for the duplicate-PK case (e.g. the materialized-view "must be a set"
+     * message); when omitted, the generic backing-table message is thrown. The
+     * factory only controls the wording — duplicate detection still uses the
+     * btree's collation/desc/composite-correct key comparison.
+     */
+    replaceBaseLayer(rows: readonly Row[], onDuplicateKey?: () => QuereusError): Promise<void>;
+    /**
+     * Privileged **transactional** maintenance write: apply an ordered
+     * {@link MaintenanceOp} batch to a given connection's *pending*
+     * {@link TransactionLayer} (creating it lazily, exactly as a user write would).
+     * The row-time materialized-view maintenance path uses it so a covering
+     * structure's backing table is kept consistent synchronously with each source
+     * row-write — within the same transaction, visible to later reads on this
+     * connection (reads-own-writes), and committed/rolled-back in lockstep with the
+     * source write by the Database's coordinated commit.
+     *
+     * It deliberately bypasses {@link validateMutationPermissions} (which throws
+     * READONLY for MV backing tables) and reuses {@link TransactionLayer.recordUpsert} /
+     * {@link TransactionLayer.recordDelete} so secondary-index and change-tracking
+     * bookkeeping stay correct. No latch is taken: the pending layer is private to
+     * `connection`, only this synchronous path writes it, and the tree mutations are
+     * synchronous — so a multi-row statement's later rows observe earlier rows'
+     * pending writes with no interleaving.
+     *
+     * Declared secondary UNIQUE constraints ARE enforced — post-batch, against the
+     * final effective contents, throwing the maintained-table-attributed
+     * CONSTRAINT error ({@link enforceSecondaryUniqueOnMaintenance}). CHECK / FK
+     * stay engine-validated (see `vtab/backing-host.ts` § Constraint validation).
+     *
+     * Returns the **effective** changes it applied (one {@link BackingRowChange} per
+     * backing row it mutated): a `delete-key` that found a row → `delete`; an `upsert` →
+     * `update` when it replaced an existing row, else `insert`; a `delete-by-prefix` →
+     * one `delete` per matched row; a `replace-all` → the minimal keyed diff between the
+     * new and old contents (insert/update/delete, identical rows skipped). A
+     * `delete-key`/`delete-by-prefix` that matches nothing, an `upsert` whose row is
+     * **value-identical** to the effective existing row (`rowsValueIdentical` — written
+     * nothing, reported nothing; the normative skip in `vtab/backing-host.ts`), or a
+     * `replace-all` whose new contents equal the old — produces nothing. The MV-over-MV
+     * cascade feeds these onward to MVs reading this backing table (see
+     * `database-materialized-views.ts` § cascade).
+     *
+     * Async only because `delete-by-prefix` / `replace-all` reuse the async layer scan to
+     * enumerate the affected (prefix / whole-table) slice; the point ops stay synchronous
+     * within the same pass, so a multi-row statement's later rows still observe earlier
+     * rows' pending writes with no interleaving (no await separates a single op's lookup
+     * from its record).
+     */
+    applyMaintenanceToLayer(connection: MemoryTableConnection, ops: readonly MaintenanceOp[]): Promise<BackingRowChange[]>;
+    /**
+     * Declared secondary-UNIQUE enforcement for maintenance writes — the
+     * collision-shaped half of the derived-row constraint contract (CHECK / FK
+     * are per-row properties and validate engine-side; see
+     * docs/materialized-views.md § Derived-row constraint validation). The
+     * privileged surface bypasses the DML constraint pipeline, so without this
+     * the batch above would store two derived rows colliding on a declared
+     * UNIQUE silently.
+     *
+     * Runs POST-batch over the effective changes, never per-op: a `replace-all`
+     * diff applies its upserts before its deletes, so an in-flight per-op check
+     * would false-positive against a row the same batch is about to delete
+     * (e.g. the derived set moved a unique value from one primary key to
+     * another). After the batch the layer holds exactly the final contents, so
+     * checking each WRITTEN image against it is exact — and complete: every
+     * pre-existing row entered through DML / ADD CONSTRAINT / earlier validated
+     * maintenance, so any colliding pair includes at least one written image.
+     * A value-identical upsert the batch skipped emitted no change and cannot
+     * introduce a collision (the table's contents did not change at that key).
+     *
+     * Reuses {@link checkSingleUniqueConstraint} (same-PK exclusion, NULL-pass,
+     * partial-predicate scope, per-column collation, auto-index fast path) with
+     * two maintenance-specific postures: the conflict action is forced to ABORT
+     * (a derivation write carries no user OR clause, and a declared
+     * `on conflict replace`/`ignore` default must not silently evict or drop
+     * derived rows — the eviction would diverge the table from its derivation),
+     * and the covering-MV route is bypassed (see
+     * {@link findIndexForConstraint}'s `allowMvCovering`).
+     *
+     * Zero overhead when the table declares no secondary UNIQUE (every MV-sugar
+     * backing, and most maintained tables): one empty-array check.
+     */
+    private enforceSecondaryUniqueOnMaintenance;
+    addColumn(columnDefAst: ASTColumnDef, backfillEvaluator?: (row: Row) => SqlValue | Promise<SqlValue>): Promise<void>;
     dropColumn(columnName: string): Promise<void>;
     renameColumn(oldName: string, newColumnDefAst: ASTColumnDef): Promise<void>;
     /**
@@ -115,11 +334,79 @@ export declare class MemoryTableManager {
         setNotNull?: boolean;
         setDataType?: string;
         setDefault?: Expression | null;
+        setCollation?: string;
     }): Promise<void>;
     createIndex(newIndexSchemaEntry: IndexSchema, ifNotExistsFromAst?: boolean): Promise<void>;
     dropIndex(indexName: string, ifExists?: boolean): Promise<void>;
+    /**
+     * Drops a named table-level constraint (CHECK / UNIQUE / FOREIGN KEY). Schema-
+     * only — constraints don't change row shape — except that dropping a UNIQUE
+     * also tears down the implicit covering index (the auto-built secondary BTree
+     * named `uc.name ?? '_uc_<cols>'`) so introspection / the declarative differ
+     * don't observe an orphaned index. The class is resolved here (NOTFOUND /
+     * ambiguous), so the engine can route through `module.alterTable` uniformly.
+     */
+    dropConstraint(constraintName: string): Promise<void>;
+    /**
+     * Renames a named table-level constraint. Schema-only, with one caveat: a
+     * UNIQUE whose implicit covering index is named after the constraint has that
+     * index renamed in lock-step (so the index stays recognized as the
+     * constraint's covering structure rather than surfacing as an orphan).
+     */
+    renameConstraint(oldName: string, newName: string): Promise<void>;
+    /**
+     * Adds a table-level UNIQUE or FOREIGN KEY constraint to an existing table,
+     * re-validating the current rows against it and failing atomically with
+     * `CONSTRAINT` (no schema mutation) when the data violates it. Mirrors the
+     * latch + `ensureSchemaChangeSafety()` + snapshot/restore scaffolding of
+     * {@link createIndex} / {@link dropConstraint}.
+     *
+     * - UNIQUE builds (or reuses) the implicit covering secondary index; the build
+     *   raises `CONSTRAINT` on the first duplicate among in-scope rows (partial
+     *   predicate + per-column collation honored, NULLs distinct).
+     * - FOREIGN KEY appends the constraint and runs the pragma-gated existing-row
+     *   validation (engine-side enforcement needs no physical structure).
+     * - CHECK appends the constraint (no physical structure, no existing-row scan —
+     *   matching the engine's prior in-emitter behavior); it routes here, rather than
+     *   being applied catalog-only, so the module-cached schema stays in lock-step
+     *   with the catalog and a later `DROP/RENAME CONSTRAINT` resolves it. (The engine
+     *   keeps an engine-side fallback in `runtime/emit/add-constraint.ts` only for
+     *   modules that omit `alterTable` — which cannot DROP/RENAME a constraint anyway.)
+     */
+    addConstraint(constraint: ASTTableConstraint): Promise<void>;
+    /**
+     * CHECK arm of {@link addConstraint}. Schema-only: a CHECK has no covering
+     * structure and (matching the engine's prior in-emitter behavior) no existing-row
+     * validation, so this just appends the constraint to the cached schema. Enforcement
+     * is engine-side at INSERT/UPDATE plan time. Runs under the same latch / rollback
+     * scaffolding as the other arms (via {@link addConstraint}).
+     */
+    private addCheckConstraint;
+    /**
+     * UNIQUE arm of {@link addConstraint}. Builds the covering secondary index the
+     * same way {@link ensureUniqueConstraintIndexes} does (validating existing rows
+     * via `addIndexToBase` → `populateNewIndex`), unless an existing *unique* index
+     * already covers the exact columns — in which case the data is already
+     * validated and we only register the covering structure.
+     */
+    private addUniqueConstraint;
+    /**
+     * FOREIGN KEY arm of {@link addConstraint}. Validates existing child rows
+     * against the new FK (pragma-gated; throws CONSTRAINT on an orphan), then
+     * appends it to the cached schema. No physical structure — FK enforcement is
+     * engine-side (synthesized EXISTS checks at plan time).
+     */
+    private addForeignKeyConstraint;
     destroy(): Promise<void>;
     private ensureSchemaChangeSafety;
+    /**
+     * Re-point every Database-registered {@link MemoryTableConnection} backed by this
+     * manager (including ones detached from {@link connections}) at the current base layer,
+     * when it carries no uncommitted pending layer. Companion to the `connections`-map sweep
+     * in {@link ensureSchemaChangeSafety}: it closes the gap for a connection that lives in
+     * the Database registry but not in the manager's map.
+     */
+    private repointRegisteredConnections;
     /** Consolidates all transaction data into the base layer for schema changes */
     private consolidateToBaseLayer;
     /** Copies all data from a transaction layer to the base layer */

package/dist/src/vtab/memory/layer/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../src/vtab/memory/layer/manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../../src/vtab/memory/layer/manager.ts"],"names":[],"mappings":"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"}