@quereus/isolation 4.3.1 → 4.3.2

package/README.md

@@ -4,12 +4,12 @@ Generic transaction isolation layer for Quereus virtual table modules.
 
 ## Overview
 
-The `@quereus/isolation` package provides MVCC-style transaction isolation semantics for any Quereus virtual table module. It wraps existing modules to add:
+The `@quereus/isolation` package provides connection-level transaction isolation for any Quereus virtual table module. It wraps existing modules to add:
 
 - **Read-your-own-writes** — See uncommitted changes within your transaction
-- **Snapshot isolation** — Consistent reads throughout the transaction
+- **Read-committed reads of shared state** — Reads merge against the *live* underlying table, so another connection's committed writes can become visible mid-transaction. This is **not** snapshot isolation — reads are not a stable point-in-time view. A stable snapshot, if needed, is the job of whatever module is layered beneath this one (see [Isolation Level](#isolation-level) below).
 - **Savepoint support** — Nested transaction control
-- **ACID semantics** — Full transaction guarantees
+- **No write-write conflict detection** — Concurrent writers to the same row are not detected; the last connection to flush wins.
 
 This allows module authors to focus on storage concerns while getting isolation "for free."
 
@@ -80,6 +80,26 @@ The isolation layer operates at the **row level**, merging query results from tw
 └─────────────────────────────────────────────────────────┘
 ```
 
+## Isolation Level
+
+The guarantee this layer actually provides is closer to **read-committed with
+read-your-own-writes** than to snapshot isolation:
+
+- **Read-your-own-writes** — a connection always sees its own uncommitted overlay
+  changes.
+- **Live reads of shared state** — the merged read path queries the *live* underlying
+  table on every read, not a point-in-time copy taken at `BEGIN`. If another
+  connection commits mid-transaction, the next read in this transaction can observe
+  that write. Reads are **not** isolated from concurrent commits.
+- **No write-write conflict detection** — two connections that write the same row in
+  overlapping transactions are not detected as conflicting; whichever connection
+  flushes (commits) last overwrites the other.
+- **Snapshotting is delegated downward** — if a consumer needs a stable, point-in-time
+  view of the data, that guarantee must come from the module wrapped *beneath* this
+  layer (the `underlying` module), not from `IsolationModule` itself. A future
+  optional snapshotting pass-through module may be added below the isolation layer
+  for consumers that need this; it does not exist today.
+
 ### Key Features
 
 **Per-connection overlay** — Each database instance gets its own overlay storage, ensuring proper isolation between connections.
@@ -90,8 +110,8 @@ The isolation layer operates at the **row level**, merging query results from tw
 
 **Atomic ALTER (issuer-faithful) + cross-connection poison** — DDL through Quereus is not transaction-scoped and the shared underlying base auto-commits its mutation immediately, so a half-applied ALTER cannot be rolled back. The blast radius is isolation-faithful — an ALTER never depends on another connection's uncommitted data:
 
-- **Issuer's own overlay** — `IsolationModule.alterTable` dry-run **validates the issuing connection's own affected overlay's backfill** (per-row `NOT NULL` checks and the tombstone-present guard) *before* mutating the underlying. A rejection fires while the underlying, the schema catalog, and every overlay are still untouched, so for the issuer an ADD COLUMN either fails clean or fully applies — base and catalog never diverge. (The issuer staged both the data and the DDL, so rejecting up front is the least-surprising behavior.)
-- **Another connection's overlay** — the shared underlying and the catalog change regardless of any *other* connection's uncommitted state. A foreign overlay that *can* migrate is carried forward as usual; one that *cannot* (its staged row can't satisfy the new `NOT NULL` column) is left in place and marked **poisoned**. Its owning connection then raises a `CONSTRAINT` error the next time it reads (merged), writes, or commits that table, and recovers by rolling back (which discards the overlay and its poison). A committed-snapshot (`committed.<table>`) read bypasses the overlay and keeps working. A layer-invariant violation (e.g. a missing tombstone column, `INTERNAL`) still rethrows loud for everyone rather than poisoning.
+- **Issuer's own overlay** — `IsolationModule.alterTable` dry-run **validates the issuing connection's own affected overlay's backfill** (per-row `NOT NULL` checks — for a new `ADD COLUMN ... NOT NULL` and for tightening an existing column with `ALTER COLUMN ... SET NOT NULL` — and the tombstone-present guard) *before* mutating the underlying. A rejection fires while the underlying, the schema catalog, and every overlay are still untouched, so for the issuer the ALTER either fails clean or fully applies — base and catalog never diverge. (The issuer staged both the data and the DDL, so rejecting up front is the least-surprising behavior.)
+- **Another connection's overlay** — the shared underlying and the catalog change regardless of any *other* connection's uncommitted state. A foreign overlay that *can* migrate is carried forward as usual (a staged `NULL` is backfilled when a usable literal `DEFAULT` exists); one that *cannot* (its staged row can't satisfy the new or newly-`NOT NULL` column) is left in place and marked **poisoned**. Its owning connection then raises a `CONSTRAINT` error the next time it reads (merged), writes, or commits that table, and recovers by rolling back (which discards the overlay and its poison). A committed-snapshot (`committed.<table>`) read bypasses the overlay and keeps working. A layer-invariant violation (e.g. a missing tombstone column, `INTERNAL`) still rethrows loud for everyone rather than poisoning.
 
 **Configurable overlay module** — Use memory for fast transactions, or persistent storage for large transactions:
 

package/dist/src/filter-info.d.ts

@@ -0,0 +1,34 @@
+import type { FilterInfo, SqlValue, TableIndexSchema } from '@quereus/quereus';
+import { makeFullScanFilterInfo } from '@quereus/quereus';
+/**
+ * Creates a FilterInfo for a full table scan (no constraints).
+ *
+ * Shared by the overlay-merge read paths, the ALTER/DROP INDEX overlay
+ * migrations, and the commit flush — a single definition keeps the several
+ * scan sites from drifting. Delegates to the engine's builder so the overlay
+ * scans present the same access path the planner would.
+ */
+export { makeFullScanFilterInfo };
+/**
+ * Creates a FilterInfo for a primary key point lookup (equality on all PK
+ * columns). Produces O(log n) lookups instead of O(n) full scans.
+ *
+ * The overlay always names its primary-key index `_primary_`, so the descriptor is
+ * built here rather than resolved from a schema.
+ */
+export declare function makePkPointLookupFilter(pkIndices: number[], pk: SqlValue[]): FilterInfo;
+/**
+ * Creates a FilterInfo for an equality seek over a secondary `index`, binding each of
+ * the index's key columns to `newRow`'s value for that column. Produces an O(log n)
+ * index lookup for the isolation layer's UNIQUE-conflict check instead of a full scan.
+ *
+ * The seek values are read in INDEX-KEY order (`index.columns[i].index`), which need
+ * not match the UNIQUE constraint's `columns` order — so read off the index, never
+ * assume the two arrays agree.
+ *
+ * The built `constraints` carry an EQ per key column, so a module that ignores the
+ * `idxStr` index hint still applies the equalities as a residual filter rather than
+ * returning the whole table.
+ */
+export declare function makeSecondaryIndexEqSeekFilter(index: TableIndexSchema, newRow: readonly SqlValue[]): FilterInfo;
+//# sourceMappingURL=filter-info.d.ts.map

package/dist/src/filter-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-info.d.ts","sourceRoot":"","sources":["../../src/filter-info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmB,QAAQ,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAChG,OAAO,EAAsB,sBAAsB,EAA6B,MAAM,kBAAkB,CAAC;AAEzG;;;;;;;GAOG;AACH,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAElC;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,UAAU,CAQvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,SAAS,QAAQ,EAAE,GAAG,UAAU,CAU/G"}

package/dist/src/filter-info.js

@@ -0,0 +1,51 @@
+import { PRIMARY_INDEX_NAME, makeFullScanFilterInfo, makeIndexEqSeekFilterInfo } from '@quereus/quereus';
+/**
+ * Creates a FilterInfo for a full table scan (no constraints).
+ *
+ * Shared by the overlay-merge read paths, the ALTER/DROP INDEX overlay
+ * migrations, and the commit flush — a single definition keeps the several
+ * scan sites from drifting. Delegates to the engine's builder so the overlay
+ * scans present the same access path the planner would.
+ */
+export { makeFullScanFilterInfo };
+/**
+ * Creates a FilterInfo for a primary key point lookup (equality on all PK
+ * columns). Produces O(log n) lookups instead of O(n) full scans.
+ *
+ * The overlay always names its primary-key index `_primary_`, so the descriptor is
+ * built here rather than resolved from a schema.
+ */
+export function makePkPointLookupFilter(pkIndices, pk) {
+    const index = {
+        name: PRIMARY_INDEX_NAME,
+        role: 'primary',
+        keyColumns: pkIndices.map(columnIndex => ({ columnIndex, desc: false })),
+        unique: true,
+    };
+    return makeIndexEqSeekFilterInfo(index, pkIndices, pk);
+}
+/**
+ * Creates a FilterInfo for an equality seek over a secondary `index`, binding each of
+ * the index's key columns to `newRow`'s value for that column. Produces an O(log n)
+ * index lookup for the isolation layer's UNIQUE-conflict check instead of a full scan.
+ *
+ * The seek values are read in INDEX-KEY order (`index.columns[i].index`), which need
+ * not match the UNIQUE constraint's `columns` order — so read off the index, never
+ * assume the two arrays agree.
+ *
+ * The built `constraints` carry an EQ per key column, so a module that ignores the
+ * `idxStr` index hint still applies the equalities as a residual filter rather than
+ * returning the whole table.
+ */
+export function makeSecondaryIndexEqSeekFilter(index, newRow) {
+    const descriptor = {
+        name: index.name,
+        role: 'secondary',
+        keyColumns: index.columns.map(c => ({ columnIndex: c.index, desc: !!c.desc, collation: c.collation })),
+        unique: true,
+    };
+    const seekColumnIndexes = index.columns.map(c => c.index);
+    const values = seekColumnIndexes.map(i => newRow[i]);
+    return makeIndexEqSeekFilterInfo(descriptor, seekColumnIndexes, values);
+}
+//# sourceMappingURL=filter-info.js.map

package/dist/src/filter-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-info.js","sourceRoot":"","sources":["../../src/filter-info.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAEzG;;;;;;;GAOG;AACH,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAElC;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAmB,EAAE,EAAc;IAC1E,MAAM,KAAK,GAAoB;QAC9B,IAAI,EAAE,kBAAkB;QACxB,IAAI,EAAE,SAAS;QACf,UAAU,EAAE,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACxE,MAAM,EAAE,IAAI;KACZ,CAAC;IACF,OAAO,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,8BAA8B,CAAC,KAAuB,EAAE,MAA2B;IAClG,MAAM,UAAU,GAAoB;QACnC,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,IAAI,EAAE,WAAW;QACjB,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;QACtG,MAAM,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,iBAAiB,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,OAAO,yBAAyB,CAAC,UAAU,EAAE,iBAAiB,EAAE,MAAM,CAAC,CAAC;AACzE,CAAC"}

package/dist/src/flush.d.ts

@@ -0,0 +1,36 @@
+import type { SqlValue, UpdateResult, RowOp, VirtualTable } from '@quereus/quereus';
+/**
+ * Applies every staged overlay row to the underlying table WITHOUT committing.
+ *
+ * This is the *apply-only* half of the isolation commit flush. It begins a
+ * transaction on the underlying table and writes each overlay entry (tombstones
+ * as deletes, live rows as insert/update), but deliberately leaves the
+ * underlying transaction OPEN. Committing per table here is exactly what tears a
+ * multi-table commit (table A durably commits before table B applies), so the
+ * commit is factored out to {@link IsolationModule.commitConnectionOverlays},
+ * which drives one apply-all pass followed by one commit-all pass across every
+ * table the db-transaction touched.
+ *
+ * Preserves the original per-table flush semantics:
+ * - Deletes (tombstones) are applied before inserts/updates so a write colliding
+ *   on a secondary UNIQUE with a row being deleted in the same flush sees the
+ *   slot freed first. Each PK appears at most once in the overlay, so there is no
+ *   same-PK delete-then-insert pair this reordering could invert; sort() is
+ *   stable in V8/Node, preserving the original PK order within each group.
+ * - Data writes use `preCoerced`/`trustedWrite` (the overlay already coerced and
+ *   constraint-checked them in the merged view).
+ * - A post-precheck constraint result is a loud INTERNAL error (see
+ *   {@link assertFlushWriteOk}), never silently dropped.
+ */
+export declare function applyOverlayToUnderlying(underlyingTable: VirtualTable, overlayTable: VirtualTable, tombstoneColumn: string): Promise<void>;
+/**
+ * Asserts that an underlying write performed during the commit flush succeeded.
+ *
+ * The overlay's merged-view pre-checks resolve every constraint before commit, so
+ * a `constraint` result here means a real invariant was violated *after* those
+ * checks. Historically this result was discarded, silently dropping the colliding
+ * write and surfacing as data corruption. Convert it into a loud INTERNAL error;
+ * the caller's coordinator rolls back the flush and rethrows.
+ */
+export declare function assertFlushWriteOk(result: UpdateResult, operation: RowOp, pk: SqlValue[], tableName: string): void;
+//# sourceMappingURL=flush.d.ts.map

package/dist/src/flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flush.d.ts","sourceRoot":"","sources":["../../src/flush.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAKpF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,wBAAwB,CAC7C,eAAe,EAAE,YAAY,EAC7B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CA2Df;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAOlH"}

package/dist/src/flush.js

@@ -0,0 +1,110 @@
+import { QuereusError, StatusCode, isConstraintViolation } from '@quereus/quereus';
+import { makePkPointLookupFilter } from './filter-info.js';
+import { collectOverlayEntries } from './overlay-rows.js';
+/**
+ * Applies every staged overlay row to the underlying table WITHOUT committing.
+ *
+ * This is the *apply-only* half of the isolation commit flush. It begins a
+ * transaction on the underlying table and writes each overlay entry (tombstones
+ * as deletes, live rows as insert/update), but deliberately leaves the
+ * underlying transaction OPEN. Committing per table here is exactly what tears a
+ * multi-table commit (table A durably commits before table B applies), so the
+ * commit is factored out to {@link IsolationModule.commitConnectionOverlays},
+ * which drives one apply-all pass followed by one commit-all pass across every
+ * table the db-transaction touched.
+ *
+ * Preserves the original per-table flush semantics:
+ * - Deletes (tombstones) are applied before inserts/updates so a write colliding
+ *   on a secondary UNIQUE with a row being deleted in the same flush sees the
+ *   slot freed first. Each PK appears at most once in the overlay, so there is no
+ *   same-PK delete-then-insert pair this reordering could invert; sort() is
+ *   stable in V8/Node, preserving the original PK order within each group.
+ * - Data writes use `preCoerced`/`trustedWrite` (the overlay already coerced and
+ *   constraint-checked them in the merged view).
+ * - A post-precheck constraint result is a loud INTERNAL error (see
+ *   {@link assertFlushWriteOk}), never silently dropped.
+ */
+export async function applyOverlayToUnderlying(underlyingTable, overlayTable, tombstoneColumn) {
+    if (!overlayTable.query) {
+        // No overlay rows to read — still begin so the coordinator has a live
+        // underlying transaction to commit/roll back consistently with peers.
+        await underlyingTable.begin?.();
+        return;
+    }
+    const underlyingSchema = underlyingTable.tableSchema;
+    if (!underlyingSchema) {
+        throw new QuereusError('Underlying table has no schema', StatusCode.INTERNAL);
+    }
+    const pkIndices = underlyingSchema.primaryKeyDefinition.map(pkDef => pkDef.index);
+    const tableName = underlyingSchema.name;
+    // Collect all overlay entries first.
+    const overlayEntries = await collectOverlayEntries(overlayTable, tombstoneColumn, pkIndices);
+    // Begin the underlying transaction (idempotent for a shared-coordinator store)
+    // before applying — and unconditionally, so the coordinator's applied-table set
+    // is accurate even for a (degenerate) empty overlay.
+    await underlyingTable.begin?.();
+    if (overlayEntries.length === 0)
+        return;
+    // Deletes before inserts/updates (see doc comment above).
+    const ordered = [...overlayEntries].sort((a, b) => (a.isTombstone === b.isTombstone ? 0 : a.isTombstone ? -1 : 1));
+    for (const entry of ordered) {
+        if (entry.isTombstone) {
+            const result = await underlyingTable.update({
+                operation: 'delete',
+                values: undefined,
+                oldKeyValues: entry.pk,
+            });
+            assertFlushWriteOk(result, 'delete', entry.pk, tableName);
+        }
+        else {
+            // Insert vs update decided by whether the row already exists underlying.
+            const existsInUnderlying = await rowExistsInUnderlying(underlyingTable, pkIndices, entry.pk);
+            if (existsInUnderlying) {
+                const result = await underlyingTable.update({
+                    operation: 'update',
+                    values: entry.dataRow,
+                    oldKeyValues: entry.pk,
+                    preCoerced: true,
+                    trustedWrite: true,
+                });
+                assertFlushWriteOk(result, 'update', entry.pk, tableName);
+            }
+            else {
+                const result = await underlyingTable.update({
+                    operation: 'insert',
+                    values: entry.dataRow,
+                    preCoerced: true,
+                    trustedWrite: true,
+                });
+                assertFlushWriteOk(result, 'insert', entry.pk, tableName);
+            }
+        }
+    }
+}
+/**
+ * Checks if a row with the given primary key exists in the underlying table.
+ * Uses an O(log n) point lookup via the PK index.
+ */
+async function rowExistsInUnderlying(underlyingTable, pkIndices, pk) {
+    if (!underlyingTable.query)
+        return false;
+    for await (const _row of underlyingTable.query(makePkPointLookupFilter(pkIndices, pk))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Asserts that an underlying write performed during the commit flush succeeded.
+ *
+ * The overlay's merged-view pre-checks resolve every constraint before commit, so
+ * a `constraint` result here means a real invariant was violated *after* those
+ * checks. Historically this result was discarded, silently dropping the colliding
+ * write and surfacing as data corruption. Convert it into a loud INTERNAL error;
+ * the caller's coordinator rolls back the flush and rethrows.
+ */
+export function assertFlushWriteOk(result, operation, pk, tableName) {
+    if (isConstraintViolation(result)) {
+        throw new QuereusError(`Isolation flush ${operation} on '${tableName}' (pk=[${pk.join(', ')}]) hit a ${result.constraint} constraint: ${result.message ?? 'no message'}. The overlay merged-view pre-checks should have resolved this before commit; this indicates an isolation-layer invariant violation.`, StatusCode.INTERNAL);
+    }
+}
+//# sourceMappingURL=flush.js.map

package/dist/src/flush.js.map

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