@quereus/quereus 4.3.2 → 4.4.1

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;
     /**
@@ -145,6 +173,31 @@ export declare class TransactionLayer implements Layer {
      * is the row it removed.
      */
     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.
+     */
+    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 +207,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 +233,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 +313,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 +340,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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"}

package/dist/src/vtab/memory/layer/transaction.js

@@ -4,6 +4,7 @@ import { createLogger } from '../../../common/logger.js';
 import { createPrimaryKeyFunctions } from '../utils/primary-key.js';
 import { QuereusError } from '../../../common/errors.js';
 import { StatusCode } from '../../../common/types.js';
+import { convertRowAtIndex } from './row-convert.js';
 const log = createLogger('vtab:memory:layer:transaction');
 const warnLog = log.extend('warn');
 let transactionLayerCounter = 1000;
@@ -26,8 +27,10 @@ export class TransactionLayer {
      * 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.
      */
     tableSchemaAtCreation;
     /**
@@ -104,12 +107,17 @@ export class TransactionLayer {
      *    `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
@@ -130,8 +138,10 @@ export class TransactionLayer {
      *
      * 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) {
         const oldSchema = this.tableSchemaAtCreation;
@@ -194,13 +204,14 @@ export class TransactionLayer {
      * is the row it removed.
      */
     rekeyPrimaryKey(newSchema) {
+        // The pending-change EVENT log is deliberately NOT rewritten here: a collation
+        // change moves only the comparator — every stored value and every key value is
+        // untouched — so the recorded `pk`/`oldRow`/`newRow` images stay accurate as-is.
+        // (Contrast convertColumn / installReshapedColumns, which do rewrite the log.)
         const preRekeyTree = this.primaryModifications;
         const preRekeyEncode = this.pkFunctions.encode;
         this.tableSchemaAtCreation = newSchema;
         this.pkFunctions = createPrimaryKeyFunctions(newSchema, this.collationResolver);
-        const { extractFromRow, compare } = this.pkFunctions;
-        const parentPrimaryTree = this.parentLayer.getModificationTree('primary');
-        const rekeyed = new BTree((value) => extractFromRow(value), compare, { base: parentPrimaryTree || undefined });
         // Net per-key effect of this layer's own writes, read out of the pre-rekey tree
         // (`get` traverses the inheritance chain, so it yields the layer's EFFECTIVE row).
         const deletions = [];
@@ -217,29 +228,55 @@ export class TransactionLayer {
             else
                 upserts.push(effectiveRow);
         }
+        this.installNetOwnWrites(deletions, upserts);
+    }
+    /**
+     * 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).
+     */
+    newPrimaryTreeOverParent() {
+        const { extractFromRow, compare } = this.pkFunctions;
+        return new BTree((value) => extractFromRow(value), compare, { base: this.parentLayer.getModificationTree('primary') || undefined });
+    }
+    /**
+     * 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.
+     */
+    installNetOwnWrites(deletions, upserts) {
+        const rebuilt = this.newPrimaryTreeOverParent();
         for (const primaryKey of deletions) {
-            const path = rekeyed.find(primaryKey);
+            const path = rebuilt.find(primaryKey);
             if (path.on)
-                rekeyed.deleteAt(path);
+                rebuilt.deleteAt(path);
         }
         for (const row of upserts) {
-            rekeyed.upsert(row);
+            rebuilt.upsert(row);
         }
-        this.primaryModifications = rekeyed;
-        // A deleted key an upsert has since re-occupied (`update t set v='A' where v='a'` under
-        // NOCASE) is no longer a deletion of anything: keeping it would make the log claim both
-        // a deletion and an upsert of the same key.
-        const survivingDeletions = deletions.filter(primaryKey => rekeyed.get(primaryKey) === undefined);
+        this.primaryModifications = rebuilt;
+        const { extractFromRow } = this.pkFunctions;
         this.ownWrites.length = 0;
-        for (const primaryKey of survivingDeletions) {
-            this.ownWrites.push({ type: 'delete', primaryKey });
+        for (const primaryKey of deletions) {
+            if (rebuilt.get(primaryKey) === undefined)
+                this.ownWrites.push({ type: 'delete', primaryKey });
         }
         for (const row of upserts) {
             this.ownWrites.push({ type: 'upsert', primaryKey: extractFromRow(row), newRow: row });
         }
-        // Every secondary index's key encoding and PK bookkeeping derive from `pkFunctions`,
-        // and each inherits the parent's freshly-rebuilt tree — so all of them are rebuilt,
-        // including ones the altered column does not appear in.
         this.secondaryIndexes = new Map();
         this.initializeSecondaryIndexes();
         for (const index of this.secondaryIndexes.values()) {
@@ -255,11 +292,16 @@ export class TransactionLayer {
      * 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.
@@ -280,15 +322,12 @@ export class TransactionLayer {
         this.tableSchemaAtCreation = newSchema;
         // The parent's primary tree has been REPLACED by the conversion (base rebuilt from fresh
         // rows, or a parent layer already converted oldest-first), so this layer's own tree — which
-        // derived from the OLD one — must be rebuilt over the parent's NEW tree, exactly as
-        // rekeyPrimaryKey does. The PK is unchanged (a key-column retype is rejected upstream), so
-        // pkFunctions and the keys stay; only the value at colIndex moves.
-        const { extractFromRow, compare } = this.pkFunctions;
-        const parentPrimaryTree = this.parentLayer.getModificationTree('primary');
-        const rebuilt = new BTree((value) => extractFromRow(value), compare, { base: parentPrimaryTree || undefined });
-        // Net per-key effect of this layer's own writes, read out of the pre-conversion tree. The PK
-        // is unchanged, so a key is either finally-deleted or finally-upserted, never both — no key
-        // can collapse onto another (unlike rekeyPrimaryKey).
+        // derived from the OLD one — must be rebuilt over the parent's NEW tree; installNetOwnWrites
+        // below does that. The PK is unchanged (a key-column retype is rejected upstream), so
+        // pkFunctions and the keys stay; only the value at colIndex moves — which also means a key
+        // is either finally-deleted or finally-upserted, never both, and no key can collapse onto
+        // another (unlike rekeyPrimaryKey). The net per-key effect is read out of the
+        // pre-conversion tree.
         const seen = new Set();
         const survivingDeletions = [];
         const upserts = [];
@@ -304,42 +343,139 @@ export class TransactionLayer {
                 survivingDeletions.push(write.primaryKey);
                 continue;
             }
-            const oldVal = effectiveRow[colIndex];
             let newRow = effectiveRow;
-            if (oldVal !== null || convertNulls) {
-                try {
-                    const newVal = convert(oldVal);
-                    newRow = effectiveRow.map((v, i) => i === colIndex ? newVal : v);
-                }
-                catch {
-                    // Shadowed unconvertible own value — leave as-is (see method doc).
-                }
+            try {
+                newRow = convertRowAtIndex(effectiveRow, colIndex, convert, convertNulls);
+            }
+            catch {
+                // Shadowed unconvertible own value — leave as-is (see method doc).
             }
             upserts.push(newRow);
         }
-        for (const primaryKey of survivingDeletions) {
-            const path = rebuilt.find(primaryKey);
-            if (path.on)
-                rebuilt.deleteAt(path);
-        }
-        for (const row of upserts) {
-            rebuilt.upsert(row);
+        this.installNetOwnWrites(survivingDeletions, upserts);
+        // Rewrite the pending-change EVENT log's images too, so the events emitted at this
+        // table's commit carry the post-conversion values the committed rows hold. Best-effort,
+        // per image: the log holds historical images (including superseded intermediate ones the
+        // net rewrite above never touches), so an unconvertible value keeps its raw form rather
+        // than failing the ALTER. One entry per recorded write is kept — no dedup, unlike the
+        // own-write collapse — because every recorded write is a separately delivered event.
+        if (this.pendingChanges) {
+            this.pendingChanges = this.pendingChanges.map(change => {
+                const remapImage = (row) => {
+                    if (!row)
+                        return row;
+                    try {
+                        return convertRowAtIndex(row, colIndex, convert, convertNulls);
+                    }
+                    catch {
+                        return row;
+                    }
+                };
+                return { ...change, oldRow: remapImage(change.oldRow), newRow: remapImage(change.newRow) };
+            });
         }
-        this.primaryModifications = rebuilt;
-        this.ownWrites.length = 0;
-        for (const primaryKey of survivingDeletions) {
-            this.ownWrites.push({ type: 'delete', primaryKey });
+    }
+    /**
+     * 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.
+     */
+    async prepareReshapedColumns(reshapeRow, reshapeEventRow) {
+        const seen = new Set();
+        const survivingDeletions = [];
+        const upserts = [];
+        for (const write of this.ownWrites) {
+            const encoded = this.pkFunctions.encode(write.primaryKey);
+            if (seen.has(encoded))
+                continue;
+            seen.add(encoded);
+            // `get` traverses the inheritance chain, so this is the layer's EFFECTIVE row:
+            // undefined when the layer deleted the key, the layer's own row otherwise.
+            const effectiveRow = this.primaryModifications.get(write.primaryKey);
+            if (effectiveRow === undefined) {
+                survivingDeletions.push(write.primaryKey);
+                continue;
+            }
+            upserts.push(await reshapeRow(effectiveRow));
         }
-        for (const row of upserts) {
-            this.ownWrites.push({ type: 'upsert', primaryKey: extractFromRow(row), newRow: row });
+        // Reshape the pending-change EVENT log alongside — through `reshapeEventRow`, the
+        // BEST-EFFORT variant of `reshapeRow`, deliberately the opposite posture: `reshapeRow`
+        // rewrites the layer's net effective rows and its failure MUST reject the ALTER, while
+        // the log holds historical images (including superseded intermediate ones the net
+        // rewrite never touches) that a backfill evaluator can legitimately fail on. The
+        // caller supplies a `reshapeEventRow` that falls back rather than throws (ADD COLUMN
+        // fills NULL when the evaluator fails); a throw that still escapes leaves that image
+        // at the old arity (logged) and never rejects the ALTER. One entry per recorded write
+        // is kept — no dedup, unlike the own-write collapse above — because every recorded
+        // write is a separately delivered event.
+        let reshapedPendingChanges = null;
+        if (this.pendingChanges) {
+            reshapedPendingChanges = [];
+            for (const change of this.pendingChanges) {
+                const next = { ...change };
+                try {
+                    if (change.oldRow)
+                        next.oldRow = await reshapeEventRow(change.oldRow);
+                    if (change.newRow)
+                        next.newRow = await reshapeEventRow(change.newRow);
+                }
+                catch (e) {
+                    warnLog('Pending-change reshape failed on %s; leaving image at the old arity: %O', this.tableSchemaAtCreation.name, e);
+                }
+                reshapedPendingChanges.push(next);
+            }
         }
-        // Any secondary index on the column holds keys extracted from the OLD value. Rebuild every
-        // index over the parent's freshly-converted trees (matching the base's unconditional rebuild),
-        // then re-file this layer's own converted writes.
-        this.secondaryIndexes = new Map();
-        this.initializeSecondaryIndexes();
-        for (const index of this.secondaryIndexes.values()) {
-            this.reindexOwnWrites(index);
+        return { survivingDeletions, upserts, reshapedPendingChanges };
+    }
+    /**
+     * 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, prepared) {
+        this.tableSchemaAtCreation = newSchema;
+        this.pkFunctions = createPrimaryKeyFunctions(newSchema, this.collationResolver);
+        this.installNetOwnWrites(prepared.survivingDeletions, prepared.upserts);
+        // Install the reshaped event log the prepare phase computed (null ⇔ tracking
+        // disabled), so the events emitted at this table's commit describe rows in the
+        // post-ALTER column set.
+        if (prepared.reshapedPendingChanges !== null) {
+            this.pendingChanges = prepared.reshapedPendingChanges;
         }
     }
     /**
@@ -414,6 +550,19 @@ export class TransactionLayer {
     getPendingChanges() {
         return this.pendingChanges ?? [];
     }
+    /**
+     * 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() {
+        if (this.pendingChanges)
+            this.pendingChanges = [];
+    }
     /** This layer's own structural writes, oldest-first — the rebase replay source. */
     getOwnWrites() {
         return this.ownWrites;