@quereus/quereus 4.4.0 → 4.5.0

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

@@ -8,7 +8,7 @@ import type { CollationResolver } from '../../../types/logical-type.js';
 /**
  * Pending change for event emission.
  */
-interface PendingChange {
+export interface PendingChange {
     type: 'insert' | 'update' | 'delete';
     pk: BTreeKeyForPrimary;
     oldRow?: Row;
@@ -27,6 +27,25 @@ export interface OwnWrite {
     /** New row for an upsert; absent for a delete. */
     newRow?: Row;
 }
+/**
+ * One layer's net own-writes at the post-ADD/DROP-COLUMN arity, computed fallibly by
+ * {@link TransactionLayer.prepareReshapedColumns} and installed infallibly by
+ * {@link TransactionLayer.installReshapedColumns} — see those methods for why the
+ * two phases are split.
+ */
+export interface PreparedColumnReshape {
+    /** Keys this layer's net effect deletes. Key values are invariant under a column-set change. */
+    survivingDeletions: BTreeKeyForPrimary[];
+    /** This layer's net effective rows, rewritten to the new column set. */
+    upserts: Row[];
+    /**
+     * The layer's {@link PendingChange} event log with every row image rewritten to the
+     * new column set, or null when change tracking is disabled. Unlike the own-write
+     * collapse above, the log is NOT deduplicated — every recorded write stays a
+     * separate event, because that is the delivered contract.
+     */
+    reshapedPendingChanges: PendingChange[] | null;
+}
 /**
  * Represents a set of modifications (inserts, updates, deletes) applied
  * on top of a parent Layer using inherited BTrees with copy-on-write semantics.
@@ -46,8 +65,10 @@ export declare class TransactionLayer implements Layer {
      * Schema when this layer was started. Replaced when DDL runs inside this layer's own
      * transaction: by {@link adoptSchema} for additive index/constraint DDL, a secondary-index
      * re-key from `alter column … set collate`, and index/constraint removal (`drop index` /
-     * `drop constraint`), and by {@link rekeyPrimaryKey} when that collate change lands on a
-     * primary-key column. The column set is identical across every such swap.
+     * `drop constraint`); by {@link rekeyPrimaryKey} when that collate change lands on a
+     * primary-key column; and by {@link installReshapedColumns} when `add column` / `drop
+     * column` changes the column set itself. Every swap except the last keeps the column set
+     * identical.
      */
     private tableSchemaAtCreation;
     /**
@@ -78,12 +99,17 @@ export declare class TransactionLayer implements Layer {
      *    `IndexSchema` (so an index scan raises "Secondary index not found") nor the derived
      *    `uniqueConstraints` entry (so `checkUniqueConstraints` silently skips it and a
      *    colliding insert is accepted).
-     *  - **Re-keying** (`alter column … set collate`): an index whose `IndexSchema` object
-     *    is no longer the one this layer holds is REPLACED. `BaseLayer.rebuildAllSecondaryIndexes`
-     *    hands every index a fresh BTree under the new collation, so a layer that kept its old
-     *    `MemoryIndex` would go on comparing under the old collation over an orphaned tree —
-     *    and, once it becomes the committed head at commit, would shadow the base's rebuilt
-     *    structures entirely.
+     *  - **Re-keying** (`alter column … set collate`, or an `alter column … set data type` that
+     *    keeps the physical storage class but moves to a differently-ordering logical type —
+     *    text ↔ timespan, where 'PT1H' and 'PT60M' are one value): an index whose `IndexSchema`
+     *    object is no longer the one this layer holds is REPLACED.
+     *    `BaseLayer.rebuildAllSecondaryIndexes` hands every index a fresh BTree under the new
+     *    comparator, so a layer that kept its old `MemoryIndex` would go on comparing the old way
+     *    over an orphaned tree — and, once it becomes the committed head at commit, would shadow
+     *    the base's rebuilt structures entirely. The retype has no index-column field to change
+     *    (an index column carries no logical type; it reads the column's), so
+     *    `MemoryTableManager.alterColumn` rebuilds the `IndexSchema` objects purely to raise this
+     *    signal — see its `structuresRekeyed` branch.
      *  - **Removal** (`drop index` / `drop constraint`): an index whose name the new schema no
      *    longer declares is DROPPED from {@link secondaryIndexes}. Without it the layer keeps the
      *    derived `uniqueConstraints` entry in its frozen schema and goes on enforcing a constraint
@@ -104,8 +130,10 @@ export declare class TransactionLayer implements Layer {
      *
      * Never applied to a column-set or primary-key change: either would invalidate
      * {@link pkFunctions} and the primary tree. A PK-column collation change goes to
-     * {@link rekeyPrimaryKey} instead, and `ensureSchemaChangeSafety` raises BUSY when any
-     * connection other than the DDL issuer holds a pending layer.
+     * {@link rekeyPrimaryKey} instead, a column-set change (`add column` / `drop column`) to
+     * {@link prepareReshapedColumns} / {@link installReshapedColumns}, and
+     * `ensureSchemaChangeSafety` raises BUSY when any connection other than the DDL issuer
+     * holds a pending layer.
      */
     adoptSchema(newSchema: TableSchema): void;
     /**
@@ -137,14 +165,48 @@ export declare class TransactionLayer implements Layer {
      * in the parent, so a deletion removes exactly the row this layer removed and an upsert
      * lands at exactly one key.
      *
-     * NOTE: the deletion replay assumes a key this layer deleted was a key the PARENT held.
-     * That holds because every DML operation gets its own layer (`MemoryTableConnection`'s
-     * statement savepoints), so no layer both creates and destroys a key. If a single layer
-     * ever does, `rekeyed.find(key)` can land on a *colliding* parent row and delete it: at
-     * that point the deletion needs to verify, under the OLD comparator, that the row it found
-     * is the row it removed.
+     * The deletion replay verifies, under the OLD comparator, that the row it finds is the row
+     * it removed (see {@link installNetOwnWrites}'s `deletionTargets`). Without that check a
+     * deletion whose old key collapses onto a DIFFERENT row's new key deletes that other row:
+     * stage an upsert at key `'a'` in one layer, delete the colliding `'A'` from a LATER layer,
+     * and the later layer's replayed deletion lands on the parent's `'a'` — silently removing
+     * the row the transaction just wrote. `validateRekeyedPrimaryKey`'s chain walk refuses any
+     * chain that holds a colliding pair before this method runs, which makes a cross-row land
+     * unreachable today — the verify is insurance, so the replay's own correctness does not
+     * hinge on that caller-side pass staying exactly as conservative as it is.
      */
     rekeyPrimaryKey(newSchema: TableSchema): void;
+    /**
+     * A fresh primary tree inheriting copy-on-write from the parent's CURRENT one, keyed by this
+     * layer's current {@link pkFunctions}. Callers must have installed the post-DDL `pkFunctions`
+     * first, and the parent must already carry the DDL (every whole-layer rebuild runs oldest-first).
+     */
+    private newPrimaryTreeOverParent;
+    /**
+     * Shared tail of the three whole-layer rebuilds — {@link rekeyPrimaryKey},
+     * {@link convertColumn}, {@link installReshapedColumns}. Each has already swapped in its new
+     * schema (and, where the key changed, its new {@link pkFunctions}) and collapsed
+     * {@link ownWrites} to the net per-key effect passed here; this replays that effect into a
+     * tree built over the parent's fresh one, installs it, rewrites the own-write log to match,
+     * and rebuilds every secondary index.
+     *
+     * Every index is rebuilt unconditionally, not only those over an altered column: each inherits
+     * the parent's freshly-rebuilt tree, and each index's key encoding and PK bookkeeping derive
+     * from `pkFunctions`.
+     *
+     * A deletion an upsert has since re-occupied is dropped from the log — keeping it would make
+     * the log claim both a deletion and an upsert of the same key. Only {@link rekeyPrimaryKey}
+     * can produce that collision (two old keys collapsing under the new comparator); where key
+     * values are invariant a key is classified as either a deletion or an upsert, never both, so
+     * the filter is a no-op.
+     *
+     * `deletionTargets` guards each deletion's replay: `find(key)` runs under the NEW comparator,
+     * so a re-key can land it on a colliding row this layer never removed — a row a PARENT layer
+     * upserted at what is now the same key. Only {@link rekeyPrimaryKey} passes it (an
+     * old-comparator identity check); the column-set/value rebuilds leave key values untouched,
+     * where find() can only land on the deleted key itself.
+     */
+    private installNetOwnWrites;
     /**
      * Adopts an `alter column … set data type` / `set not null` backfill conversion applied while
      * THIS layer's transaction is still open: swaps in the new schema and rewrites the CONVERTED value
@@ -154,11 +216,16 @@ export declare class TransactionLayer implements Layer {
      * layer, not the base.
      *
      * NON-primary-key column, or a key column whose bytes are unchanged. `MemoryTableManager.alterColumn`
-     * rejects a physical retype of a key column before any mutation, and SET NOT NULL leaves the key
+     * rejects any retype of a key column before any mutation, and SET NOT NULL leaves the key
      * bytes intact, so the primary key encoding is unchanged: {@link pkFunctions} and the primary tree
      * keep their keys, and only the value at `colIndex` moves. (Contrast {@link rekeyPrimaryKey}, which
      * must rebuild the tree because the keys themselves change.)
      *
+     * Subsumes {@link adoptSchema} for a same-storage-class retype that ALSO moves the comparator
+     * (text → date/timespan): `tableSchemaAtCreation` is swapped to `newSchema` and every secondary
+     * index is rebuilt from scratch against it below, so the layer's structures pick up the new
+     * comparators along with the converted values.
+     *
      * Like {@link adoptSchema} / {@link rekeyPrimaryKey}, the caller MUST apply this oldest-first
      * (base already converted): the layer's copy-on-write base inherits the parent's already-converted
      * rows, so only this layer's OWN writes are rewritten here.
@@ -175,6 +242,53 @@ export declare class TransactionLayer implements Layer {
      * double-fault a value the transaction cannot see. It matches the base rewrite's same-reasoned skip.
      */
     convertColumn(colIndex: number, convert: (v: SqlValue) => SqlValue, newSchema: TableSchema, convertNulls?: boolean): void;
+    /**
+     * Computes — without mutating anything — what {@link installReshapedColumns} will install
+     * for an `alter table … add column` / `drop column` applied while THIS layer's transaction
+     * is still open: the net per-key effect of the layer's own writes, with each surviving row
+     * run through `reshapeRow` to the new column set.
+     *
+     * Split from the install (unlike {@link convertColumn}, which mutates in one pass) because
+     * this rewrite can FAIL: an ADD COLUMN with a per-row `default (new.<col>)` expression
+     * evaluates that expression against each pending row, and it can throw — or produce NULL
+     * for a NOT NULL column — on a pending row even when every committed row backfilled cleanly.
+     * The rewrite is async for the same reason (`convertColumn`'s value map is a pure function;
+     * a backfill evaluator is engine-supplied and may await). `MemoryTableManager` therefore runs
+     * every prepare — one per open layer — BEFORE the first mutation anywhere (base included), so
+     * a failure rejects the whole ALTER with every structure untouched; there is no undo for a
+     * half-reshaped layer chain.
+     *
+     * Own writes collapse to one entry per key exactly as {@link convertColumn}'s pass does: a
+     * column-set change leaves every primary key VALUE untouched (ADD introduces a column no key
+     * reads — even when it is inserted ahead of one, which only renumbers the key's *indices*;
+     * dropping a PK column is rejected upstream), so a key is either finally-deleted or
+     * finally-upserted, never both, and no key can collapse onto another.
+     */
+    prepareReshapedColumns(reshapeRow: (row: Row) => Row | Promise<Row>, reshapeEventRow: (row: Row) => Row | Promise<Row>): Promise<PreparedColumnReshape>;
+    /**
+     * Adopts an `alter table … add column` / `drop column` applied while THIS layer's
+     * transaction is still open, installing what {@link prepareReshapedColumns} computed:
+     * swaps in the new schema, rebuilds the primary tree over the parent's already-reshaped
+     * one, replays the layer's net own-writes at the new arity, and rebuilds every secondary
+     * index. Synchronous and mutation-only — everything fallible ran in the prepare phase.
+     *
+     * {@link pkFunctions} is REBUILT (unlike {@link convertColumn}, which keeps it): a column-set
+     * change can shift the primary key's column *indices* — DROP COLUMN renumbers
+     * `primaryKeyDefinition` past the dropped slot, and an ADD COLUMN placed AHEAD of a key
+     * column (`insertAtIndex`, module-API only) renumbers it past the inserted slot — so the row
+     * extractor changes even though the key *values* do not. Because the values are invariant
+     * under both ADD (the new column is not part of any key, wherever it lands) and DROP
+     * (dropping a PK column is rejected upstream), tree ordering is preserved and the
+     * `primaryKey` values recorded in {@link ownWrites} stay valid — no re-key of the kind
+     * {@link rekeyPrimaryKey} performs is needed, and the prepared deletions apply verbatim.
+     *
+     * Like every other open-layer adoption, the caller MUST apply this to the whole parent
+     * chain oldest-first (base already reshaped): the rebuilt tree inherits copy-on-write from
+     * the parent's NEW tree, so the parent's must already hold rows at the new arity. The
+     * rewritten {@link ownWrites} log — carrying reshaped rows — is what the commit-time rebase
+     * and any later `create index` ({@link reindexOwnWrites}) replay.
+     */
+    installReshapedColumns(newSchema: TableSchema, prepared: PreparedColumnReshape): void;
     /**
      * Brings a newly-inherited `MemoryIndex` (built over the parent's tree, which
      * already covers the parent chain's effective rows) up to date with this layer's own
@@ -208,6 +322,16 @@ export declare class TransactionLayer implements Layer {
      * Get pending changes for event emission.
      */
     getPendingChanges(): readonly PendingChange[];
+    /**
+     * Drops the pending-change event log (tracking stays enabled). Called when this
+     * layer's content is drained into the base by ALTER's consolidation
+     * (`MemoryTableManager.consolidateToBaseLayer`): its events were already delivered
+     * when the layer originally committed, but the layer can remain in the DDL
+     * connection's open-transaction parent chain — and once the base becomes the
+     * committed head, the commit-time collection (`collectPendingChanges`) walks that
+     * chain all the way down to the base and would re-deliver them.
+     */
+    clearPendingChanges(): void;
     /** This layer's own structural writes, oldest-first — the rebase replay source. */
     getOwnWrites(): readonly OwnWrite[];
     getPkExtractorsAndComparators(schema: TableSchema): PkExtractorsAndComparators;
@@ -225,5 +349,4 @@ export declare class TransactionLayer implements Layer {
      */
     clearBase(): void;
 }
-export {};
 //# sourceMappingURL=transaction.d.ts.map

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

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