@quereus/store 4.4.0 → 4.4.1

package/dist/src/common/store-table.d.ts.map

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

package/dist/src/common/store-table.js

@@ -9,11 +9,12 @@
  *   - Index stores: {schema}.{table}_idx_{name} - one per secondary index
  *   - Stats store: __stats__ - unified store for all table statistics, keyed by {schema}.{table}
  */
-import { VirtualTable, IndexConstraintOp, ConflictResolution, QuereusError, StatusCode, compareSqlValues, compareSqlValuesFast, resolveUniqueEnforcementCollations, BINARY_COLLATION, rowsValueIdentical, validateAndParse, compilePredicate, decodeIdxStr, maintainedTableUniqueViolationError, uniqueEnforcementCollations, logicalTypeCanHoldText, pkKeyCollationName, } from '@quereus/quereus';
+import { VirtualTable, IndexConstraintOp, ConflictResolution, QuereusError, StatusCode, compareSqlValues, compareSqlValuesFast, createTypedComparator, hasSemanticOrdering, semanticKeyTransform, resolveUniqueEnforcementCollations, uniqueEnforcementComparators, BINARY_COLLATION, rowsValueIdentical, coerceRowToSchema, compilePredicate, decodeIdxStr, maintainedTableUniqueViolationError, uniqueEnforcementCollations, logicalTypeCanHoldText, pkKeyCollationName, JSON_TYPE, } from '@quereus/quereus';
 import { bytesEqual, bytesToHex, compareBytes } from './bytes.js';
 import { StoreConnection } from './store-connection.js';
 import { buildDataKey, buildIndexKey, buildIndexPrefixBounds, buildFullScanBounds, buildPkPrefixBounds, buildStatsKey, } from './key-builder.js';
 import { serializeRow, deserializeRow, serializeStats, deserializeStats, } from './serialization.js';
+import { jsonStructuralKey } from './json-key.js';
 /** Number of mutations before persisting statistics. */
 const STATS_FLUSH_INTERVAL = 100;
 /** True when `key` falls within the (gte/gt/lte/lt) window of `bounds`. */
@@ -87,6 +88,76 @@ export function resolvePkKeyCollations(pkDef, columns, fallback) {
         return name === undefined ? undefined : (name || fallback).toUpperCase();
     });
 }
+/**
+ * The store's per-type key VALUE TRANSFORM for a semantic-ordering logical type, or
+ * `undefined` when raw values already key faithfully.
+ *
+ * The contract is TWO-sided — identity AND order. `StoreTable` implements no
+ * `comparePrimaryKey`, so the isolation layer merges overlay against underlying with
+ * its own fallback comparator (the PK type's `compare` via `createTypedComparator`)
+ * and needs this table's key BYTE order to agree with it; and byte equality must be
+ * exactly the type's equality, or two spellings of one value land on two keys.
+ *
+ *  - JSON → the store-local structural encoder ({@link jsonStructuralKey}): a
+ *    `Uint8Array` whose memcmp order reproduces the type's structural `compare`
+ *    (canonical-text bytes are identity-faithful but sort `[10]` before `[2]`,
+ *    which broke overlay shadowing — see json-key.ts).
+ *  - Everything else → the engine's {@link semanticKeyTransform} (the type's
+ *    `groupKey`). Today that is TIMESPAN: total seconds against the same reference
+ *    date as `TIMESPAN.compare`, so 'PT1H' and 'PT60M' collide on one key AND byte
+ *    order is elapsed-time order.
+ *
+ * JSON deliberately gets NO engine `groupKey` — `groupKey` also drives GROUP BY /
+ * `IN` / hash-join identity, where canonical-text identity is already correct and a
+ * `Uint8Array` key would be a behaviour change for no benefit. Hence this
+ * store-local seam. A semantic-ordering type with NEITHER a `groupKey` nor an entry
+ * here cannot key a persisted structure soundly; `StoreTable` rejects it at DDL time
+ * (see `validateSemanticKeyTransforms`).
+ */
+export function storeSemanticKeyTransform(type) {
+    // Matched by NAME, not object identity (`type === JSON_TYPE`): the engine and this
+    // package can be loaded as two module instances (e.g. the logic suite runs the
+    // engine from src via ts-node while the store resolves `@quereus/quereus` to dist),
+    // and each instance carries its own JSON_TYPE singleton. The `hasSemanticOrdering`
+    // gate keeps a hypothetical plain custom type named 'JSON' out of this branch.
+    if (hasSemanticOrdering(type) && type.name === JSON_TYPE.name)
+        return jsonStructuralKey;
+    return semanticKeyTransform(type);
+}
+/**
+ * Resolve the per-column key value transform for each primary-key column —
+ * {@link storeSemanticKeyTransform} of the member's logical type. One entry per PK
+ * member in `pkDef` order; `undefined` for every type whose raw value already keys
+ * faithfully. The companion of {@link resolvePkKeyCollations}: every call site that
+ * threads the collations MUST thread these too, or key identity/order drifts
+ * between the write path and the rebuild/lookup path.
+ */
+export function resolvePkKeyTransforms(pkDef, columns) {
+    return pkDef.map(def => storeSemanticKeyTransform(columns[def.index]?.logicalType));
+}
+/**
+ * Per-column key value transforms for a secondary index's OWN columns (the
+ * index half of `buildIndexKey`), positionally aligned with `index.columns`.
+ * Same rule as {@link resolvePkKeyTransforms}: a semantic-ordering member
+ * canonicalizes through {@link storeSemanticKeyTransform}, everything else
+ * encodes raw.
+ */
+export function resolveIndexKeyTransforms(index, columns) {
+    return index.columns.map(col => storeSemanticKeyTransform(columns[col.index]?.logicalType));
+}
+/**
+ * Per-PK-column typed equality comparator for semantic-ordering members, `undefined`
+ * elsewhere. Backs {@link StoreTable.keysEqual}: two PK arrays naming the same
+ * physical key under {@link resolvePkKeyTransforms} ('PT1H' / 'PT60M') must also
+ * answer "same row" here, or self-PK exclusion in the UNIQUE checks false-conflicts
+ * a row against its own differently-spelled image.
+ */
+function resolvePkSemanticEquality(pkDef, columns) {
+    return pkDef.map(def => {
+        const logicalType = columns[def.index]?.logicalType;
+        return hasSemanticOrdering(logicalType) ? createTypedComparator(logicalType) : undefined;
+    });
+}
 /**
  * True when `col` can produce a TEXT value at runtime, and so when its physical
  * key bytes are produced by a collation normalizer rather than a type-native
@@ -128,6 +199,17 @@ export function columnCanHoldText(col) {
  * "mark handled" and "build a window" decisions can never disagree.
  */
 export function keyOrderMatchesCollation(db, column, keyCollation, compareCollation) {
+    // A semantic-ordering logical type (TIMESPAN, JSON — see docs/types.md "Semantic
+    // ordering") is ordered by its `compare` (elapsed time / structural), which the
+    // engine's Sort, comparison operators, and the memory backend all use. Both types'
+    // key bytes now encode through an order-preserving transform (TIMESPAN's `groupKey`
+    // total seconds; JSON's structural encoding — see `storeSemanticKeyTransform`), so
+    // byte order DOES match the type's `compare` for every well-formed value and this
+    // blanket decline is conservative, costing the seek/sort-elision, never a row.
+    // Re-opening the window/advertisement (and the byte-EQ arms in `analyzePKAccess` /
+    // `analyzeIndexAccess`) is tracked in backlog `feat-reopen-timespan-store-seeks`.
+    if (hasSemanticOrdering(column?.logicalType))
+        return false;
     if (!columnCanHoldText(column))
         return true;
     if (compareCollation.toUpperCase() !== keyCollation.toUpperCase())
@@ -145,13 +227,12 @@ export function keyOrderMatchesCollation(db, column, keyCollation, compareCollat
  * already aligned with the key collation for every *textual* PK member.
  *
  * What the advertisement is measured against is the order the planner's `Sort` would have
- * produced, and `Sort` (like every scalar comparison) orders under the operand's COLLATION via
- * `compareSqlValuesFast` — never through `logicalType.compare`. So a collation match is the
- * whole question, even for a member whose type declares a `compare` that orders differently
- * (`TIMESPAN.compare` ranks by `Temporal.Duration` total, `JSON_TYPE.compare` structurally).
- * `MemoryTable`, whose primary-key BTree *is* keyed by `createTypedComparator`, advertises the
- * type's order instead and so disagrees with its own `Sort` — tracked as
- * `bug-memory-pk-btree-orders-by-logical-type-compare`, not something the store should copy.
+ * produced. For most members Sort orders under the operand's COLLATION, so a collation match
+ * is the question; for a member whose logical type carries SEMANTIC ordering (TIMESPAN, JSON
+ * — see docs/types.md "Semantic ordering") Sort now ranks by `logicalType.compare`, which no
+ * text-byte encoding reproduces, and {@link keyOrderMatchesCollation} closes the gate for
+ * such members outright (the memory backend's typed BTree order is the canonical order under
+ * that ruling; the store declines rather than advertising a divergent byte order).
  *
  * `0` ⇒ even the leading member is unsafe: no range seek, no PK-order advertisement.
  * A prefix shorter than the PK truncates the ordering advertisement rather than voiding it.
@@ -279,6 +360,21 @@ export class StoreTable extends VirtualTable {
      * {@link updateSchema} (an ALTER COLUMN SET COLLATE on a PK member changes it).
      */
     pkKeyCollations;
+    /**
+     * Per-PK-column key-identity value transform (see {@link resolvePkKeyTransforms}).
+     * Threaded alongside {@link pkKeyCollations} into every data-key / PK-suffix /
+     * PK-prefix-bounds encode, so a semantic-ordering PK member (TIMESPAN) keys
+     * semantically-equal spellings to one physical key. Recomputed on every
+     * {@link updateSchema}.
+     */
+    pkKeyTransforms;
+    /**
+     * Per-PK-column typed EQUALITY comparator for the semantic-ordering members only —
+     * `undefined` for every other member, which {@link keysEqual} still compares with
+     * strict `!==` as before. Keeps self-PK exclusion and PK-identity questions in
+     * agreement with the physical key identity above ('PT1H' row IS the 'PT60M' row).
+     */
+    pkSemanticEquality;
     /**
      * `db.getCollationResolver()`, bound once at construction. Every collation-aware
      * VALUE comparison this table makes — pushed-constraint re-check, UNIQUE conflict
@@ -345,9 +441,12 @@ export class StoreTable extends VirtualTable {
         };
         this.pkDirections = tableSchema.primaryKeyDefinition.map(pk => !!pk.desc);
         this.pkKeyCollations = resolvePkKeyCollations(tableSchema.primaryKeyDefinition, tableSchema.columns, this.encodeOptions.collation ?? 'NOCASE');
+        this.pkKeyTransforms = resolvePkKeyTransforms(tableSchema.primaryKeyDefinition, tableSchema.columns);
+        this.pkSemanticEquality = resolvePkSemanticEquality(tableSchema.primaryKeyDefinition, tableSchema.columns);
         // Validate the MATERIALIZED schema, so a `_uc_*` over a text column that needs the
         // table key collation K is rejected up front just like an explicit index would be.
         this.validateKeyCollations(this.materializedSchema, this.pkKeyCollations);
+        this.validateSemanticKeyTransforms(this.materializedSchema);
         this.ddlSaved = isConnected;
     }
     /**
@@ -397,6 +496,47 @@ export class StoreTable extends VirtualTable {
                 + `— pass { normalizer } to registerCollation`, StatusCode.ERROR);
         }
     }
+    /**
+     * Reject, at DDL time, a key member whose semantic-ordering logical type has no
+     * store key transform — before a single row is keyed under bytes whose order the
+     * type's `compare` (and so the isolation merge, the memory oracle, and Sort)
+     * disagrees with.
+     *
+     * A semantic-ordering type keys soundly only through an order- and
+     * identity-preserving transform ({@link storeSemanticKeyTransform}: the type's
+     * `groupKey`, or a store-local encoder like JSON's structural one). This gap used
+     * to be undetectable — JSON sat here transform-less for a release, keying in
+     * canonical-text order while every comparator ordered structurally, and the only
+     * symptom was a misaligned overlay merge deep inside a transaction. Unreachable
+     * today (TIMESPAN and JSON are both covered); it exists so the NEXT
+     * semantic-ordering type fails loudly at CREATE TABLE instead.
+     *
+     * Checked over the same materialized schema as {@link validateKeyCollations}:
+     * every PK member and every (explicit or hidden `_uc_*`) index column.
+     *
+     * CAVEAT: this can only check that a transform EXISTS — a `groupKey` that is
+     * identity-faithful but not order-preserving passes undetected, so a new type's
+     * transform still needs its byte order argued against its `compare` (see
+     * json-key.ts for the shape of that argument).
+     */
+    validateSemanticKeyTransforms(schema) {
+        const check = (colIndex, member) => {
+            const col = schema.columns[colIndex];
+            const type = col?.logicalType;
+            if (!hasSemanticOrdering(type) || storeSemanticKeyTransform(type) !== undefined)
+                return;
+            throw new QuereusError(`column ${col?.name ?? String(colIndex)} (${member}): semantic-ordering type `
+                + `${type.name} cannot key a persisted structure: its raw encoding would not `
+                + `reproduce the type's compare order — the type needs an order-preserving `
+                + `groupKey or a store key encoder (see storeSemanticKeyTransform)`, StatusCode.ERROR);
+        };
+        for (const def of schema.primaryKeyDefinition)
+            check(def.index, 'primary key');
+        for (const index of schema.indexes ?? []) {
+            for (const col of index.columns)
+                check(col.index, `index ${index.name}`);
+        }
+    }
     /** Get the table configuration. */
     getConfig() {
         return this.config;
@@ -427,10 +567,13 @@ export class StoreTable extends VirtualTable {
         const materialized = withImplicitUniqueIndexes(newSchema);
         const pkKeyCollations = resolvePkKeyCollations(newSchema.primaryKeyDefinition, newSchema.columns, this.encodeOptions.collation ?? 'NOCASE');
         this.validateKeyCollations(materialized, pkKeyCollations);
+        this.validateSemanticKeyTransforms(materialized);
         this.tableSchema = newSchema;
         this.materializedSchema = materialized;
         this.pkDirections = newSchema.primaryKeyDefinition.map(pk => !!pk.desc);
         this.pkKeyCollations = pkKeyCollations;
+        this.pkKeyTransforms = resolvePkKeyTransforms(newSchema.primaryKeyDefinition, newSchema.columns);
+        this.pkSemanticEquality = resolvePkSemanticEquality(newSchema.primaryKeyDefinition, newSchema.columns);
     }
     /**
      * Mark the table's DDL as already persisted to the catalog, so the lazy
@@ -566,9 +709,13 @@ export class StoreTable extends VirtualTable {
         const bounds = buildFullScanBounds();
         const newPkDirections = newPkDef.map(pk => !!pk.desc);
         const newPkCollations = resolvePkKeyCollations(newPkDef, newColumns, this.encodeOptions.collation ?? 'NOCASE');
+        // Post-ALTER key-identity transforms too: an ALTER PRIMARY KEY onto (or a SET
+        // DATA TYPE creating) a semantic-ordering member must collapse equal spellings
+        // — pass 1 then rejects 'PT1H'/'PT60M' as a duplicate PK, all-or-nothing.
+        const newPkTransforms = resolvePkKeyTransforms(newPkDef, newColumns);
         // Both passes key rows through this one helper, so a collision judged in pass 1
         // is byte-identical to the key pass 2 writes.
-        const computeNewKey = (row) => buildDataKey(newPkDef.map(pk => row[pk.index]), this.encodeOptions, newPkDirections, newPkCollations);
+        const computeNewKey = (row) => buildDataKey(newPkDef.map(pk => row[pk.index]), this.encodeOptions, newPkDirections, newPkCollations, newPkTransforms);
         // Pass 1 — collision detection only. Hold one hex signature per new key, never
         // the row or old key. On a repeat, reject before any write; the store is
         // untouched on rejection.
@@ -783,11 +930,7 @@ export class StoreTable extends VirtualTable {
      * objects before PK extraction, serialization, and index-key construction.
      */
     coerceRow(row) {
-        const cols = this.tableSchema.columns;
-        if (row.length > cols.length) {
-            throw new QuereusError(`Too many values for ${this.schemaName}.${this.tableName}: expected ${cols.length}, got ${row.length}`, StatusCode.ERROR);
-        }
-        return row.map((v, i) => validateAndParse(v, cols[i].logicalType, cols[i].name));
+        return coerceRowToSchema(row, this.tableSchema.columns, `${this.schemaName}.${this.tableName}`);
     }
     /**
      * Query the table with optional filters.
@@ -891,6 +1034,22 @@ export class StoreTable extends VirtualTable {
     leadingPkRangeIsOrderSafe() {
         return pkOrderPreservingPrefixLength(this.db, this.tableSchema, this.pkKeyCollations, this.encodeOptions.collation ?? 'NOCASE') >= 1;
     }
+    /**
+     * True when some PK member's logical type carries semantic ordering (TIMESPAN,
+     * JSON). Such PKs decline the point arm and full-scan, where
+     * {@link matchesFilters} applies the type's compare. Historically required —
+     * byte-key equality was a strict subset of the type's equality ('PT1H' ≡
+     * 'PT60M' elapsed-time-equal, byte-distinct) and a point window under-fetched
+     * with no residual able to resurrect a skipped row. Both types' key transforms
+     * (see {@link storeSemanticKeyTransform}) now make byte equality the type's
+     * equality, so the decline is conservative; re-opening is tracked in backlog
+     * `feat-reopen-timespan-store-seeks`. (Range windows and ordering
+     * advertisements are already declined by {@link keyOrderMatchesCollation}.)
+     */
+    pkHasSemanticOrderingMember() {
+        const schema = this.tableSchema;
+        return schema.primaryKeyDefinition.some(def => hasSemanticOrdering(schema.columns[def.index]?.logicalType));
+    }
     /** Analyze filter info to determine PK access pattern. */
     analyzePKAccess(filterInfo) {
         const schema = this.tableSchema;
@@ -912,7 +1071,7 @@ export class StoreTable extends VirtualTable {
                 break;
             }
         }
-        if (allEq) {
+        if (allEq && !this.pkHasSemanticOrderingMember()) {
             return { type: 'point', values: eqValues };
         }
         // Check for range constraints on first PK column
@@ -1068,9 +1227,14 @@ export class StoreTable extends VirtualTable {
             return null;
         const indexCols = index.columns.map(c => c.index);
         const indexDirections = index.columns.map(c => !!c.desc);
-        // Contiguous leading-prefix EQ → point/prefix window.
+        // Contiguous leading-prefix EQ → point/prefix window. A prefix member whose
+        // logical type carries semantic ordering stops the prefix: its byte-equality
+        // window under-fetches the type's equality (see pkHasSemanticOrderingMember),
+        // and a skipped row cannot be resurrected by the residual.
         const eqValues = [];
         for (let i = 0; i < indexCols.length; i++) {
+            if (hasSemanticOrdering(this.tableSchema.columns[indexCols[i]]?.logicalType))
+                break;
             const eq = filterInfo.constraints?.find(c => c.constraint.iColumn === indexCols[i]
                 && c.constraint.op === IndexConstraintOp.EQ
                 && c.argvIndex > 0);
@@ -1225,7 +1389,16 @@ export class StoreTable extends VirtualTable {
             const rowValue = row[constraint.iColumn];
             const filterValue = filterInfo.args[argvIndex - 1];
             const collation = collations.get(constraint.iColumn) ?? BINARY_COLLATION;
-            if (!this.compareValues(rowValue, constraint.op, filterValue, collation)) {
+            // A semantic-ordering column (TIMESPAN, JSON) must filter under the type's
+            // compare — the same order the engine's operators and Sort use — or a pushed
+            // `d > 'PT90M'` would text-compare and drop rows the predicate admits. The
+            // comparator is built per row only on this rare column kind; if a profile
+            // ever shows it, resolve it once per scan alongside the collations.
+            const logicalType = this.tableSchema.columns[constraint.iColumn]?.logicalType;
+            const compare = hasSemanticOrdering(logicalType)
+                ? createTypedComparator(logicalType, collation)
+                : undefined;
+            if (!this.compareValues(rowValue, constraint.op, filterValue, collation, compare)) {
                 return false;
             }
         }
@@ -1296,11 +1469,11 @@ export class StoreTable extends VirtualTable {
      * NULL on either side fails every operator except EQ-with-both-NULL (the
      * internal point-lookup convention; the planner never pushes `= NULL`).
      */
-    compareValues(a, op, b, collationFunc) {
+    compareValues(a, op, b, collationFunc, semanticCompare) {
         if (a === null || b === null) {
             return op === IndexConstraintOp.EQ ? a === b : false;
         }
-        const cmp = compareSqlValuesFast(a, b, collationFunc);
+        const cmp = semanticCompare ? semanticCompare(a, b) : compareSqlValuesFast(a, b, collationFunc);
         switch (op) {
             case IndexConstraintOp.EQ: return cmp === 0;
             case IndexConstraintOp.NE: return cmp !== 0;
@@ -1324,7 +1497,7 @@ export class StoreTable extends VirtualTable {
                     throw new QuereusError('INSERT requires values', StatusCode.MISUSE);
                 const coerced = args.preCoerced ? values : this.coerceRow(values);
                 const pk = this.extractPK(coerced);
-                const key = buildDataKey(pk, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
+                const key = this.encodeDataKey(pk);
                 // Check for existing row (for conflict handling).
                 // Resolve PK-conflict action: statement OR > per-constraint default > ABORT.
                 const pkEffective = args.onConflict ?? resolvePkDefaultConflict(schema) ?? ConflictResolution.ABORT;
@@ -1442,8 +1615,8 @@ export class StoreTable extends VirtualTable {
                 const coerced = args.preCoerced ? values : this.coerceRow(values);
                 const oldPk = this.extractPK(oldKeyValues);
                 const newPk = this.extractPK(coerced);
-                const oldKey = buildDataKey(oldPk, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
-                const newKey = buildDataKey(newPk, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
+                const oldKey = this.encodeDataKey(oldPk);
+                const newKey = this.encodeDataKey(newPk);
                 // Get old row for index updates. Read the effective
                 // (pending-over-committed) image UNCONDITIONALLY — including the trusted
                 // flush path — so an old image written earlier in the same transaction is
@@ -1558,7 +1731,7 @@ export class StoreTable extends VirtualTable {
                 if (!oldKeyValues)
                     throw new QuereusError('DELETE requires oldKeyValues', StatusCode.MISUSE);
                 const pk = this.extractPK(oldKeyValues);
-                const key = buildDataKey(pk, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
+                const key = this.encodeDataKey(pk);
                 // Get old row for index cleanup. Read the effective
                 // (pending-over-committed) image so a row inserted earlier in the same
                 // transaction is seen: this fixes index cleanup, the `-1` stats delta
@@ -1614,6 +1787,9 @@ export class StoreTable extends VirtualTable {
             const indexStore = await this.ensureIndexStore(index.name);
             const indexCols = index.columns.map(c => c.index);
             const indexDirections = index.columns.map(c => !!c.desc);
+            // Canonicalize semantic-ordering index members ('PT1H'/'PT60M' → one key) so a
+            // UNIQUE enforcement seek and delete-then-insert maintenance address one entry.
+            const indexTransforms = resolveIndexKeyTransforms(index, this.tableSchema.columns);
             // Partial index: only rows the predicate unambiguously accepts are
             // indexed (mirrors buildIndexEntries' build-time filtering). Guarding both
             // halves keeps a row that transitions across the predicate scope on UPDATE
@@ -1624,7 +1800,7 @@ export class StoreTable extends VirtualTable {
             // Remove old index entry (only if the old row was within scope).
             if (oldRow && (!predicate || predicate.evaluate(oldRow) === true)) {
                 const oldIndexValues = indexCols.map(i => oldRow[i]);
-                const oldIndexKey = buildIndexKey(oldIndexValues, oldPk, this.encodeOptions, indexDirections, this.pkDirections, this.pkKeyCollations);
+                const oldIndexKey = buildIndexKey(oldIndexValues, oldPk, this.encodeOptions, indexDirections, this.pkDirections, this.pkKeyCollations, indexTransforms, this.pkKeyTransforms);
                 if (inTransaction && this.coordinator) {
                     this.coordinator.delete(oldIndexKey, indexStore);
                 }
@@ -1635,7 +1811,7 @@ export class StoreTable extends VirtualTable {
             // Add new index entry (only if the new row is within scope).
             if (newRow && (!predicate || predicate.evaluate(newRow) === true)) {
                 const newIndexValues = indexCols.map(i => newRow[i]);
-                const newIndexKey = buildIndexKey(newIndexValues, newPk, this.encodeOptions, indexDirections, this.pkDirections, this.pkKeyCollations);
+                const newIndexKey = buildIndexKey(newIndexValues, newPk, this.encodeOptions, indexDirections, this.pkDirections, this.pkKeyCollations, indexTransforms, this.pkKeyTransforms);
                 // Index value = the row's encoded DATA key. The index-entry key can
                 // locate a row's byte window, but its PK suffix is not losslessly
                 // recoverable to SqlValues (a NOCASE/RTRIM PK column encodes lossily)
@@ -1684,16 +1860,36 @@ export class StoreTable extends VirtualTable {
         }
         return compiled;
     }
-    /** Check if two PK arrays are equal. */
+    /**
+     * Check if two PK arrays name the same row. A semantic-ordering member compares
+     * through its type's `compare` (see {@link resolvePkSemanticEquality}) so
+     * differently-spelled equal values ('PT1H' / 'PT60M') answer "same row",
+     * agreeing with the physical key identity {@link encodeDataKey} produces; every
+     * other member keeps the original strict `!==`.
+     */
     keysEqual(a, b) {
         if (a.length !== b.length)
             return false;
         for (let i = 0; i < a.length; i++) {
-            if (a[i] !== b[i])
+            const semantic = this.pkSemanticEquality[i];
+            if (semantic ? semantic(a[i], b[i]) !== 0 : a[i] !== b[i])
                 return false;
         }
         return true;
     }
+    /**
+     * Per-constrained-column comparison functions for one UNIQUE constraint: the
+     * type's `compare` for a semantic-ordering column (so 'PT1H' conflicts with
+     * 'PT60M', matching the memory backend's typed BTree), else the enforcement
+     * collation the caller resolved (`resolveUniqueEnforcementCollations`) through
+     * `compareSqlValuesFast` — the exact comparison every finder used before.
+     *
+     * Thin wrapper over the engine's `uniqueEnforcementComparators`, which memory
+     * and the isolation overlay share so the three backends cannot drift.
+     */
+    uniqueColumnComparators(uc, collations) {
+        return uniqueEnforcementComparators(this.tableSchema.columns, uc.columns, collations);
+    }
     /**
      * Returns true if any column covered by a UNIQUE constraint differs between
      * oldRow and newRow, or — for partial UNIQUE — any column referenced by the
@@ -1927,7 +2123,10 @@ export class StoreTable extends VirtualTable {
         // unregistered name and cannot be inlined, so a per-candidate call would be
         // pure overhead.
         const collations = resolveUniqueEnforcementCollations(this.tableSchema, uc, this.collationResolver);
-        const bounds = buildIndexPrefixBounds(uc.columns.map(c => newRow[c]), this.encodeOptions, index.columns.map(c => !!c.desc));
+        const compares = this.uniqueColumnComparators(uc, collations);
+        // Same per-column transforms `updateSecondaryIndexes` wrote the entries under, so
+        // the probe for 'PT60M' lands on the window holding the 'PT1H' entry.
+        const bounds = buildIndexPrefixBounds(uc.columns.map(c => newRow[c]), this.encodeOptions, index.columns.map(c => !!c.desc), resolveIndexKeyTransforms(index, this.tableSchema.columns));
         for await (const entry of this.iterateEffective(indexStore, bounds)) {
             // A legacy index store (written before index values carried the data key)
             // holds EMPTY values. `scanIndex` may skip such an entry — a read that
@@ -1944,7 +2143,7 @@ export class StoreTable extends VirtualTable {
             const pk = this.extractPK(candidate);
             if (selfPks.some(skip => this.keysEqual(pk, skip)))
                 continue;
-            if (uc.columns.some((c, i) => compareSqlValuesFast(newRow[c], candidate[c], collations[i]) !== 0))
+            if (uc.columns.some((c, i) => compares[i](newRow[c], candidate[c]) !== 0))
                 continue;
             if (predicate && predicate.evaluate(candidate) !== true)
                 continue;
@@ -1971,6 +2170,7 @@ export class StoreTable extends VirtualTable {
         // COLLATE for an index-derived UNIQUE, else the declared column collation.
         // Resolved once here, not per candidate row.
         const collations = resolveUniqueEnforcementCollations(this.tableSchema, uc, this.collationResolver);
+        const compares = this.uniqueColumnComparators(uc, collations);
         const matches = (candidate) => {
             const pk = this.extractPK(candidate);
             for (const skip of selfPks) {
@@ -1979,7 +2179,7 @@ export class StoreTable extends VirtualTable {
             }
             for (let i = 0; i < constrainedCols.length; i++) {
                 const idx = constrainedCols[i];
-                if (compareSqlValuesFast(newRow[idx], candidate[idx], collations[i]) !== 0)
+                if (compares[i](newRow[idx], candidate[idx]) !== 0)
                     return null;
             }
             // Partial UNIQUE: candidate must also be in the predicate's scope to conflict.
@@ -2024,6 +2224,7 @@ export class StoreTable extends VirtualTable {
         const newSourcePk = this.extractPK(newRow);
         // Resolved once, above the candidate loop.
         const collations = resolveUniqueEnforcementCollations(this.tableSchema, uc, this.collationResolver);
+        const compares = this.uniqueColumnComparators(uc, collations);
         const candidates = await this.db._lookupCoveringConflicts(mv, uc, newRow, newSourcePk);
         for (const cand of candidates) {
             const liveRow = await this.readLiveRowByPk(cand.pk);
@@ -2041,7 +2242,7 @@ export class StoreTable extends VirtualTable {
             // index over a BINARY column) is declined upstream by the collation gate in
             // findRowTimeCoveringStructure, so only BINARY-floor or equal-collation MVs
             // reach here — the superset this re-validation can soundly filter.
-            if (uc.columns.some((c, i) => compareSqlValuesFast(newRow[c], liveRow[c], collations[i]) !== 0))
+            if (uc.columns.some((c, i) => compares[i](newRow[c], liveRow[c]) !== 0))
                 continue;
             if (predicate && predicate.evaluate(liveRow) !== true)
                 continue;
@@ -2065,7 +2266,7 @@ export class StoreTable extends VirtualTable {
     // the table's own read/write paths.
     /** Encode `pkValues` (in PK-definition order) exactly as the data store keys rows. */
     encodeDataKey(pkValues) {
-        return buildDataKey(pkValues, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
+        return buildDataKey(pkValues, this.encodeOptions, this.pkDirections, this.pkKeyCollations, this.pkKeyTransforms);
     }
     /**
      * Byte bounds covering every data key whose leading PK columns equal
@@ -2074,7 +2275,7 @@ export class StoreTable extends VirtualTable {
      * exact slice. An empty prefix yields full-scan bounds.
      */
     encodePkPrefixBounds(prefixValues) {
-        return buildPkPrefixBounds(prefixValues, this.encodeOptions, this.pkDirections.slice(0, prefixValues.length), this.pkKeyCollations.slice(0, prefixValues.length));
+        return buildPkPrefixBounds(prefixValues, this.encodeOptions, this.pkDirections.slice(0, prefixValues.length), this.pkKeyCollations.slice(0, prefixValues.length), this.pkKeyTransforms.slice(0, prefixValues.length));
     }
     /**
      * Effective (pending-over-committed) point read by encoded data key: a pending
@@ -2284,7 +2485,7 @@ export class StoreTable extends VirtualTable {
      */
     async deleteRowAt(inTransaction, pk, oldRow) {
         const store = await this.ensureStore();
-        const key = buildDataKey(pk, this.encodeOptions, this.pkDirections, this.pkKeyCollations);
+        const key = this.encodeDataKey(pk);
         if (inTransaction && this.coordinator) {
             this.coordinator.delete(key, store);
         }