@quereus/quereus 4.4.1 → 4.6.0

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

@@ -9,11 +9,11 @@ import { ConflictResolution } from '../../../common/constants.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 { MemoryIndex } from '../index.js';
 import type { MaintainedTableSchema } from '../../../schema/derivation.js';
 import type { MaintenanceOp, BackingRowChange } from '../../backing-host.js';
 import type { EffectiveRowSource } from '../../module.js';
+import { type AlterColumnChange } from './alter-column.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
@@ -105,8 +105,44 @@ export declare class MemoryTableManager {
      * {@link ImplicitCoveringStructure.indexName}.
      */
     getImplicitCoveringStructure(uc: UniqueConstraintSchema): ImplicitCoveringStructure | undefined;
-    /** Conventional auto-index name for an unnamed UNIQUE constraint (mirrors {@link ensureUniqueConstraintIndexes}). */
+    /** Conventional auto-index name for an unnamed UNIQUE constraint, over the LIVE columns. */
     private implicitIndexNameFor;
+    /**
+     * The materialized covering-index renames a column rename forces: one per UNNAMED
+     * UNIQUE constraint covering the renamed column, from its `_uc_<old cols>` name to
+     * its `_uc_<new cols>` one.
+     *
+     * The auto-name is derived from the live column names and recomputed by every
+     * consumer ({@link implicitIndexNameFor} here, the catalog's exposure map behind
+     * `schema()` / `index_info()`), so leaving the entry under its pre-rename name
+     * severs the constraint↔structure link: the structure stops being recognized as
+     * hidden (it surfaces as a user index and becomes droppable, taking the
+     * constraint's enforcement structure with it) and
+     * {@link getImplicitCoveringStructure} falls through to its column-set fallback.
+     *
+     * Skipped for constraints that do not move: a NAMED one's structure takes the
+     * constraint's name, a `derivedFromIndex` one IS the user's index, and one realized
+     * by a REUSED user index has no `_uc_*` entry to rename (that index keeps its own
+     * name).
+     *
+     * A case-only column rename DOES produce a rename here, even though every name
+     * comparison folds case: the covering-structure map is keyed by the exact derived
+     * string, so leaving `_uc_a` in place while consumers derive `_uc_A` would break
+     * {@link getImplicitCoveringStructure} the same way. It cannot collide — an index
+     * named `_uc_A` could never have been created alongside `_uc_a` in the first place.
+     *
+     * Pure — the caller applies the result to the new index list and, once the schema
+     * swap has succeeded, to {@link implicitCoveringStructures}.
+     */
+    private planImplicitCoveringIndexRenames;
+    /**
+     * Re-keys {@link implicitCoveringStructures} for the renames
+     * {@link planImplicitCoveringIndexRenames} produced — the map is keyed by
+     * constraint identity, which for an unnamed constraint IS the derived index name.
+     * Runs only after the schema swap succeeded, so a failed rename leaves the map
+     * agreeing with the restored schema.
+     */
+    private applyImplicitCoveringStructureRenames;
     /**
      * True when a same-column-set index's per-column collations are
      * collation-equivalent to the constraint's DECLARED column collations.
@@ -154,6 +190,18 @@ export declare class MemoryTableManager {
     connect(): MemoryTableConnection;
     disconnect(connectionId: number): Promise<void>;
     commitTransaction(connection: MemoryTableConnection): Promise<void>;
+    /**
+     * The delivered `key` of one pending change: the primary key projected out of the change's
+     * own row image (`newRow` for an insert or an update, `oldRow` for a delete) through
+     * `pkIndices`, the key columns of the schema current at delivery.
+     *
+     * Best-effort, exactly like the pending-change image reshape it consumes: an image the
+     * reshape had to leave at the retired arity cannot be projected, so the event ships with no
+     * key and logs rather than emitting an `undefined` key slot a listener would file a row
+     * under. (A `PendingChange` always carries at least one image — `recordUpsert` sets
+     * `newRow`, `recordDelete` sets `oldRow` — so a missing image means only that.)
+     */
+    private eventKeyFromImage;
     /** All layers in `layer`'s parent chain, including `layer` itself. */
     private layerChainSet;
     /**
@@ -255,11 +303,6 @@ export declare class MemoryTableManager {
     private checkUniqueViaMaterializedView;
     private checkUniqueByScanning;
     renameTable(newName: string): void;
-    /** Iterates all committed rows from the current committed layer (for rebuild). */
-    scanAllRows(): Row[];
-    /** Inserts a row directly into the base layer (for rebuild, bypasses transaction).
-     *  Throws on duplicate primary key. */
-    insertRow(row: Row): void;
     /**
      * Atomically replaces the entire committed contents with `rows` by building a
      * fresh {@link BaseLayer} and swapping it in under the SchemaChange latch.
@@ -366,17 +409,128 @@ export declare class MemoryTableManager {
     dropColumn(columnName: string): Promise<void>;
     renameColumn(oldName: string, newColumnDefAst: ASTColumnDef): Promise<void>;
     /**
-     * Apply a single-attribute ALTER COLUMN change (NOT NULL, DEFAULT, DATA TYPE).
+     * Apply a single-attribute ALTER COLUMN change (NOT NULL, DEFAULT, DATA TYPE, COLLATE).
      * The caller supplies exactly one populated change; multi-attribute combinations
      * are rejected by the runtime before reaching this method.
-     */
-    alterColumn(change: {
-        columnName: string;
-        setNotNull?: boolean;
-        setDataType?: string;
-        setDefault?: Expression | null;
-        setCollation?: string;
-    }, rows?: EffectiveRowSource): Promise<void>;
+     *
+     * The body is the ordering contract, and only that: resolve the column → decide the change
+     * and pre-validate it (`alter-column.ts`, which mutates nothing) → probe the re-keyed
+     * structures ({@link validateAlterColumnPlan}) → rebuild the base
+     * ({@link applyAlterColumnToBase}, the first write) → swap this manager's schema →
+     * propagate to open layers ({@link propagateAlterColumnToOpenLayers}) → emit. Each step's
+     * own reasoning lives on the step.
+     *
+     * `validateOnly` runs everything up to (and including) the pre-mutation validation
+     * passes — the effective-row NULL / conversion scans, the re-keyed UNIQUE probe, and
+     * the primary-key re-key legality/representability passes — and returns before the
+     * first mutation, throwing exactly what the real application would throw. The
+     * isolation layer uses it to pre-flight an overlay's migration before the shared
+     * underlying table mutates irreversibly (see `VirtualTable.alterSchema`).
+     */
+    alterColumn(change: AlterColumnChange, rows?: EffectiveRowSource, validateOnly?: boolean): Promise<void>;
+    /**
+     * Apply `alter table … alter primary key` in place — the table's rows, the open
+     * transaction's pending writes, and its pending change events all survive under the new
+     * key. Follows {@link alterColumn}'s ordering contract: resolve and pre-validate the new
+     * definition (mutating nothing) → probe the re-keyed primary structures
+     * ({@link validateRekeyedPrimaryKey}, the same pass the `set collate` re-key runs) →
+     * rebuild the base → swap this manager's schema → propagate to the open transaction's
+     * layers → emit. What differs from the `set collate` re-key is WHAT moves: the key's
+     * columns rather than its comparator, so each open layer's net deletions and its pending
+     * event log must be re-derived from row images — a two-phase prepare/install pair
+     * ({@link TransactionLayer.prepareRekeyedPrimaryKeyColumns}), with every prepare running
+     * BEFORE the first mutation because a deletion's image resolves only through the intact
+     * old layer chain.
+     *
+     * `validateOnly` runs everything up to (and including) the pre-mutation validation and
+     * returns before the first mutation, throwing exactly what the real application would
+     * throw — the same dry-run contract as {@link alterColumn}'s, for a wrapper (the
+     * isolation layer) that must pre-flight before a shared underlying mutates irreversibly.
+     */
+    alterPrimaryKey(newPkColumns: ReadonlyArray<{
+        index: number;
+        desc?: boolean;
+    }>, rows?: EffectiveRowSource, validateOnly?: boolean): Promise<void>;
+    /**
+     * Resolve `alter primary key`'s column list against the current schema — bounds, no
+     * duplicates, every member NOT NULL — and return the re-keyed schema. The engine's
+     * emitter validates the same three by column NAME before dispatch; re-checking by index
+     * here keeps a wrapper driving the module API directly (the isolation layer) from
+     * installing an unkeyable definition. The schema construction itself (definition +
+     * per-column flag rebuild, member collations carried) is delegated to the shared
+     * {@link rekeySchemaPrimaryKey}, which the store's native arm uses too.
+     */
+    private buildRekeyedPrimaryKeySchema;
+    /**
+     * The re-keyed-structure pre-pass for {@link alterColumn}, over the DDL transaction's EFFECTIVE
+     * rows: a pair the transaction inserted that collides under the NEW schema must reject the
+     * change, and one it has deleted must not block it. Runs before any mutation, so a throw leaves
+     * the schema, the base layer and the index map exactly as they were.
+     *
+     * A value-REWRITING change (`set data type`, or a `set not null` null → DEFAULT backfill) probes
+     * the CONVERTED rows — the same per-row conversion the base rewrite applies — under the NEW
+     * schema's comparators, so one call covers both ways an ALTER can collapse two previously-distinct
+     * rows: the VALUES converge (`'1'`/`'01'` → 1; two NULLs → one DEFAULT;
+     * '2024-06-05T00:00:00Z' → '2024-06-05') and/or the COMPARATOR moves (text → timespan makes
+     * 'PT1H'/'PT60M' one value). A same-storage-class retype sets both `rewrite` and
+     * `structuresRekeyed`, so the rewrite arm is tested FIRST — its converted-row probe subsumes the
+     * comparator-only one. The rebuild that follows is deliberately non-enforcing, so this is the
+     * only guard.
+     *
+     * The comparator-MOVING arm without a rewrite has one trigger left: `set collate`. The values are
+     * untouched — hence no `mapRow` — and only the comparator the structures are keyed by moves.
+     * `newSchema` carries the new collations, so the probe indexes compare as the rebuilt ones will.
+     *
+     * The primary key: `set collate` on a PK member gets a stricter pre-pass
+     * ({@link validateRekeyedPrimaryKey}): no layer in the chain, base included, may hold a collision.
+     * That is what lets every apply step succeed unconditionally, and what
+     * `TransactionLayer.rekeyPrimaryKey` relies on. The rewrite arm needs no PK pre-pass and cannot
+     * shadow one: a retype of a PK column is rejected upstream, the backfill only fires on a column
+     * holding NULLs (which a PK member cannot — the engine enforces NOT NULL on every PK member
+     * regardless of the declared nullability), and `pkColumnRekeyed` is set only by `set collate`,
+     * which never sets `rewrite` — so whenever `pkColumnRekeyed` is true, the `structuresRekeyed` arm
+     * still runs.
+     * NOTE: if PK members ever become genuinely nullable, the backfill arm gains a PK collision path
+     * (two NULL keys → one DEFAULT) and needs `validateRekeyedPrimaryKey` plus a primary-tree re-key
+     * of its own.
+     */
+    private validateAlterColumnPlan;
+    /**
+     * First mutation of {@link alterColumn}: install the new schema on the base layer and rebuild its
+     * structures under it — each MemoryIndex rebuilds its comparator from the CURRENT schema's
+     * collation and logical type. The secondary rebuilds are NON-enforcing ({@link validateAlterColumnPlan}
+     * owns uniqueness, and the base's rows are not a subset of the effective rows); the `set collate`
+     * PK rebuild is strict, since a PK collision cannot be represented at all — the pre-pass has
+     * already proved the base collision-free, so the strict rebuild is a live invariant check, not
+     * the enforcement path. It runs LAST so its throw leaves the live tree intact for the rollback.
+     *
+     * Records the primary tree it is about to REPLACE in `undo` *before* replacing it, so a throw
+     * from either rebuild still leaves the caller's `catch` a tree to restore.
+     */
+    private applyAlterColumnToBase;
+    /**
+     * Hand the post-{@link alterColumn} schema to the DDL transaction's own open layers.
+     *
+     * The base rebuild handed every secondary index a fresh tree under the new comparator; those
+     * layers still inherit the old ones and froze the old schema at construction. Re-key them, or
+     * the rest of the transaction — and everything after the pending layer becomes the committed
+     * head at commit — keeps comparing under the old collation / old logical type.
+     *
+     * When the altered column is part of the primary key, `rebuildPrimaryTreeStrict` also swapped the
+     * base primary tree object out from under those layers' copy-on-write bases and invalidated their
+     * `pkFunctions`; `rekeyPrimaryKey` rebuilds both, plus every secondary index (each derives its PK
+     * comparator/encoder from the PK definition). Outside a transaction there are no open layers and
+     * every arm is a no-op.
+     */
+    private propagateAlterColumnToOpenLayers;
+    /**
+     * The rows the `alter column` pre-validation scans judge: `rows` when a wrapper module supplies
+     * them (the isolation overlay holds the transaction's pending rows outside this manager, so only
+     * it can name the rows the issuing connection actually sees), else this manager's own layered
+     * view ({@link effectiveDdlRows}) — which stays a SYNC iterable on purpose, so a scan over it
+     * cannot be interleaved with another connection's write. See `scanEffectiveRows`.
+     */
+    private effectiveRowSource;
     createIndex(newIndexSchemaEntry: IndexSchema, ifNotExistsFromAst?: boolean, rows?: EffectiveRowSource): Promise<void>;
     dropIndex(indexName: string, ifExists?: boolean): Promise<void>;
     /**
@@ -553,24 +707,41 @@ export declare class MemoryTableManager {
      */
     private validateRekeyedUniqueStructures;
     /**
-     * PRIMARY KEY arm of the `alter column … set collate` pre-pass. Runs before anything is
-     * mutated, so a rejection leaves the table, the schema and the transaction untouched.
-     *
-     * The primary tree is a map, not a multi-map, so — unlike a secondary index — it cannot
-     * physically hold two rows whose keys collapse under the new comparator. Every layer the
-     * DDL connection still reads through therefore has to be collision-free, not just the
-     * transaction's effective view:
-     *
-     *  1. **The effective view collides** → `CONSTRAINT`. The duplicate is visible to a `select`
-     *     in this transaction; the change is simply illegal.
-     *  2. **A layer beneath it collides** → `BUSY`. Those rows are not visible now, but every
-     *     such layer is the copy-on-write base the view reads through, and one of them may be a
-     *     savepoint snapshot a `rollback to savepoint` must restore. A re-keyed tree could not
-     *     represent the pair at all. Committing (or rolling back) settles the transaction and
-     *     the ALTER can be retried — the same "commit/rollback and retry" posture as
-     *     {@link ensureSchemaChangeSafety}.
-     *
-     * Case 2 is deliberately conservative. The chain holds one immutable layer per statement
+     * The primary-key re-key pre-pass, shared by both statements that move the key:
+     * `alter column … set collate` on a PK member (the comparator moves) and
+     * `alter table … alter primary key` (the key columns move — {@link alterPrimaryKey}).
+     * Runs before anything is mutated, so a rejection leaves the table, the schema and the
+     * transaction untouched.
+     *
+     * Asks two questions, in order, over two DIFFERENT row sets:
+     *
+     *  1. **Is the change legal at all?** — probes the rows the DDL transaction can SEE: the
+     *     wrapper-supplied `rows` when a wrapper module (the isolation layer) holds the
+     *     transaction's pending rows outside this manager, otherwise this manager's own
+     *     layered view ({@link effectiveDdlRows}). A duplicate here is visible to a `select`
+     *     in this transaction, so the change is simply illegal → `CONSTRAINT`, naming the
+     *     colliding key.
+     *  2. **Can the structures physically carry it?** — probes every layer of this manager's
+     *     own chain. The primary tree is a map, not a multi-map, so — unlike a secondary
+     *     index — no tree that a `rollback` / `rollback to savepoint` could restore may hold
+     *     two rows whose keys collapse under the new comparator. A collision confined to
+     *     committed rows the transaction has DELETED is therefore refused by physical
+     *     necessity, not because the data is invalid: the base must keep both rows for a
+     *     rollback, and a base re-keyed under the new collation could not represent the pair
+     *     at all → `BUSY` with the same "commit/rollback and retry" posture as
+     *     {@link ensureSchemaChangeSafety}. The persistent store backend asks the same two
+     *     questions with the same statuses (`StoreTable.validateRekeyedPrimaryKey` in
+     *     quereus-store — its committed rows equally survive a rollback); accepting the
+     *     deleted-collider shape instead would take transaction-scoped DDL
+     *     (`backlog/feat-transactional-ddl-native-backends`), which Quereus does not have.
+     *
+     * The passes judge different sets because a wrapper's effective stream and this manager's
+     * layers genuinely diverge: staged inserts exist only in the stream, deleted committed
+     * rows only in the layers. When `rows` is supplied, the view layer holds the COMMITTED
+     * rows — not a subset of what pass 1 judged — so pass 2 starts AT the view; when `rows`
+     * is absent, pass 1 judged exactly the view's rows and pass 2 starts at its parent.
+     *
+     * Pass 2 is deliberately conservative. The chain holds one immutable layer per statement
      * boundary (see `MemoryTableConnection.createSavepoint`'s eager path), so it rejects any
      * transaction that has held a colliding pair at ANY statement boundary — even one whose
      * final view is clean and whose intermediate layer no savepoint can reach. Narrowing that
@@ -578,20 +749,42 @@ export declare class MemoryTableManager {
      * rebase that savepoint snapshots exist to avoid. The tradeoff is a rare false BUSY on a
      * statement sequence the user can retry after committing, versus losing a row on rollback.
      *
-     * This precondition is also what makes `TransactionLayer.rekeyPrimaryKey`'s replay sound:
-     * with no collisions anywhere in the chain, every primary key resolves to at most one row
-     * in each layer under the new comparator.
+     * This precondition is also what makes the open-layer replays sound — both
+     * `TransactionLayer.rekeyPrimaryKey`'s and `installRekeyedPrimaryKeyColumns`'s: with no
+     * collisions anywhere in the chain, every primary key resolves to at most one row in
+     * each layer under the new definition.
      */
     private validateRekeyedPrimaryKey;
     /**
-     * Raises `code` when two of `layer`'s rows share a primary key under `pkFunctions`.
+     * A duplicate-key detector over the new primary key functions: feed it rows, and it returns
+     * the key the moment one repeats. Shared by both arms of {@link validateRekeyedPrimaryKey}
+     * so the async (effective-row) arm and the sync (layer-tree) arm cannot disagree about what
+     * counts as a collision.
+     *
+     * NOTE: the probe holds every row it has seen, because the BTree derives its key from the
+     * stored value — so an ALTER over a large table transiently doubles that table's row
+     * references. If a wide table ever makes this the memory peak, key the probe by the PK
+     * encoding (`primaryKeyFunctions.encode`) into a `Set` instead of by the row.
+     */
+    private makePrimaryKeyProbe;
+    /**
+     * Legality arm of {@link validateRekeyedPrimaryKey}: raises `CONSTRAINT`, naming the key,
+     * when two of the rows the DDL transaction can SEE share a primary key under `pkFunctions`.
+     * Takes a wrapper's merged async stream or this manager's own synchronous layered view.
+     */
+    private assertNoPrimaryKeyCollisionInRows;
+    /**
+     * Representability arm of {@link validateRekeyedPrimaryKey}: raises `BUSY` when two of
+     * `layer`'s physical rows share a primary key under `pkFunctions`. Its rows are ones a
+     * rollback could restore, not ones the transaction can see, so this is never a statement
+     * about the data's validity — hence the retryable status and wording.
      *
      * NOTE: O(rows) per layer, so O(layers × rows) for a whole chain — one more full pass than
      * the base rebuild the caller is about to do anyway. Fine for a statement this rare; if a
      * deep savepoint stack over a large table ever makes an ALTER slow, note that a layer's rows
      * differ from its parent's only at the keys it wrote, so the walk can be narrowed to those.
      */
-    private assertNoPrimaryKeyCollision;
+    private assertNoPrimaryKeyCollisionInLayer;
     /**
      * Propagates a schema change — a new index and/or UNIQUE constraint, or a set of structures
      * re-keyed by `alter column … set collate` — into every {@link TransactionLayer} the DDL

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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"}