@quereus/quereus 4.20.0 → 4.20.2

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

@@ -257,21 +257,22 @@ export declare class MemoryTableManager {
     private validateMutationPermissions;
     private ensureTransactionLayer;
     private performInsert;
+    /**
+     * Resolves a primary-key collision with `existingRow` under the effective
+     * action (statement OR > per-constraint default > ABORT). Returns the
+     * terminating result for IGNORE / ABORT-family actions, or null for REPLACE —
+     * the caller then proceeds to the secondary UNIQUE check and the write, and
+     * reports `existingRow` as `replacedRow`.
+     */
+    private resolvePkConflict;
     private performUpdate;
     private performUpdateWithPrimaryKeyChange;
     private performDelete;
     /**
-     * Returns true if any column covered by a UNIQUE constraint changed between
-     * old and new rows, or if any column referenced by a partial-UNIQUE predicate
-     * changed (which may transition the row into or out of the predicate's scope).
-     *
-     * NOTE: the per-column test is byte-level `compareSqlValues`, not the enforcement
-     * comparator, so it OVER-triggers for a semantic-ordering column: rewriting a
-     * TIMESPAN 'PT1H' to 'PT60M' reports "changed" and re-runs the UNIQUE check, which
-     * then excludes the row's own primary key and passes. Correct — this only gates
-     * whether to re-check — just not minimal. If UPDATE-heavy workloads over
-     * semantic-ordering UNIQUE columns ever show the redundant re-check as hot, route
-     * this through `uniqueEnforcementComparators` too.
+     * Same-PK UPDATE gate over the shared {@link sharedUniqueColumnsChanged} (see its
+     * NOTE on byte-level over-triggering). A partial constraint's referenced columns
+     * come from its covering index's compiled predicate when one is on hand; for an
+     * MV-covered (or uncovered) constraint the predicate is compiled ad hoc.
      */
     private uniqueColumnsChanged;
     /**
@@ -280,6 +281,7 @@ export declare class MemoryTableManager {
      * 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.
+     * Rows at the `self` slots are never conflicts (see {@link UniqueCheckSelf}).
      */
     private checkUniqueConstraints;
     private checkSingleUniqueConstraint;
@@ -307,7 +309,7 @@ export declare class MemoryTableManager {
      * 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)
+     * statement (e.g. a prior REPLACE eviction or key-changing UPDATE)
      * — 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.
@@ -321,6 +323,7 @@ export declare class MemoryTableManager {
      * backing delete still lands within this statement.
      */
     private checkUniqueViaMaterializedView;
+    private isSelfKey;
     private checkUniqueByScanning;
     renameTable(newName: string): void;
     /**

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

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

@@ -10,9 +10,9 @@ import { MemoryVirtualTableConnection } from '../connection.js';
 import { QuereusError } from '../../../common/errors.js';
 import { ConflictResolution } from '../../../common/constants.js';
 import { buildUniqueConstraintSchema, buildForeignKeyConstraintSchema, buildCheckConstraintSchema, validateForeignKeyOverExistingRows, maintainedTableUniqueViolationError, formatKeyValue } from '../../../schema/constraint-builder.js';
-import { indexEnforcesUnique, uniqueEnforcementCollations, uniqueEnforcementComparators } from '../../../schema/unique-enforcement.js';
+import { indexEnforcesUnique, uniqueColumnsChanged as sharedUniqueColumnsChanged, uniqueEnforcementCollations, uniqueEnforcementComparators } from '../../../schema/unique-enforcement.js';
 import { generateIndexDDL, generateDropIndexDDL } from '../../../schema/ddl-generator.js';
-import { compareSqlValues, rowsValueIdentical, normalizeCollationName } from '../../../util/comparison.js';
+import { rowsValueIdentical, normalizeCollationName } from '../../../util/comparison.js';
 import { scanLayer as scanLayerImpl } from './scan-layer.js';
 import { createPrimaryKeyFunctions, buildPrimaryKeyFromValues, primaryKeyArity } from '../utils/primary-key.js';
 import { createMemoryTableLoggers } from '../utils/logging.js';
@@ -916,32 +916,43 @@ export class MemoryTableManager {
         const primaryKey = this.primaryKeyFromRow(newRowData);
         const existingRow = this.lookupEffectiveRow(primaryKey, targetLayer);
         if (existingRow !== null) {
-            // Resolve PK-conflict action: statement OR > per-constraint default > ABORT.
-            const pkAction = onConflict ?? resolvePkDefaultConflict(schema) ?? ConflictResolution.ABORT;
-            if (pkAction === ConflictResolution.IGNORE) {
-                return { status: 'ok', row: undefined };
-            }
-            if (pkAction === ConflictResolution.REPLACE) {
-                targetLayer.recordUpsert(primaryKey, newRowData, existingRow);
-                return { status: 'ok', row: newRowData, replacedRow: existingRow };
-            }
-            return {
-                status: 'constraint',
-                constraint: 'unique',
-                message: `UNIQUE constraint failed: ${this._tableName} PK.`,
-                existingRow: existingRow
-            };
+            const pkOutcome = this.resolvePkConflict(schema, onConflict, existingRow, `UNIQUE constraint failed: ${this._tableName} PK.`);
+            if (pkOutcome)
+                return pkOutcome;
+            // REPLACE: the row at this PK is overwritten below, after the secondary
+            // UNIQUE check (which excludes this PK, so it cannot self-conflict).
         }
         // Check UNIQUE constraints against secondary indexes. Secondary-UNIQUE
         // REPLACE evictions (rows at OTHER PKs) accumulate in `evicted` and are
         // surfaced via `evictedRows` so the DML executor runs the full delete
         // pipeline (change-tracking, row-time MV maintenance, FK cascade, events).
         const evicted = [];
-        const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, primaryKey, onConflict, evicted);
+        const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, { key: primaryKey }, onConflict, evicted);
         if (ucResult)
             return ucResult;
-        targetLayer.recordUpsert(primaryKey, newRowData, null);
-        return { status: 'ok', row: newRowData, evictedRows: evicted.length > 0 ? evicted : undefined };
+        targetLayer.recordUpsert(primaryKey, newRowData, existingRow);
+        return {
+            status: 'ok',
+            row: newRowData,
+            replacedRow: existingRow ?? undefined,
+            evictedRows: evicted.length > 0 ? evicted : undefined,
+        };
+    }
+    /**
+     * Resolves a primary-key collision with `existingRow` under the effective
+     * action (statement OR > per-constraint default > ABORT). Returns the
+     * terminating result for IGNORE / ABORT-family actions, or null for REPLACE —
+     * the caller then proceeds to the secondary UNIQUE check and the write, and
+     * reports `existingRow` as `replacedRow`.
+     */
+    resolvePkConflict(schema, onConflict, existingRow, message) {
+        const pkAction = onConflict ?? resolvePkDefaultConflict(schema) ?? ConflictResolution.ABORT;
+        if (pkAction === ConflictResolution.REPLACE)
+            return null;
+        if (pkAction === ConflictResolution.IGNORE) {
+            return { status: 'ok', row: undefined };
+        }
+        return { status: 'constraint', constraint: 'unique', message, existingRow };
     }
     async performUpdate(targetLayer, values, oldKeyValues, onConflict, preCoerced) {
         if (!values || !oldKeyValues) {
@@ -973,7 +984,7 @@ export class MemoryTableManager {
             // surface them via `evictedRows` for the executor's delete pipeline.
             const evicted = [];
             if (this.uniqueColumnsChanged(schema, oldRowData, newRowData)) {
-                const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, targetPrimaryKey, onConflict, evicted);
+                const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, { key: targetPrimaryKey }, onConflict, evicted);
                 if (ucResult)
                     return ucResult;
             }
@@ -984,38 +995,34 @@ export class MemoryTableManager {
     async performUpdateWithPrimaryKeyChange(targetLayer, schema, oldPrimaryKey, newPrimaryKey, oldRowData, newRowData, onConflict) {
         const existingRowAtNewKey = this.lookupEffectiveRow(newPrimaryKey, targetLayer);
         if (existingRowAtNewKey !== null) {
-            const pkAction = onConflict ?? resolvePkDefaultConflict(schema) ?? ConflictResolution.ABORT;
-            if (pkAction === ConflictResolution.IGNORE) {
-                return { status: 'ok', row: undefined };
-            }
-            if (pkAction === ConflictResolution.REPLACE) {
-                // Evict the row currently at the new PK, then move the updated row.
-                targetLayer.recordDelete(newPrimaryKey, existingRowAtNewKey);
-                targetLayer.recordDelete(oldPrimaryKey, oldRowData);
-                targetLayer.recordUpsert(newPrimaryKey, newRowData, null);
-                return { status: 'ok', row: newRowData, replacedRow: existingRowAtNewKey };
-            }
-            // Return constraint violation with existing row
-            return {
-                status: 'constraint',
-                constraint: 'unique',
-                message: `UNIQUE constraint failed on new PK for ${this._tableName}.`,
-                existingRow: existingRowAtNewKey
-            };
-        }
-        // Delete old row first, then check UNIQUE constraints at the new position.
-        // A secondary-UNIQUE REPLACE at the new position evicts conflicting row(s)
-        // at other PKs; surface them via `evictedRows` for the executor pipeline.
-        targetLayer.recordDelete(oldPrimaryKey, oldRowData);
+            const pkOutcome = this.resolvePkConflict(schema, onConflict, existingRowAtNewKey, `UNIQUE constraint failed on new PK for ${this._tableName}.`);
+            if (pkOutcome)
+                return pkOutcome;
+            // REPLACE: the row at the new PK is evicted below, once the secondary
+            // UNIQUE check passes.
+        }
+        // Check UNIQUE constraints before touching either slot. Both the old and the
+        // new PK are the moving row's own (the old row leaves, any row at the new PK
+        // is displaced), so neither can conflict. A secondary-UNIQUE REPLACE evicts
+        // conflicting row(s) at other PKs; surface them via `evictedRows` for the
+        // executor pipeline.
         const evicted = [];
-        const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, newPrimaryKey, onConflict, evicted);
-        if (ucResult) {
-            // Rollback the delete if constraint check fails
-            targetLayer.recordUpsert(oldPrimaryKey, oldRowData, null);
+        const ucResult = await this.checkUniqueConstraints(targetLayer, schema, newRowData, { key: newPrimaryKey, vacated: oldPrimaryKey }, onConflict, evicted);
+        if (ucResult)
             return ucResult;
+        // Journal order evict-delete, move-delete, move-insert is the data-change
+        // event contract (docs/usage.md § Subscribing to Data Changes).
+        if (existingRowAtNewKey !== null) {
+            targetLayer.recordDelete(newPrimaryKey, existingRowAtNewKey);
         }
+        targetLayer.recordDelete(oldPrimaryKey, oldRowData);
         targetLayer.recordUpsert(newPrimaryKey, newRowData, null);
-        return { status: 'ok', row: newRowData, evictedRows: evicted.length > 0 ? evicted : undefined };
+        return {
+            status: 'ok',
+            row: newRowData,
+            replacedRow: existingRowAtNewKey ?? undefined,
+            evictedRows: evicted.length > 0 ? evicted : undefined,
+        };
     }
     async performDelete(targetLayer, oldKeyValues) {
         if (!oldKeyValues) {
@@ -1031,43 +1038,18 @@ export class MemoryTableManager {
         return { status: 'ok', row: oldRowData };
     }
     /**
-     * Returns true if any column covered by a UNIQUE constraint changed between
-     * old and new rows, or if any column referenced by a partial-UNIQUE predicate
-     * changed (which may transition the row into or out of the predicate's scope).
-     *
-     * NOTE: the per-column test is byte-level `compareSqlValues`, not the enforcement
-     * comparator, so it OVER-triggers for a semantic-ordering column: rewriting a
-     * TIMESPAN 'PT1H' to 'PT60M' reports "changed" and re-runs the UNIQUE check, which
-     * then excludes the row's own primary key and passes. Correct — this only gates
-     * whether to re-check — just not minimal. If UPDATE-heavy workloads over
-     * semantic-ordering UNIQUE columns ever show the redundant re-check as hot, route
-     * this through `uniqueEnforcementComparators` too.
+     * Same-PK UPDATE gate over the shared {@link sharedUniqueColumnsChanged} (see its
+     * NOTE on byte-level over-triggering). A partial constraint's referenced columns
+     * come from its covering index's compiled predicate when one is on hand; for an
+     * MV-covered (or uncovered) constraint the predicate is compiled ad hoc.
      */
     uniqueColumnsChanged(schema, oldRow, newRow) {
-        if (!schema.uniqueConstraints)
-            return false;
-        for (const uc of schema.uniqueConstraints) {
-            for (const colIdx of uc.columns) {
-                if (compareSqlValues(oldRow[colIdx], newRow[colIdx]) !== 0)
-                    return true;
-            }
-            if (uc.predicate) {
-                const covering = this.findIndexForConstraint(this._currentCommittedLayer, uc);
-                // For an index the compiled predicate is already on hand; for an MV-covered
-                // (or uncovered) constraint, compile the partial predicate ad hoc to learn
-                // which columns can transition the row across the predicate's scope.
-                const referenced = covering?.kind === 'memory-index'
-                    ? covering.index.predicate?.referencedColumns
-                    : compilePredicate(uc.predicate, schema.columns, schema.name).referencedColumns;
-                if (referenced) {
-                    for (const colIdx of referenced) {
-                        if (compareSqlValues(oldRow[colIdx], newRow[colIdx]) !== 0)
-                            return true;
-                    }
-                }
-            }
-        }
-        return false;
+        return sharedUniqueColumnsChanged(schema.uniqueConstraints, oldRow, newRow, uc => {
+            const covering = this.findIndexForConstraint(this._currentCommittedLayer, uc);
+            return covering?.kind === 'memory-index'
+                ? covering.index.predicate?.referencedColumns
+                : compilePredicate(uc.predicate, schema.columns, schema.name).referencedColumns;
+        });
     }
     /**
      * Checks all UNIQUE constraints for a new/updated row. Returns an UpdateResult
@@ -1075,18 +1057,19 @@ export class MemoryTableManager {
      * 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.
+     * Rows at the `self` slots are never conflicts (see {@link UniqueCheckSelf}).
      */
-    async checkUniqueConstraints(targetLayer, schema, newRowData, newPrimaryKey, onConflict, evicted) {
+    async checkUniqueConstraints(targetLayer, schema, newRowData, self, onConflict, evicted) {
         if (!schema.uniqueConstraints)
             return null;
         for (const uc of schema.uniqueConstraints) {
-            const result = await this.checkSingleUniqueConstraint(targetLayer, schema, uc, newRowData, newPrimaryKey, onConflict, evicted);
+            const result = await this.checkSingleUniqueConstraint(targetLayer, schema, uc, newRowData, self, onConflict, evicted);
             if (result)
                 return result;
         }
         return null;
     }
-    async checkSingleUniqueConstraint(targetLayer, schema, uc, newRowData, newPrimaryKey, onConflict, evicted, allowMvCovering = true) {
+    async checkSingleUniqueConstraint(targetLayer, schema, uc, newRowData, self, onConflict, evicted, allowMvCovering = true) {
         // SQL semantics: UNIQUE allows multiple NULLs — skip if any constrained column is NULL
         if (uc.columns.some(colIdx => newRowData[colIdx] === null))
             return null;
@@ -1112,9 +1095,9 @@ export class MemoryTableManager {
         if (covering) {
             switch (covering.kind) {
                 case 'memory-index':
-                    return this.checkUniqueViaIndex(targetLayer, schema, uc, covering.index, newRowData, newPrimaryKey, effective, evicted);
+                    return this.checkUniqueViaIndex(targetLayer, schema, uc, covering.index, newRowData, self, effective, evicted);
                 case 'materialized-view':
-                    return this.checkUniqueViaMaterializedView(targetLayer, schema, uc, covering.view, newRowData, newPrimaryKey, effective, evicted);
+                    return this.checkUniqueViaMaterializedView(targetLayer, schema, uc, covering.view, newRowData, self, effective, evicted);
                 default: {
                     const exhaustive = covering;
                     throw new QuereusError(`Unknown covering structure: ${JSON.stringify(exhaustive)}`, StatusCode.INTERNAL);
@@ -1122,7 +1105,7 @@ export class MemoryTableManager {
             }
         }
         // Fallback: scan primary tree
-        return this.checkUniqueByScanning(targetLayer, schema, uc, newRowData, newPrimaryKey, effective, evicted);
+        return this.checkUniqueByScanning(targetLayer, schema, uc, newRowData, self, effective, evicted);
     }
     /**
      * Resolves the {@link CoveringStructure} enforcing a UNIQUE constraint. Prefers
@@ -1215,7 +1198,7 @@ export class MemoryTableManager {
         }
         return undefined;
     }
-    checkUniqueViaIndex(targetLayer, schema, uc, index, newRowData, newPrimaryKey, onConflict, evicted) {
+    checkUniqueViaIndex(targetLayer, schema, uc, index, newRowData, self, onConflict, evicted) {
         const indexKey = index.keyFromRow(newRowData);
         const existingPKs = index.getPrimaryKeys(indexKey);
         // The overwhelmingly common insert has no candidate at all; bail before paying
@@ -1229,7 +1212,7 @@ export class MemoryTableManager {
         const enforcementCollations = uc.columns.map((col, i) => this.collationResolver(index.specColumns[i]?.collation ?? schema.columns[col].collation ?? 'BINARY'));
         const compares = uniqueEnforcementComparators(schema.columns, uc.columns, enforcementCollations);
         for (const existingPK of existingPKs) {
-            if (this.comparePrimaryKeys(newPrimaryKey, existingPK) === 0)
+            if (this.isSelfKey(self, existingPK))
                 continue;
             // Validate the candidate against the live effective row before acting —
             // the same stale-candidate discipline as checkUniqueViaMaterializedView.
@@ -1301,7 +1284,7 @@ export class MemoryTableManager {
      * 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)
+     * statement (e.g. a prior REPLACE eviction or key-changing UPDATE)
      * — 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.
@@ -1314,14 +1297,14 @@ export class MemoryTableManager {
      * executor processes the eviction before the writing row's own bookkeeping, so the
      * backing delete still lands within this statement.
      */
-    async checkUniqueViaMaterializedView(targetLayer, schema, uc, mv, newRowData, newPrimaryKey, onConflict, evicted) {
+    async checkUniqueViaMaterializedView(targetLayer, schema, uc, mv, newRowData, self, onConflict, evicted) {
         // Component-array view of the source PK. Shape comes from the PK arity, never
         // from `Array.isArray` — a single-column JSON PK holding a document like `[1]`
         // is a scalar key that is also a JS array (see the `BTreeKey` invariant).
         // A wrong shape here only WIDENS the candidate set (the row fails its own
         // self-exclusion), and the loop below re-excludes self through the real PK
         // comparator — which is why no query result can observe this line.
-        const newSourcePk = keyParts(newPrimaryKey, primaryKeyArity(schema) !== 1);
+        const newSourcePk = keyParts(self.key, primaryKeyArity(schema) !== 1);
         const conflicts = await this.db._lookupCoveringConflicts(mv, uc, newRowData, newSourcePk);
         // Re-validate under each column's enforcement collation — the index's per-column
         // COLLATE for an index-derived UNIQUE, else the declared column collation
@@ -1340,7 +1323,7 @@ export class MemoryTableManager {
         const compares = uniqueEnforcementComparators(schema.columns, uc.columns, collations);
         for (const conflict of conflicts) {
             const existingPK = buildPrimaryKeyFromValues(conflict.pk, schema.primaryKeyDefinition);
-            if (this.comparePrimaryKeys(newPrimaryKey, existingPK) === 0)
+            if (this.isSelfKey(self, existingPK))
                 continue;
             // Validate against the live source row: skip stale backing candidates.
             const conflictingRow = this.lookupEffectiveRow(existingPK, targetLayer);
@@ -1367,7 +1350,11 @@ export class MemoryTableManager {
         }
         return null;
     }
-    checkUniqueByScanning(targetLayer, schema, uc, newRowData, newPrimaryKey, onConflict, evicted) {
+    isSelfKey(self, pk) {
+        return this.comparePrimaryKeys(self.key, pk) === 0
+            || (self.vacated !== undefined && this.comparePrimaryKeys(self.vacated, pk) === 0);
+    }
+    checkUniqueByScanning(targetLayer, schema, uc, newRowData, self, onConflict, evicted) {
         const primaryTree = targetLayer.getModificationTree('primary');
         if (!primaryTree)
             return null;
@@ -1392,7 +1379,7 @@ export class MemoryTableManager {
         for (const path of primaryTree.ascending(primaryTree.first())) {
             const existingRow = primaryTree.at(path);
             const existingPK = this.primaryKeyFromRow(existingRow);
-            if (this.comparePrimaryKeys(newPrimaryKey, existingPK) === 0)
+            if (this.isSelfKey(self, existingPK))
                 continue;
             if (predicate && predicate.evaluate(existingRow) !== true)
                 continue;
@@ -1698,9 +1685,9 @@ export class MemoryTableManager {
         for (const change of changes) {
             if (change.op === 'delete')
                 continue;
-            const newPrimaryKey = this.primaryKeyFromRow(change.newRow);
+            const self = { key: this.primaryKeyFromRow(change.newRow) };
             for (const uc of ucs) {
-                const result = await this.checkSingleUniqueConstraint(layer, schema, uc, change.newRow, newPrimaryKey, ConflictResolution.ABORT, noEvict, /*allowMvCovering*/ false);
+                const result = await this.checkSingleUniqueConstraint(layer, schema, uc, change.newRow, self, ConflictResolution.ABORT, noEvict, /*allowMvCovering*/ false);
                 if (result) {
                     const colNames = uc.columns.map(i => schema.columns[i]?.name ?? String(i));
                     throw maintainedTableUniqueViolationError(this.schemaName, this._tableName, uc.name ?? implicitIndexNameOver(uc, schema.columns), colNames, uc.columns.map(i => change.newRow[i]));