@quereus/quereus 4.13.0 → 4.14.0

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

@@ -2273,9 +2273,9 @@ export class MemoryTableManager {
                 throw new QuereusError(`Duplicate column '${columns[pk.index].name}' in PRIMARY KEY definition`, StatusCode.ERROR);
             }
             seen.add(pk.index);
-            if (!columns[pk.index].notNull) {
-                throw new QuereusError(`Column '${columns[pk.index].name}' must be NOT NULL to participate in PRIMARY KEY`, StatusCode.CONSTRAINT);
-            }
+            // A nullable member is keyable here: this backend compares NULL == NULL as
+            // equal and orders NULL first, so a NULL-containing key is an ordinary key.
+            // See docs/schema.md § Primary-key nullability.
         }
         return rekeySchemaPrimaryKey(this.tableSchema, newPkColumns);
     }
@@ -2299,28 +2299,29 @@ export class MemoryTableManager {
      * 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.
+     * The primary key: a change that moves a PK member's keys (`pkColumnRekeyed`) 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` / `convertColumn` rely on. Both arms can set it: `set
+     * collate` moves the comparator (the `structuresRekeyed` arm, values untouched), and the `set
+     * not null` backfill moves the key VALUES (the rewrite arm — key membership does not imply NOT
+     * NULL, so any key column can be nullable and two NULL keys can converge on one DEFAULT).
+     * The rewrite arm probes the CONVERTED rows through the same `mapRow`, on both of the pass's
+     * row sets: the effective rows decide legality, and the layer chain — whose base rebuild is
+     * what would merge two committed rows — decides representability. A retype of a PK column is
+     * rejected upstream, so `rewrite` + `pkColumnRekeyed` is only ever the backfill.
      */
     async validateAlterColumnPlan(plan, rows) {
         if (plan.rewrite) {
             const { convert, convertNulls } = plan.rewrite;
-            await this.validateRekeyedUniqueStructures(plan.newSchema, plan.colIndex, rows, 
             // Unlike `convertBaseRows`, a conversion failure here is NOT swallowed. Every row
             // the probe sees is visible to the transaction, and the `set data type` pre-pass
             // already proved each one convertible, so a throw is unreachable; surfacing it as
             // MISMATCH still beats probing a stale value that could mask a collision.
-            row => convertRowAtIndex(row, plan.colIndex, convert, convertNulls));
+            const mapRow = row => convertRowAtIndex(row, plan.colIndex, convert, convertNulls);
+            await this.validateRekeyedUniqueStructures(plan.newSchema, plan.colIndex, rows, mapRow);
+            if (plan.pkColumnRekeyed)
+                await this.validateRekeyedPrimaryKey(plan.newSchema, rows, mapRow);
         }
         else if (plan.structuresRekeyed) {
             await this.validateRekeyedUniqueStructures(plan.newSchema, plan.colIndex, rows);
@@ -2367,7 +2368,10 @@ export class MemoryTableManager {
             // `set not null` (`convertNulls`): null base values are mapped to the DEFAULT literal.
             const convertedBaseRows = this.convertBaseRows(plan.colIndex, plan.rewrite.convert, plan.rewrite.convertNulls);
             undo.basePrimaryTree = this.baseLayer.primaryTree;
-            this.baseLayer.rebuildPrimaryTreeFromRows(convertedBaseRows);
+            // `assertDistinctKeys` only when the rewrite moves the KEY values (the backfill of a
+            // key member): the pre-pass has already refused any converging pair, so this is the
+            // invariant check that turns a hole in it into a throw instead of a merged row.
+            this.baseLayer.rebuildPrimaryTreeFromRows(convertedBaseRows, plan.pkColumnRekeyed);
         }
         else if (plan.structuresRekeyed) {
             this.baseLayer.rebuildAllSecondaryIndexes();
@@ -3155,8 +3159,10 @@ export class MemoryTableManager {
         }
     }
     /**
-     * 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
+     * The primary-key re-key pre-pass, shared by every statement that moves the key:
+     * `alter column … set collate` on a PK member (the comparator moves), `alter column … set
+     * not null` on a PK member (the key VALUES move — null → DEFAULT — so the caller passes the
+     * conversion as `mapRow` and both passes judge the post-backfill rows), 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.
@@ -3202,34 +3208,37 @@ export class MemoryTableManager {
      * collisions anywhere in the chain, every primary key resolves to at most one row in
      * each layer under the new definition.
      */
-    async validateRekeyedPrimaryKey(newSchema, rows) {
+    async validateRekeyedPrimaryKey(newSchema, rows, mapRow) {
         const newPkFunctions = createPrimaryKeyFunctions(newSchema, this.collationResolver);
         const connection = this.ddlConnection();
         const view = connection
             ? (connection.pendingTransactionLayer ?? connection.readLayer)
             : this.baseLayer;
-        await this.assertNoPrimaryKeyCollisionInRows(rows ? rows() : this.effectiveDdlRows(), newPkFunctions, primaryKeyArity(newSchema) !== 1);
+        await this.assertNoPrimaryKeyCollisionInRows(rows ? rows() : this.effectiveDdlRows(), newPkFunctions, primaryKeyArity(newSchema) !== 1, mapRow);
         // `ensureSchemaChangeSafety` has already drained every committed layer into the base and
         // rejected sibling connections with open work, so this walk covers the transaction's own
         // layers plus the base — every tree a rollback could restore.
         for (let layer = rows ? view : view.getParent(); layer; layer = layer.getParent()) {
-            this.assertNoPrimaryKeyCollisionInLayer(layer, newPkFunctions);
+            this.assertNoPrimaryKeyCollisionInLayer(layer, newPkFunctions, mapRow);
         }
     }
     /**
      * 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.
+     * counts as a collision. `mapRow`, when given, is applied to each row BEFORE its key is
+     * extracted — the value-rewriting ALTER's per-row conversion, so the probe judges the keys
+     * the rows will have AFTER the rewrite, not the ones stored now.
      *
      * 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.
      */
-    makePrimaryKeyProbe(pkFunctions) {
+    makePrimaryKeyProbe(pkFunctions, mapRow) {
         const probe = new BTree((row) => pkFunctions.extractFromRow(row), pkFunctions.compare);
-        return (row) => {
+        return (stored) => {
+            const row = mapRow ? mapRow(stored) : stored;
             const key = pkFunctions.extractFromRow(row);
             if (probe.get(key) !== undefined)
                 return key;
@@ -3242,8 +3251,8 @@ export class MemoryTableManager {
      * 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.
      */
-    async assertNoPrimaryKeyCollisionInRows(rows, pkFunctions, keyIsTuple) {
-        const seen = this.makePrimaryKeyProbe(pkFunctions);
+    async assertNoPrimaryKeyCollisionInRows(rows, pkFunctions, keyIsTuple, mapRow) {
+        const seen = this.makePrimaryKeyProbe(pkFunctions, mapRow);
         for await (const row of rows) {
             const key = seen(row);
             if (key === undefined)
@@ -3266,11 +3275,11 @@ export class MemoryTableManager {
      * 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.
      */
-    assertNoPrimaryKeyCollisionInLayer(layer, pkFunctions) {
+    assertNoPrimaryKeyCollisionInLayer(layer, pkFunctions, mapRow) {
         const tree = layer.getModificationTree('primary');
         if (!tree)
             return;
-        const seen = this.makePrimaryKeyProbe(pkFunctions);
+        const seen = this.makePrimaryKeyProbe(pkFunctions, mapRow);
         for (const row of iteratePrimaryRows(tree)) {
             if (seen(row) !== undefined) {
                 throw new QuereusError(`Cannot re-key the primary key of table ${this._tableName}: `
@@ -3314,9 +3323,11 @@ export class MemoryTableManager {
      * `convertNulls` routes null own-values through `convert` (the SET NOT NULL null → DEFAULT map);
      * SET DATA TYPE leaves them untouched. No-op in autocommit.
      *
-     * PRIMARY-KEY columns never reach here — any retype of a key column is rejected before
-     * any mutation, and SET NOT NULL leaves the key bytes unchanged — so the primary tree's keys are
-     * stable and no re-key is needed.
+     * A retype of a PRIMARY-KEY column never reaches here (rejected before any mutation), but the
+     * SET NOT NULL backfill of a key member does — its keys move with the values. The layer's own
+     * rows re-key themselves (their keys are extracted from the converted row); the layer's staged
+     * DELETIONS carry only a key, which `convertColumn` re-derives under the same conversion. The
+     * pre-pass has already proved no two rows converge anywhere in the chain.
      */
     convertColumnOnOpenLayers(newSchema, colIndex, convert, convertNulls = false) {
         for (const layer of this.openTransactionLayersOldestFirst()) {