@minnowdb/core 0.4.1 → 0.6.0

package/dist/engine/database.js

@@ -1,26 +1,28 @@
 import { toColumnarBatch, } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
+import { throwIfAborted } from "./cancellation.js";
 import { BufferedTableWriter } from "./buffered-writer.js";
 export { attachLifecycleFlush, BufferedTableWriter, MAX_BUFFERED_WRITER_PENDING_ADDS, } from "./buffered-writer.js";
-import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
+import { CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, DatabaseReadBacklogError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, UniqueConstraintError, VisibleSegmentCursorStaleError, } from "./errors.js";
+export { DatabaseReadBacklogError } from "./errors.js";
 import { BLOCK_HEADER_LENGTH, buildPhysicalColumnFromRanges, decodeBlock, decodePhysicalBlock, encodeBlock, encodePhysicalBlock, getCompressionMemoryBound, inspectBlock, maximumPhysicalBlockByteLength, MAX_BLOCK_METADATA_BYTE_LENGTH, MAX_BLOCK_ROW_COUNT, MAX_PHYSICAL_COLUMN_BYTE_LENGTH, MAX_STORED_BLOCK_BYTE_LENGTH, measurePhysicalColumnRanges, physicalColumnByteLength, slicePhysicalColumn, StoredBlockPayloadTooLargeError, wellFormedUtf8ByteLength, } from "../block-format/index.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { estimateCompactionRowsPerOutput, planAlignedWriteBlockRanges as writeBlockRanges, } from "./write-block-planner.js";
-import { MAX_CACHEABLE_TEXT_CHARACTERS } from "./cache-limits.js";
+import { MAX_CACHEABLE_TEXT_CHARACTERS, MAX_SQL_PARAMETERS } from "./cache-limits.js";
 import { fillColumnDefaults, patchAutoIncrementValues, } from "./defaults.js";
 import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize as ftsTokenize, } from "./fts.js";
 import { boundedMaintenanceBatchItems, simpleDataTypes, floorWholeNumberProduct, BlockReadBatchTooLargeError, validateColumnDefault, validateEnumValues, secondaryIndexColumnIds, secondaryIndexDirections, secondaryUniqueKeyNamespace, CompactionJobConflictError, CompactionBacklogError, GarbageCollectionJobConflictError, MAX_LEVEL_ZERO_SEGMENTS, MAX_FTS_CANDIDATE_ROW_IDS, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_INDEXED_STRING_CHARACTERS, MAX_CATALOG_NAME_CHARACTERS, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MAINTENANCE_BATCH_ITEMS, MAX_STORAGE_BULK_READ_ITEMS, MAX_TRANSACTION_STAGE_BLOCKS, MAX_TRANSACTION_STAGE_BYTES, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_POSTING_BUILD_TTL_MS, MAX_TEMP_OWNER_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, SNAPSHOT_FRAME_KINDS, validateStorageId, SnapshotManifestMissingError, SchemaConflictError, TableInUseError, TableRecordConflictError, TransactionRecordConflictError, UniqueKeyConflictError, UniqueIndexCoverageError, WriteConflictError, } from "../storage/types.js";
 import { decodeSnapshotFrameStream, encodeSnapshotFrameStreamFooter, encodeSnapshotFrameStreamHeader, extendSnapshotFrameStreamChecksum, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity, } from "../storage/snapshot.js";
 import { Snapshot, TransactionManager, } from "../transactions/index.js";
-import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, compileStatement, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
+import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, } from "./query.js";
 import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, DEFAULT_QUERY_MEMORY_BUDGET_BYTES, } from "./memory.js";
 import { LiveQueryLimitError, LiveQuerySet, MAX_LIVE_QUERY_SETS_PER_DATABASE, } from "./live.js";
 import { chooseJoinOrder, renderPlan } from "./optimizer.js";
 import { encodeSqlEqualityValue } from "./sql-semantics.js";
-import { externalSqlDomainValue, externalSqlTextValue, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
+import { externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
-import { applyColumnSteps, assertColumnDroppable, declaredForeignKeys, isDestructiveStep, planMigration, } from "./schema.js";
+import { applyColumnSteps, assertColumnDroppable, compileGeneratedColumnExpression, declaredForeignKeys, isDestructiveStep, planMigration, } from "./schema.js";
 import { columnarTableFromRows, createColumnarTable, vectorValue, } from "./vector.js";
 // The on-disk format is little-endian; the bulk Float64 copy reads platform order.
 const PLATFORM_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
@@ -103,14 +105,6 @@ export const MAX_TRANSACTION_SAVEPOINT_BYTES = 8 * 1024 * 1024;
 export const MAX_DATABASE_PENDING_WRITES = 64;
 /** Concurrent direct reads retained by one database instance. Reads still execute in parallel. */
 export const MAX_DATABASE_ACTIVE_READS = 256;
-export class DatabaseReadBacklogError extends Error {
-    limit;
-    name = "DatabaseReadBacklogError";
-    constructor(limit = MAX_DATABASE_ACTIVE_READS) {
-        super(`A database cannot retain more than ${String(limit)} active reads; await a read`);
-        this.limit = limit;
-    }
-}
 /** Commits tolerated while collection fails before foreground writes assist and backpressure. */
 const AUTO_COLLECT_MAX_DEBT_COMMITS = 4_096;
 /** Failed background passes retry without another write, with bounded exponential backoff. */
@@ -272,7 +266,7 @@ function migrationResult(steps) {
     };
 }
 export const MAX_GARBAGE_COLLECTION_RETAIN_RECENT_VERSIONS = 1_024;
-export { CompactionBacklogError, CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, TableInUseError, UniqueConstraintError, VisibleSegmentCursorStaleError, };
+export { CompactionBacklogError, CompactionJobCancelledError, CompactionMemoryBudgetError, CompactionWriteAmplificationError, MaintenanceBacklogError, MissingKeyError, SqlCompileError, UnknownTableError, TableInUseError, UniqueConstraintError, VisibleSegmentCursorStaleError, };
 /**
  * How deep a delete's referential actions may cascade. A chain of CASCADE keys can reach further
  * tables; the bound stops a cycle from recursing, the same way the trigger chain is bounded.
@@ -291,13 +285,29 @@ function isTransactionalStatement(statement) {
         statement.kind === "delete" ||
         statement.kind === "select");
 }
+function returningExecuteFields(table, columns, rows) {
+    return {
+        returnedRows: rows,
+        returnedColumns: [...columns],
+        returnedColumnDomains: columns.map((name) => table.columns.find((column) => column.name === name)?.sqlDomain ?? null),
+    };
+}
 function externalizeExecuteResult(result) {
     if (!("returnedRows" in result) || !Array.isArray(result.returnedRows))
         return result;
-    const columns = [...new Set(result.returnedRows.flatMap((row) => Object.keys(row)))];
+    const columns = result.returnedColumns ?? [
+        ...new Set(result.returnedRows.flatMap((row) => Object.keys(row))),
+    ];
+    const columnDomains = result.returnedColumnDomains ?? unknownColumnDomains(columns);
     return {
         ...result,
-        returnedRows: externalizeQueryResult({ columns, rows: result.returnedRows }).rows,
+        returnedRows: externalizeQueryResult({
+            columns,
+            columnDomains,
+            rows: result.returnedRows,
+        }).rows,
+        returnedColumns: [...columns],
+        returnedColumnDomains: structuredClone(columnDomains),
     };
 }
 /** Rejects an INSERT value that is still an unbound `?`/`$n` slot. */
@@ -567,6 +577,8 @@ export class MinnowDatabase {
     #droppingTables = new Set();
     /** Per table: the visible segment count a failed auto-compaction must see before retrying. */
     #autoCompactionBackoff = new Map();
+    /** Exact current-layout counters; local commits advance them without rescanning history. */
+    #autoCompactionHints = new Map();
     /** Data commits per table since its last write-path auto-compaction check. */
     #commitsSinceCompactionCheck = new Map();
     /** The compaction step in flight per table, so steps on one table run one at a time. */
@@ -745,6 +757,7 @@ export class MinnowDatabase {
         this.#autoCompactionsRequested.clear();
         this.#idleCompactionTableIds.clear();
         this.#autoCompactionBackoff.clear();
+        this.#autoCompactionHints.clear();
         this.#commitsSinceCompactionCheck.clear();
         this.#artifactCache.clear();
     }
@@ -809,6 +822,9 @@ export class MinnowDatabase {
                 ...(sqlDomain === undefined ? {} : { sqlDomain: structuredClone(sqlDomain) }),
                 nullable: column.nullable ?? false,
                 ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
+                ...(column.generatedValue === undefined
+                    ? {}
+                    : { generatedValue: structuredClone(column.generatedValue) }),
                 ...(column.enumValues === undefined
                     ? {}
                     : { enumValues: validateEnumValues(column.enumValues, columnName) }),
@@ -867,6 +883,15 @@ export class MinnowDatabase {
             throw new TypeError(`Unique key cannot be nullable: ${uniqueKeyColumn.name}`);
         }
         for (const column of columns) {
+            if (column.generatedValue !== undefined) {
+                if (column.defaultValue !== undefined || column.backfill !== undefined) {
+                    throw new TypeError(`A generated column cannot also have a default or backfill: ${name}.${column.name}`);
+                }
+                compileGeneratedColumnExpression(name, column.name, column.generatedValue.sql, columns);
+                if (column === uniqueKeyColumn || compositePrimaryColumns.includes(column)) {
+                    throw new TypeError(`Generated columns cannot be row-addressing keys: ${name}.${column.name}`);
+                }
+            }
             if (column.defaultValue !== undefined) {
                 validateColumnDefault({ ...column, isUniqueKey: column === uniqueKeyColumn }, column.defaultValue);
                 if (column.defaultValue.kind === "literal" && column.sqlDomain !== undefined) {
@@ -894,6 +919,9 @@ export class MinnowDatabase {
         const checkNames = (input.checks ?? []).map((check) => claimConstraintName(check.name));
         const uniqueConstraintNames = (input.uniqueConstraints ?? []).map((constraint) => claimConstraintName(constraint.name));
         const foreignKeys = await Promise.all((input.foreignKeys ?? []).map(async (key, keyIndex) => {
+            if (key.enforced === false && key.onDelete !== "restrict") {
+                throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE actions`);
+            }
             const childNames = key.columns ?? [key.column];
             const children = childNames.map((columnName) => {
                 const column = columns.find((candidate) => candidate.name === columnName);
@@ -959,6 +987,7 @@ export class MinnowDatabase {
                 parentTable: key.parentTable,
                 parentColumns: parentNames,
                 onDelete: key.onDelete,
+                ...(key.enforced === false ? { enforced: false } : {}),
             };
         }));
         const checks = (input.checks ?? []).map((check, checkIndex) => {
@@ -1051,6 +1080,9 @@ export class MinnowDatabase {
                         : { sqlDomain: structuredClone(column.sqlDomain) }),
                     nullable: column.nullable,
                     ...(column.defaultValue === undefined ? {} : { defaultValue: column.defaultValue }),
+                    ...(column.generatedValue === undefined
+                        ? {}
+                        : { generatedValue: column.generatedValue }),
                     ...(column.enumValues === undefined ? {} : { enumValues: [...column.enumValues] }),
                 })),
                 ...(uniqueKey === undefined ? {} : { uniqueKey }),
@@ -1121,7 +1153,7 @@ export class MinnowDatabase {
     }
     async #withReadReservation(run) {
         if (this.#activeReadReservations >= MAX_DATABASE_ACTIVE_READS) {
-            throw new DatabaseReadBacklogError();
+            throw new DatabaseReadBacklogError(MAX_DATABASE_ACTIVE_READS);
         }
         this.#activeReadReservations += 1;
         try {
@@ -1132,7 +1164,9 @@ export class MinnowDatabase {
         }
     }
     async #queryWithReadReservation(sql, options) {
+        throwIfAborted(options.signal);
         await this.#settleExpiredStatementTransaction();
+        throwIfAborted(options.signal);
         // An open statement transaction routes through its session, which owns the reservation for
         // the actual execution. Avoid charging the same query twice at this public boundary.
         return this.#openTransaction === undefined
@@ -1383,7 +1417,7 @@ export class MinnowDatabase {
                     throw new TypeError(`${tableName} is a view, not a table`);
                 if (options.ifExists === true)
                     return false;
-                throw new Error(`Table not found: ${tableName}`);
+                throw new UnknownTableError(tableName);
             }
             pinnedTableId ??= table.id;
             if (table.id !== pinnedTableId) {
@@ -1513,7 +1547,7 @@ export class MinnowDatabase {
                 }
                 if (options.ifExists === true)
                     return false;
-                throw new Error(`Table not found: ${tableName}`);
+                throw new UnknownTableError(tableName);
             }
             pinnedTableId ??= table.id;
             if (table.id !== pinnedTableId) {
@@ -1561,6 +1595,7 @@ export class MinnowDatabase {
                 for (const column of table.columns)
                     this.#gzipVerdicts.delete(column.id);
                 this.#autoCompactionBackoff.delete(table.id);
+                this.#autoCompactionHints.delete(table.id);
                 this.#commitsSinceCompactionCheck.delete(table.id);
                 this.#idleCompactionTableIds.delete(table.id);
                 const postingPrefix = `${table.id}/`;
@@ -1596,12 +1631,14 @@ export class MinnowDatabase {
                 : undefined;
             const current = await this.store.getTable(table.id);
             if (current === undefined)
-                throw new TypeError(`Unknown table: ${tableName}`);
+                throw new UnknownTableError(tableName);
             const result = await this.#writeBatch(current, batch, "insert", keys, autoIncrement);
             return { result, batch, generated, autoIncrement, rowCount };
         });
         const { result, batch, generated, autoIncrement, rowCount } = completed;
         collectAutoIncrementGenerated(batch, generated, autoIncrement);
+        if (result.segmentId === null)
+            throw new Error("An insert did not create a segment");
         return {
             tableName: result.tableName,
             segmentId: result.segmentId,
@@ -1624,6 +1661,7 @@ export class MinnowDatabase {
             Object.values(pivoted.columns).find((values) => values.length > 0)?.length ??
             0;
         normalizeDomainBatch(table, filled.batch);
+        fillStoredGeneratedColumns(table, filled.batch, inputRowCount, filled.generated);
         for (const name of filled.generated.keys()) {
             const column = table.columns.find((candidate) => candidate.name === name);
             const values = filled.batch.columns[name];
@@ -1655,35 +1693,49 @@ export class MinnowDatabase {
     async insert(tableName, row) {
         return this.insertBatch(tableName, [row]);
     }
-    upsertBatch(tableName, input) {
-        return this.#withWriteReservation(() => this.#upsertBatchReserved(tableName, input));
+    upsertBatch(tableName, input, options = {}) {
+        return this.#withWriteReservation(() => this.#upsertBatchReserved(tableName, input, options));
     }
-    async #upsertBatchReserved(tableName, input) {
+    async #upsertBatchReserved(tableName, input, options) {
         const completed = await this.#runWrite(async () => {
             const table = await this.#findTable(tableName);
             const keyColumn = getUniqueKeyColumn(table);
             if (keyColumn === undefined) {
                 throw new TypeError(`Table needs a unique key before it can be upserted: ${table.name}`);
             }
-            const { batch, generated, autoIncrement, rowCount } = await this.#fillDefaults(table, input);
+            const { batch, generated, autoIncrement } = await this.#fillDefaults(table, input);
             const deferred = autoIncrement !== undefined && autoIncrement.missingIndexes.length > 0;
             const keys = deferred ? undefined : batchKeys(table, batch);
             const current = await this.store.getTable(table.id);
             if (current === undefined)
-                throw new TypeError(`Unknown table: ${tableName}`);
-            const result = await this.#writeBatch(current, batch, "upsert", keys, autoIncrement);
-            return { result, batch, generated, autoIncrement, rowCount };
+                throw new UnknownTableError(tableName);
+            const result = await this.#writeBatch(current, batch, "upsert", keys, autoIncrement, options.conflictWhere);
+            return { result, batch, generated, autoIncrement };
         });
-        const { result, batch, generated, autoIncrement, rowCount } = completed;
+        const { result, batch, generated, autoIncrement } = completed;
         collectAutoIncrementGenerated(batch, generated, autoIncrement);
+        if (result.acceptedRowIndexes.length !== result.requestedRowCount) {
+            for (const [name, values] of generated) {
+                generated.set(name, result.acceptedRowIndexes.map((index) => values[index] ?? null));
+            }
+        }
         return {
-            ...result,
-            rowCount,
+            tableName: result.tableName,
+            segmentId: result.segmentId,
+            requestedRowCount: result.requestedRowCount,
+            rowCount: result.rowCount,
+            insertedRowCount: result.insertedRowCount,
+            updatedRowCount: result.updatedRowCount,
+            skippedRowCount: result.skippedRowCount,
+            blockCount: result.blockCount,
+            storedBytes: result.storedBytes,
+            version: result.version,
+            metrics: result.metrics,
             ...(generated.size === 0 ? {} : { generatedColumns: Object.fromEntries(generated) }),
         };
     }
-    async upsert(tableName, row) {
-        return this.upsertBatch(tableName, [row]);
+    async upsert(tableName, row, options = {}) {
+        return this.upsertBatch(tableName, [row], options);
     }
     updateBatch(tableName, input) {
         return this.#withWriteReservation(() => this.#updateBatchReserved(tableName, input));
@@ -1696,10 +1748,11 @@ export class MinnowDatabase {
                 throw new TypeError(`Table needs a unique key before rows can be updated: ${table.name}`);
             }
             const normalizedInput = normalizeDomainUpdate(table, input);
+            rejectGeneratedUpdateAssignments(table, normalizedInput);
             const keys = validateUpdateBatch(table, keyColumn, normalizedInput);
             const current = await this.store.getTable(table.id);
             if (current === undefined)
-                throw new TypeError(`Unknown table: ${tableName}`);
+                throw new UnknownTableError(tableName);
             const currentKey = getUniqueKeyColumn(current);
             if (currentKey?.id !== keyColumn.id) {
                 throw new TypeError(`Table unique key changed during update: ${tableName}`);
@@ -1713,6 +1766,10 @@ export class MinnowDatabase {
             changes: Object.fromEntries(Object.entries(changes).map(([name, value]) => [name, [value]])),
         });
     }
+    /** Deletes one row by the table's unique key. */
+    async delete(tableName, key) {
+        return this.deleteBatch(tableName, { keys: [key] });
+    }
     deleteBatch(tableName, input) {
         return this.#withWriteReservation(() => this.#deleteBatchReserved(tableName, input));
     }
@@ -1948,15 +2005,13 @@ export class MinnowDatabase {
     async #writeUpdateBatch(table, keyColumn, input, keys) {
         await this.#assertCompactionCapacity(table);
         const started = performance.now();
-        const logicalBytes = estimateValuesBytes(input.keys) +
-            Object.values(input.changes).reduce((total, values) => total + estimateValuesBytes(values), 0);
+        let logicalBytes;
         // Deferred: the record rides the single-shot commit below unless trigger rows stage first.
         const transaction = await this.#transactions.beginDeferred({ durableSnapshot: false });
         transaction.limitLevelZeroSegments(table.id, MAX_LEVEL_ZERO_SEGMENTS);
         const blockStager = new BoundedWriteBlockStager(transaction);
         const segmentId = this.#createId();
         const columnBlockIds = {};
-        const changedColumns = Object.keys(input.changes).sort();
         let storedBytes = 0;
         let blockCount = 0;
         let encodeMs = 0;
@@ -1965,6 +2020,22 @@ export class MinnowDatabase {
         let retries = 0;
         try {
             await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, keys);
+            const checks = table.checks ?? [];
+            let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+                foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
+            const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (sql, params) => this.#sessionQuery(transaction, sql, { params }), checks.length > 0 ||
+                changedForeignKey ||
+                tableGeneratedExpressions(table).length > 0 ||
+                secondaryIndexUpdateNeedsPreImages(table, input) ||
+                readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
+            input = applyStoredGeneratedUpdateChanges(table, input, preImages);
+            validateUpdateBatch(table, keyColumn, input);
+            changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+                foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
+            logicalBytes =
+                estimateValuesBytes(input.keys) +
+                    Object.values(input.changes).reduce((total, values) => total + estimateValuesBytes(values), 0);
+            const changedColumns = Object.keys(input.changes).sort();
             const columns = [keyColumn, ...changedColumns.map((name) => findColumn(table, name))];
             const plannedColumns = columns.map((column) => writeColumnValues(column.type, column.id === keyColumn.id ? input.keys : (input.changes[column.name] ?? [])));
             const ranges = writeBlockRanges(plannedColumns, input.keys.length, this.#rowsPerBlock, this.#targetBlockBytes);
@@ -1998,12 +2069,6 @@ export class MinnowDatabase {
                 }
                 columnBlockIds[column.id] = blockIds;
             }
-            const checks = table.checks ?? [];
-            const changedForeignKey = (table.foreignKeys ?? []).some((key) => foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
-            const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (sql, params) => this.#sessionQuery(transaction, sql, { params }), checks.length > 0 ||
-                changedForeignKey ||
-                secondaryIndexUpdateNeedsPreImages(table, input) ||
-                readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
             stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
             const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
             if (secondaryDeltas.length > 0) {
@@ -2076,6 +2141,14 @@ export class MinnowDatabase {
                         blockCount,
                         storedBytes,
                         version: manifest.version,
+                        ...(tableGeneratedExpressions(table).length === 0
+                            ? {}
+                            : {
+                                generatedColumns: Object.fromEntries(tableGeneratedExpressions(table).map(({ column }) => [
+                                    column.name,
+                                    (input.changes[column.name] ?? []).map((value) => externalSqlDomainValue(value)),
+                                ])),
+                            }),
                         metrics: createWriteMetrics({
                             logicalBytes,
                             storedBytes,
@@ -2117,12 +2190,13 @@ export class MinnowDatabase {
         }
         throw new Error(`Unique-key lookup returned an inconsistent result: ${table.name}`);
     }
-    async #writeBatch(table, input, kind, keys, autoIncrement) {
+    async #writeBatch(table, input, kind, keys, autoIncrement, conflictWhere) {
         await this.#assertCompactionCapacity(table);
         const started = performance.now();
-        const rowCount = input.columns[table.columns[0]?.name ?? ""]?.length ?? 0;
-        const logicalBytes = estimateBatchBytes(input);
-        const { transaction, rowIds: reservedRowIds, autoIncrementValues, } = await this.#transactions.beginWithReservation({ tableId: table.id, count: rowCount }, autoIncrement === undefined
+        const requestedRowCount = input.columns[table.columns[0]?.name ?? ""]?.length ?? 0;
+        let rowCount = requestedRowCount;
+        let logicalBytes = estimateBatchBytes(input);
+        const { transaction, rowIds: reservedRowIds, autoIncrementValues, } = await this.#transactions.beginWithReservation({ tableId: table.id, count: requestedRowCount }, autoIncrement === undefined
             ? undefined
             : {
                 tableId: table.id,
@@ -2133,11 +2207,14 @@ export class MinnowDatabase {
         transaction.limitLevelZeroSegments(table.id, MAX_LEVEL_ZERO_SEGMENTS);
         const blockStager = new BoundedWriteBlockStager(transaction);
         let resolvedKeys = keys;
-        const segmentId = this.#createId();
+        let segmentId = null;
         const columnBlockIds = {};
         let storedBytes = 0;
         let blockCount = 0;
         let counts;
+        let skippedRowCount = 0;
+        let acceptedRowIndexes = Array.from({ length: requestedRowCount }, (_, index) => index);
+        let upsertFirings;
         let encodeMs = 0;
         let stageMs = 0;
         let commitMs = 0;
@@ -2157,6 +2234,65 @@ export class MinnowDatabase {
                 }
                 resolvedKeys = batchKeys(table, input);
             }
+            const normalizedConflictWhere = kind === "upsert" && conflictWhere !== undefined
+                ? normalizeUpsertConflictWhere(table, conflictWhere)
+                : undefined;
+            const upsertKeyColumn = kind === "upsert" ? getUniqueKeyColumn(table) : undefined;
+            if (upsertKeyColumn !== undefined) {
+                upsertFirings = await this.#upsertTriggerFirings(table, upsertKeyColumn, input, rowCount, (sql, params) => this.#sessionQuery(transaction, sql, { params }), normalizedConflictWhere, normalizedConflictWhere !== undefined);
+            }
+            if (normalizedConflictWhere !== undefined) {
+                if (upsertFirings === undefined) {
+                    throw new Error("Upsert conflict classification is missing");
+                }
+                const classifiedFirings = upsertFirings;
+                acceptedRowIndexes = [...classifiedFirings.inserts, ...classifiedFirings.updates].sort((left, right) => left - right);
+                skippedRowCount = classifiedFirings.skipped.length;
+                input = selectBatchRows(input, acceptedRowIndexes);
+                rowCount = acceptedRowIndexes.length;
+                logicalBytes = estimateBatchBytes(input);
+                resolvedKeys = batchKeys(table, input);
+                counts = {
+                    inserted: classifiedFirings.inserts.length,
+                    updated: classifiedFirings.updates.length,
+                };
+                const acceptedPosition = new Map(acceptedRowIndexes.map((original, position) => [original, position]));
+                upsertFirings = {
+                    inserts: classifiedFirings.inserts.map((index) => acceptedPosition.get(index) ?? -1),
+                    updates: classifiedFirings.updates.map((index) => acceptedPosition.get(index) ?? -1),
+                    skipped: [],
+                    oldImages: acceptedRowIndexes.map((index) => classifiedFirings.oldImages[index]),
+                };
+                if (rowCount === 0) {
+                    await transaction.abort();
+                    const version = transaction.snapshotVersion;
+                    if (version === null)
+                        throw new Error("An existing table has no catalog version");
+                    return {
+                        tableName: table.name,
+                        segmentId: null,
+                        requestedRowCount,
+                        rowCount: 0,
+                        insertedRowCount: 0,
+                        updatedRowCount: 0,
+                        skippedRowCount,
+                        acceptedRowIndexes,
+                        blockCount: 0,
+                        storedBytes: 0,
+                        version,
+                        metrics: createWriteMetrics({
+                            logicalBytes: 0,
+                            storedBytes: 0,
+                            encodeMs: 0,
+                            stageMs: 0,
+                            commitMs: 0,
+                            totalMs: performance.now() - started,
+                            retries: 0,
+                            rows: 0,
+                        }),
+                    };
+                }
+            }
             if (resolvedKeys !== undefined) {
                 transaction.setUniqueKeyChanges({
                     tableId: table.id,
@@ -2169,11 +2305,20 @@ export class MinnowDatabase {
             // generated values are patched also covers an auto-incremented referencing column, and
             // registering this batch's key membership first permits valid self-references.
             await assertForeignKeys();
-            counts =
-                kind === "insert" && resolvedKeys !== undefined
-                    ? { inserted: resolvedKeys.size, updated: 0 }
-                    : await this.#classifyKeys(table, transaction.snapshotVersion, kind, resolvedKeys);
-            const rowIds = reservedRowIds ?? (await this.store.reserveRowIds(table.id, rowCount));
+            if (normalizedConflictWhere === undefined) {
+                counts =
+                    kind === "insert" && resolvedKeys !== undefined
+                        ? { inserted: resolvedKeys.size, updated: 0 }
+                        : await this.#classifyKeys(table, transaction.snapshotVersion, kind, resolvedKeys);
+            }
+            if (counts === undefined)
+                throw new Error("Write classification is missing");
+            const reserved = reservedRowIds ?? (await this.store.reserveRowIds(table.id, rowCount));
+            const rowIds = {
+                start: reserved.start,
+                endExclusive: reserved.start + BigInt(rowCount),
+            };
+            segmentId = this.#createId();
             // Insert batches maintain any active full-text index by tokenizing their own rows into a
             // commit delta. Other mutation kinds emit nothing on purpose: the store's stale-writer
             // rule then flips the index to "invalid" (keyed histories are unindexable) and the scan
@@ -2267,10 +2412,6 @@ export class MinnowDatabase {
             const insertValueAt = (source, column, rowIndex) => (source === "new" ? (input.columns[column]?.[rowIndex] ?? null) : null);
             // Upserts fire per-row: INSERT triggers for fresh keys, UPDATE triggers (with the
             // replaced row as OLD) for conflicting ones — ON CONFLICT DO UPDATE semantics.
-            const upsertKeyColumn = kind === "upsert" ? getUniqueKeyColumn(table) : undefined;
-            const upsertFirings = upsertKeyColumn === undefined
-                ? undefined
-                : await this.#upsertTriggerFirings(table, upsertKeyColumn, input, rowCount);
             stageSecondaryUniqueInsertChanges(transaction, table, input, kind === "upsert" ? upsertFirings?.oldImages : undefined);
             if (kind === "insert") {
                 await this.#stageTriggerDerivedInserts(transaction, table, "insert", rowCount, insertValueAt, "before");
@@ -2304,12 +2445,15 @@ export class MinnowDatabase {
                     return {
                         tableName: table.name,
                         segmentId,
+                        requestedRowCount,
                         rowCount,
                         blockCount,
                         storedBytes,
                         version: manifest.version,
                         insertedRowCount: counts.inserted,
                         updatedRowCount: counts.updated,
+                        skippedRowCount,
+                        acceptedRowIndexes,
                         metrics: createWriteMetrics({
                             logicalBytes,
                             storedBytes,
@@ -2329,7 +2473,7 @@ export class MinnowDatabase {
                     }
                     const stagedDerivations = kind === "insert"
                         ? (table.triggers ?? []).some((trigger) => trigger.event === "insert")
-                        : upsertFirings !== undefined;
+                        : upsertFirings !== undefined || conflictWhere !== undefined;
                     if (stagedDerivations)
                         throw new StaleTriggerDerivationsError(error);
                     retries += 1;
@@ -2383,6 +2527,7 @@ export class MinnowDatabase {
         });
         return externalizeQueryResult({
             columns: columns.map(({ name }) => name),
+            columnDomains: columns.map(({ sqlDomain }) => sqlDomain ?? null),
             rows,
         }).rows;
     }
@@ -2457,12 +2602,14 @@ export class MinnowDatabase {
     }
     async #prepareCompiledPlan(plan, options = {}, probe) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         // The ORDER-BY-expression desugar's wrapper is projection-only: prepare the inner block
         // directly (no derived materialization) and project each result to the visible aliases,
         // so `.search()` costs the same whether or not the caller also selects the score.
         const wrapper = transparentProjectionSource(plan);
         if (wrapper !== undefined) {
             const prepared = await this.#prepareCompiledPlan(wrapper.inner, options, probe);
+            throwIfAborted(options.signal);
             return {
                 sql: prepared.sql,
                 tables: prepared.tables,
@@ -2481,7 +2628,9 @@ export class MinnowDatabase {
             let resolvedPlan = plan;
             let ftsStats;
             let outputNeedsExternalization = true;
+            let outputColumnDomains = [];
             const prepareAtSnapshot = async (snapshot, realTables, visibility) => {
+                throwIfAborted(options.signal);
                 const typedSchemas = new Map([...realTables.values()].map((table) => [
                     table.name,
                     table.columns.map(({ name, type, integer, sqlDomain }) => ({
@@ -2497,32 +2646,41 @@ export class MinnowDatabase {
                 const expandedPlan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(realTables.get(tableName)));
                 const resolution = subqueryResolutionSteps(expandedPlan);
                 for (const step of resolution.steps) {
-                    step.substitute(await this.#executeBlockCached(step.block, snapshot, visibility, memory, realTables, typedSchemas, options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows));
+                    throwIfAborted(options.signal);
+                    step.substitute(await this.#executeBlockCached(step.block, snapshot, visibility, memory, realTables, typedSchemas, options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows, options.signal));
+                    throwIfAborted(options.signal);
                 }
                 resolvedPlan = resolution.plan;
                 // Index-served BM25 statistics, computed against the same catalog snapshot the pruner
                 // reads, so a pruned scoring scan always carries exact corpus numbers.
                 ftsStats = await this.#ftsIndexStats(resolvedPlan, realTables, snapshot, visibility);
+                throwIfAborted(options.signal);
                 columnarTables = await this.#prepareBlockInputs(resolvedPlan, snapshot, visibility, memory, realTables, typedSchemas, undefined, 
                 // memoize: false means "compute this statement's results" — that covers the
                 // columnar forms of derived and windowed sources too, not just the result memo.
-                options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows);
+                options.memoize !== false, options.spillToStorage !== false, options.spillToStorage === true, options.spillPageRows, options.signal);
+                throwIfAborted(options.signal);
                 outputNeedsExternalization = queryResultNeedsExternalization(resolvedPlan, typedSchemas);
+                outputColumnDomains = inferResultColumnDomains(resolvedPlan, typedSchemas);
             };
             if (options.version !== undefined) {
                 // Explicit time travel keeps the per-call lease and version-anchored reads.
                 const realTables = await this.#findRealBlockTables(plan);
+                throwIfAborted(options.signal);
                 await this.#withLeasedSnapshot(options.version, async (snapshot) => {
                     const visibility = await this.#blockSegmentVisibility(realTables);
+                    throwIfAborted(options.signal);
                     await prepareAtSnapshot(snapshot, realTables, visibility);
                 });
             }
             else {
                 await this.#withSharedCatalogSnapshot(collectRealTableNames(plan), prepareAtSnapshot, probe);
             }
+            throwIfAborted(options.signal);
             return createPreparedColumnarQuery(chooseJoinOrder(resolvedPlan, columnarTables), columnarTables, memory, {
                 ...(ftsStats === undefined ? {} : { ftsStats }),
                 outputNeedsExternalization,
+                outputColumnDomains,
             });
         }
         catch (error) {
@@ -2550,7 +2708,7 @@ export class MinnowDatabase {
                 names.forEach((name, index) => {
                     const table = state.tables[index];
                     if (table === undefined)
-                        throw new Error(`Table not found: ${name}`);
+                        throw new UnknownTableError(name);
                     realTables.set(table.name, table);
                 });
                 const segmentsByTable = new Map();
@@ -2809,38 +2967,50 @@ export class MinnowDatabase {
      * materialize their referenced columns. Each block resolves its own inputs, so one real table
      * projected differently by two blocks never collides.
      */
-    async #prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const inputs = new Map(extraInputs ?? []);
         const sources = [block.base, ...block.joins];
         for (const source of sources) {
+            throwIfAborted(signal);
             if (inputs.has(source.table))
                 continue;
             if (source.recursive !== undefined) {
                 const { reference, base, step, all } = source.recursive;
-                const { result: baseResult, schema } = await this.#executeBlockWithSchemaCached(base, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                const { result: baseResult, schema } = await this.#executeBlockWithSchemaCached(base, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                 typedSchemas.set(reference, schema);
                 const state = createRecursiveCteState(baseResult, all);
                 while (state.frontier.length > 0) {
+                    throwIfAborted(signal);
                     // Each iteration's inputs release with its own context, so only the accumulated rows
                     // and the final columnar table hold memory across the fixpoint loop.
                     const iterationMemory = memory.createChild();
                     try {
-                        const frontierTable = derivedColumnarTable(reference, { columns: [...state.columns], rows: state.frontier }, schema);
-                        state.absorb(await this.#executeBlock(step, snapshot, visibility, iterationMemory, realTables, typedSchemas, new Map([[reference, frontierTable]]), cacheResults, allowSpill, forceSpill, spillPageRows));
+                        const frontierTable = derivedColumnarTable(reference, {
+                            columns: [...state.columns],
+                            columnDomains: schema.map(({ sqlDomain }) => sqlDomain ?? null),
+                            rows: state.frontier,
+                        }, schema);
+                        state.absorb(await this.#executeBlock(step, snapshot, visibility, iterationMemory, realTables, typedSchemas, new Map([[reference, frontierTable]]), cacheResults, allowSpill, forceSpill, spillPageRows, signal));
                     }
                     finally {
                         iterationMemory.close();
                     }
                 }
                 typedSchemas.set(source.table, schema);
-                inputs.set(source.table, derivedColumnarTable(source.table, { columns: [...state.columns], rows: state.rows }, schema));
+                inputs.set(source.table, derivedColumnarTable(source.table, {
+                    columns: [...state.columns],
+                    columnDomains: schema.map(({ sqlDomain }) => sqlDomain ?? null),
+                    rows: state.rows,
+                }, schema));
                 continue;
             }
             if (source.union !== undefined) {
                 const results = [];
                 let schema;
                 for (const member of source.union.blocks) {
-                    const { result, schema: memberSchema } = await this.#executeBlockWithSchemaCached(member, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                    throwIfAborted(signal);
+                    const { result, schema: memberSchema } = await this.#executeBlockWithSchemaCached(member, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                     if (schema === undefined)
                         schema = memberSchema;
                     else {
@@ -2869,6 +3039,7 @@ export class MinnowDatabase {
                 // key plus the window spec, so a warm repeat skips the window pass and the
                 // rows-to-columnar conversion entirely.
                 const innerKey = await this.#blockResultCacheKey(source.windowed.block, snapshot, visibility, realTables, cacheResults);
+                throwIfAborted(signal);
                 const columnarKey = innerKey === undefined
                     ? undefined
                     : `ctw|${JSON.stringify(source.windowed.windows)}|${innerKey}`;
@@ -2880,7 +3051,7 @@ export class MinnowDatabase {
                         continue;
                     }
                 }
-                const { result: inner, schema: innerSchema } = await this.#executeBlockWithSchemaCached(source.windowed.block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+                const { result: inner, schema: innerSchema } = await this.#executeBlockWithSchemaCached(source.windowed.block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
                 const windowed = applyWindowFunctions(inner, source.windowed.windows, {
                     copyRows: cacheResults,
                 });
@@ -2907,6 +3078,7 @@ export class MinnowDatabase {
             if (derived === undefined)
                 continue;
             const derivedKey = await this.#blockResultCacheKey(derived, snapshot, visibility, realTables, cacheResults);
+            throwIfAborted(signal);
             const columnarKey = derivedKey === undefined ? undefined : `ctd|${derivedKey}`;
             if (columnarKey !== undefined) {
                 const hit = this.#cacheGet(columnarKey);
@@ -2916,7 +3088,7 @@ export class MinnowDatabase {
                     continue;
                 }
             }
-            const { result, schema } = await this.#executeBlockWithSchemaCached(derived, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows);
+            const { result, schema } = await this.#executeBlockWithSchemaCached(derived, snapshot, visibility, memory, realTables, typedSchemas, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
             typedSchemas.set(source.table, schema);
             const derivedTable = derivedColumnarTable(source.table, result, schema);
             if (columnarKey !== undefined) {
@@ -2931,6 +3103,7 @@ export class MinnowDatabase {
         const columns = referencedColumns(block, nameSchemas);
         const onlyRealSource = sources.length === 1 && sources[0]?.derived === undefined ? block : undefined;
         for (const source of sources) {
+            throwIfAborted(signal);
             if (source.derived !== undefined || inputs.has(source.table))
                 continue;
             if (source.table === DUAL_TABLE) {
@@ -2939,9 +3112,10 @@ export class MinnowDatabase {
             }
             const table = realTables.get(source.table);
             if (table === undefined)
-                throw new TypeError(`Unknown table: ${source.table}`);
+                throw new UnknownTableError(source.table);
             const requestedColumns = columns.get(table.name) ?? [];
             inputs.set(table.name, await this.#materializeColumnarTableAtSnapshot(table, snapshot, requestedColumns.length === 0 ? [] : resolveReadColumns(table, requestedColumns), visibility, onlyRealSource));
+            throwIfAborted(signal);
         }
         return inputs;
     }
@@ -2958,6 +3132,7 @@ export class MinnowDatabase {
         return this.#queryWithReadReservation(sql, options);
     }
     async #queryUnreserved(sql, options) {
+        throwIfAborted(options.signal);
         const open = this.#openTransaction;
         if (open !== undefined) {
             // Read-your-writes: inside BEGIN … COMMIT a read sees the pre-scope snapshot plus what
@@ -2983,6 +3158,7 @@ export class MinnowDatabase {
         const result = !memoizable
             ? await this.#queryCompiled(plan, options)
             : await this.#memoizedQuery(plan, `res ${queryResultMemoKey(sql, options.params ?? [])}`, options, probe);
+        throwIfAborted(options.signal);
         return externalizeQueryResult(result);
     }
     /**
@@ -3047,7 +3223,8 @@ export class MinnowDatabase {
         };
     }
     async #queryBatches(sql, options, cursor) {
-        options = this.#effectiveQueryOptions(options);
+        options = this.#effectiveQueryOptions({ ...options, signal: cursor.signal });
+        cursor.signal.throwIfAborted();
         // A transaction's staged overlay has its own executor. Keep its read-your-writes semantics
         // and page the materialized result; native scan batching is for durable snapshots.
         if (this.#openTransaction === undefined) {
@@ -3076,6 +3253,7 @@ export class MinnowDatabase {
             cursor.signal.throwIfAborted();
             await cursor.consume({
                 columns: [...result.columns],
+                columnDomains: [...result.columnDomains],
                 rows: result.rows.slice(start, start + cursor.batchRows),
             });
         }
@@ -3087,16 +3265,22 @@ export class MinnowDatabase {
      * and on IndexedDB every probe is a read transaction, a floor under every small query.
      */
     async #memoizedQuery(plan, key, options, probe) {
+        throwIfAborted(options.signal);
         const before = await probe();
+        throwIfAborted(options.signal);
         const cached = this.#cacheGet(`${key}\u0001${String(before.catalogEpoch)}`);
-        if (cached !== undefined)
+        if (cached !== undefined) {
+            options.onStats?.({ peakMemoryBytes: 0 });
             return copyQueryResult(cached);
+        }
         const result = await this.#queryCompiled(plan, options, before);
+        throwIfAborted(options.signal);
         const bytes = queryResultRetainedBytes(result);
         if (bytes <= RESULT_MEMO_MAX_BYTES) {
             // Cache only when the epoch did not move during execution: the result is then exactly
             // that epoch's answer. A moved epoch simply skips the cache — never mis-files.
             const after = await probe();
+            throwIfAborted(options.signal);
             if (after.catalogEpoch === before.catalogEpoch) {
                 this.#cachePut(`${key}\u0001${String(before.catalogEpoch)}`, copyQueryResult(result), bytes);
             }
@@ -3276,10 +3460,13 @@ export class MinnowDatabase {
      */
     async #queryCompiled(plan, options = {}, probe) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         // One freshness probe per query: read here unless the caller already has one, and handed
         // to the view lookup and the catalog state below, which would otherwise probe again each.
         probe ??= await this.store.getCatalogProbe();
+        throwIfAborted(options.signal);
         plan = await this.#applyCatalogRewrites(plan, probe);
+        throwIfAborted(options.signal);
         const spillPageRows = options.spillPageRows === undefined
             ? undefined
             : positiveWholeNumber(options.spillPageRows, "Query spill page rows");
@@ -3300,6 +3487,7 @@ export class MinnowDatabase {
             }
         }
         const prepared = await this.#prepareCompiledPlan(plan, options, probe);
+        throwIfAborted(options.signal);
         // Read the peak before close(): closing releases the context and zeroes what it tracked.
         const report = (result) => {
             options.onStats?.({ peakMemoryBytes: prepared.memoryUsage.peakBytes });
@@ -3307,11 +3495,16 @@ export class MinnowDatabase {
         };
         try {
             const spill = options.spillToStorage ?? options.executionMemoryBudgetBytes !== undefined;
-            if (!spill)
-                return report(prepared.execute());
+            if (!spill) {
+                const result = prepared.execute();
+                throwIfAborted(options.signal);
+                return report(result);
+            }
             if (options.spillToStorage !== true) {
                 try {
-                    return report(prepared.execute());
+                    const result = prepared.execute();
+                    throwIfAborted(options.signal);
+                    return report(result);
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
@@ -3321,12 +3514,33 @@ export class MinnowDatabase {
             return report(await prepared.executeAsync({
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
                 spillStore: this.#leasedSpillStore(),
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
             }));
         }
         finally {
             prepared.close();
         }
     }
+    /**
+     * Streams a one-column snapshot projection into bounded pages. DELETE uses this before its
+     * first staged write: selection keeps all ordinary pruning/predicate semantics without
+     * retaining every QueryRow object until the key array is complete. Undefined means the shape
+     * or physical history needs the established row-shaped executor.
+     */
+    async #queryCompiledFirstColumn(plan, probe) {
+        const options = this.#effectiveQueryOptions({ memoize: false });
+        plan = await this.#applyCatalogRewrites(plan, probe);
+        const values = [];
+        const streamed = await this.#queryStreamed(plan, options, undefined, probe, {
+            batchRows: 2_048,
+            signal: new AbortController().signal,
+            consumeFirstColumn: async (batch) => {
+                values.push(...batch);
+            },
+            consume: async () => undefined,
+        });
+        return streamed === undefined ? undefined : values;
+    }
     /**
      * Backs the executor's spill pages with durable owner leases: each owner registers a lease
      * before its first page write and renews it while pages are read or written, so an abandoned
@@ -3714,15 +3928,18 @@ export class MinnowDatabase {
      * one, so a table that cannot be compacted today costs one attempt, not one per query.
      */
     #maybeScheduleAutoCompaction(table, segments) {
+        this.#maybeScheduleAutoCompactionFromHint(table, autoCompactionHint(null, segments));
+    }
+    #maybeScheduleAutoCompactionFromHint(table, hint) {
         if (this.#closed)
             return;
         if (!this.#autoCompact)
             return;
         if (this.#droppingTables.has(table.id))
             return;
-        if (!autoCompactionDue(segments))
+        if (!autoCompactionDueHint(hint))
             return;
-        if (segments.length < (this.#autoCompactionBackoff.get(table.id) ?? 0))
+        if (hint.visible < (this.#autoCompactionBackoff.get(table.id) ?? 0))
             return;
         if (this.#autoCompactionsInFlight.has(table.id)) {
             // A final burst can cross the threshold while the prior fold is still planning or
@@ -3736,14 +3953,14 @@ export class MinnowDatabase {
             if (folded)
                 this.#autoCompactionBackoff.delete(table.id);
             else {
-                this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, segments.length * 2)));
+                this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
             }
         })
             .catch(() => {
             // Back off deterministic failures, but never beyond the maximum L0 prefix a fold can
             // consume. A transient conflict near the end of a burst must not strand hundreds of
             // segments waiting for a segment count the idle database can never reach.
-            this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, segments.length * 2)));
+            this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
         })
             .finally(() => {
             if (this.#autoCompactionsInFlight.get(table.id) === run) {
@@ -3763,6 +3980,10 @@ export class MinnowDatabase {
         // every write and let the commit return the identical CompactionBacklogError at the CAS.
         if (!this.#autoCompact)
             return;
+        const hintVersion = transaction?.snapshotVersion ?? (await this.store.getCurrentManifestVersion());
+        const hint = this.#autoCompactionHints.get(table.id);
+        if (hint?.version === hintVersion && hint.levelZero < MAX_LEVEL_ZERO_SEGMENTS)
+            return;
         let segments = await this.#currentVisibleSegments(table);
         let levelZero = 0;
         for (const segment of segments) {
@@ -3836,9 +4057,11 @@ export class MinnowDatabase {
             const version = await this.store.getCurrentManifestVersion();
             segments = await this.#visibleSegmentRecords(table, new Snapshot(this.store, version));
             if ((await this.store.getCurrentManifestVersion()) === version) {
+                this.#autoCompactionHints.set(table.id, autoCompactionHint(version, segments));
                 return segments;
             }
         }
+        this.#autoCompactionHints.delete(table.id);
         return segments;
     }
     /**
@@ -3849,6 +4072,7 @@ export class MinnowDatabase {
         if (this.#closed)
             return;
         const contribution = transaction?.committedCatalogContribution;
+        this.#advanceAutoCompactionHints(manifest, contribution?.segments);
         const initial = contribution?.initialCatalogProbe;
         const contributedTableIds = new Set(contribution?.segments.map((segment) => segment.tableId) ?? []);
         if (contribution !== undefined &&
@@ -3942,7 +4166,7 @@ export class MinnowDatabase {
         this.#armIdleCompactionCheck();
     }
     /** Counts one physical rewrite version once in this engine, including lost-ack recovery. */
-    #afterCompactionCommit(manifest) {
+    #afterCompactionCommit(manifest, tableId) {
         if (this.#accountedCompactionVersions.has(manifest.version))
             return;
         this.#accountedCompactionVersions.add(manifest.version);
@@ -3951,8 +4175,49 @@ export class MinnowDatabase {
             if (oldest !== undefined)
                 this.#accountedCompactionVersions.delete(oldest);
         }
+        // A fold replaces source segments with a different physical layout. Its manifest is
+        // logically unchanged and therefore carries no changed-table ID, so invalidate explicitly;
+        // #runAutoCompaction's stable post-fold probe seeds the replacement counters.
+        this.#autoCompactionHints.delete(tableId);
         this.#afterCommit(manifest);
     }
+    /** Advances exact local hints, or discards them when a commit's provenance is incomplete. */
+    #advanceAutoCompactionHints(manifest, contributedSegments) {
+        for (const [tableId, hint] of this.#autoCompactionHints) {
+            if (hint.version !== manifest.previousVersion) {
+                // Another database committed since this instance last proved the layout.
+                this.#autoCompactionHints.delete(tableId);
+                continue;
+            }
+            this.#autoCompactionHints.set(tableId, { ...hint, version: manifest.version });
+        }
+        const additionsByTable = new Map();
+        for (const segment of contributedSegments ?? []) {
+            const additions = additionsByTable.get(segment.tableId);
+            if (additions === undefined)
+                additionsByTable.set(segment.tableId, [segment]);
+            else
+                additions.push(segment);
+        }
+        for (const tableId of manifest.changedTableIds) {
+            const hint = this.#autoCompactionHints.get(tableId);
+            if (hint === undefined)
+                continue;
+            const additions = additionsByTable.get(tableId);
+            if (additions === undefined) {
+                // DDL and future write paths without an exact segment contribution fail closed.
+                this.#autoCompactionHints.delete(tableId);
+                continue;
+            }
+            const contribution = autoCompactionHint(manifest.version, additions);
+            this.#autoCompactionHints.set(tableId, {
+                version: manifest.version,
+                visible: hint.visible + contribution.visible,
+                levelZero: hint.levelZero + contribution.levelZero,
+                deltas: hint.deltas + contribution.deltas,
+            });
+        }
+    }
     /**
      * Debounces the final write-path check for a burst. Sampling every few commits keeps the hot
      * path cheap, but the last one through seven commits can be the ones that cross a fold
@@ -3990,6 +4255,12 @@ export class MinnowDatabase {
             const table = await this.store.getTable(tableId);
             if (table === undefined)
                 return;
+            const version = await this.store.getCurrentManifestVersion();
+            const hint = this.#autoCompactionHints.get(tableId);
+            if (hint?.version === version) {
+                this.#maybeScheduleAutoCompactionFromHint(table, hint);
+                return;
+            }
             this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
         }
         catch {
@@ -4013,7 +4284,7 @@ export class MinnowDatabase {
             const tables = proof.records;
             const table = tables.find((record) => record.name === tableName);
             if (table === undefined)
-                throw new TypeError(`Table not found: ${tableName}`);
+                throw new UnknownTableError(tableName);
             if (table.view !== undefined)
                 throw new TypeError(`Cannot create a trigger on view ${tableName}`);
             pinnedTableId ??= table.id;
@@ -4046,7 +4317,7 @@ export class MinnowDatabase {
                 }
                 const target = tables.find((record) => record.name === compiled.table);
                 if (target === undefined)
-                    throw new TypeError(`Table not found: ${compiled.table}`);
+                    throw new UnknownTableError(compiled.table);
                 if (target.view !== undefined) {
                     throw new TypeError(`Trigger bodies cannot write to views: ${compiled.table}`);
                 }
@@ -4124,19 +4395,32 @@ export class MinnowDatabase {
      * in-batch duplicate key fires as an UPDATE of the earlier occurrence. Returns undefined
      * when the table has no insert or update triggers.
      */
-    async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows) {
+    async #upsertTriggerFirings(table, keyColumn, batch, rowCount, readRows, conflictWhere, force = false) {
         const fires = (table.triggers ?? []).some((trigger) => trigger.event === "insert" || trigger.event === "update");
-        if (!fires || rowCount === 0)
+        if ((!fires && !force) || rowCount === 0)
             return undefined;
         const quote = (name) => `"${name.replaceAll('"', '""')}"`;
         const keyValues = batch.columns[keyColumn.name] ?? [];
-        const params = keyValues.filter((value) => value !== null);
-        const placeholders = params.map(() => "?").join(", ");
-        const sql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
-        const result = readRows === undefined
-            ? await this.query(sql, { params, memoize: false })
-            : await readRows(sql, params);
-        const byToken = new Map(result.rows.map((row) => {
+        const distinct = new Map();
+        for (const value of keyValues) {
+            if (value !== null)
+                distinct.set(keyToken(keyColumn.type, value), value);
+        }
+        const params = [...distinct.values()];
+        const rows = [];
+        // Each value also contributes a comma token, so the parser's token cap is reached before
+        // its parameter cap. A fixed 1,024-key window stays comfortably inside both limits.
+        const keyWindowSize = Math.min(MAX_SQL_PARAMETERS, 1_024);
+        for (let start = 0; start < params.length; start += keyWindowSize) {
+            const window = params.slice(start, start + keyWindowSize);
+            const placeholders = window.map(() => "?").join(", ");
+            const sql = `SELECT * FROM ${quote(table.name)} WHERE ${quote(keyColumn.name)} IN (${placeholders})`;
+            const result = readRows === undefined
+                ? await this.query(sql, { params: window, memoize: false })
+                : await readRows(sql, window);
+            rows.push(...result.rows);
+        }
+        const byToken = new Map(rows.map((row) => {
             const key = row[keyColumn.name];
             return [
                 key === null || key === undefined ? "" : keyToken(keyColumn.type, key),
@@ -4145,29 +4429,36 @@ export class MinnowDatabase {
         }));
         const inserts = [];
         const updates = [];
+        const skipped = [];
         const oldImages = [];
-        const seenInBatch = new Map();
+        const currentByToken = new Map(byToken);
         for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
             const key = keyValues[rowIndex] ?? null;
             const token = key === null ? "" : keyToken(keyColumn.type, key);
-            const earlier = seenInBatch.get(token);
-            const old = earlier === undefined
-                ? byToken.get(token)
-                : Object.fromEntries(table.columns.map((column) => [
-                    column.name,
-                    batch.columns[column.name]?.[earlier] ?? null,
-                ]));
+            const old = currentByToken.get(token);
             if (old === undefined) {
                 inserts.push(rowIndex);
                 oldImages.push(undefined);
             }
             else {
-                updates.push(rowIndex);
                 oldImages.push(old);
+                const rawLeft = conflictWhere === undefined ? null : (old[conflictWhere.column.name] ?? null);
+                const left = conflictWhere?.column.sqlDomain === undefined
+                    ? rawLeft
+                    : normalizeSqlDomainValue(conflictWhere.column.sqlDomain, rawLeft);
+                if (conflictWhere !== undefined &&
+                    !comparisonHolds(conflictWhere.operator, left, conflictWhere.value)) {
+                    skipped.push(rowIndex);
+                    continue;
+                }
+                updates.push(rowIndex);
             }
-            seenInBatch.set(token, rowIndex);
+            currentByToken.set(token, Object.fromEntries(table.columns.map((column) => [
+                column.name,
+                batch.columns[column.name]?.[rowIndex] ?? null,
+            ])));
         }
-        return { inserts, updates, oldImages };
+        return { inserts, updates, skipped, oldImages };
     }
     /** Fires INSERT and UPDATE triggers for one upsert batch at one timing, per the plan. */
     async #stageUpsertTriggerFirings(transaction, table, batch, firings, timing, cascadeBudget = 1) {
@@ -4250,6 +4541,7 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filled = await fillColumnDefaults(target, input, (sql) => this.#evaluateDefaultExpression(sql, statementNow), derivedRows.length);
         normalizeDomainBatch(target, filled.batch);
+        fillStoredGeneratedColumns(target, filled.batch, derivedRows.length, filled.generated);
         fillCompositePrimaryKey(target, filled.batch, derivedRows.length);
         validateBatch(target, filled.batch, filled.autoIncrement?.column.name);
         if (filled.autoIncrement !== undefined && filled.autoIncrement.missingIndexes.length > 0) {
@@ -4522,6 +4814,15 @@ export class MinnowDatabase {
                     ? this.#queryCompiled(plan, {}, probe)
                     : this.#sessionQueryPlan(transaction, await this.#applyCatalogRewrites(plan));
             }),
+            queryFirstColumn: (plan) => this.#withReadReservation(async () => {
+                // A staged overlay can add, replace, or remove keys without changing the pinned
+                // manifest. Keep that case on the read-your-writes row executor; before the first
+                // stage, the transaction's exact catalog probe makes the streamed snapshot safe.
+                const probe = transaction.initialCatalogProbe;
+                return transaction.stagedWorkCount === 0 && probe !== undefined
+                    ? this.#queryCompiledFirstColumn(plan, probe)
+                    : undefined;
+            }),
             executeStatement: (statement) => {
                 open();
                 return guarded(() => this.runStatement(statement, { writer }));
@@ -4590,21 +4891,26 @@ export class MinnowDatabase {
      */
     async #sessionQuery(transaction, sql, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const bound = bindPlanParameters(this.#compileCached(sql), options.params);
         // The same catalog rewrites a read outside a scope gets: a scope that could not see a view
         // would make the scope's reads a different language from everyone else's.
         const plan = await this.#applyCatalogRewrites(bound);
+        throwIfAborted(options.signal);
         return this.#sessionQueryPlan(transaction, plan, options);
     }
     /** #sessionQuery for an already-bound plan: trigger bodies resolve their reads through it. */
     async #sessionQueryPlan(transaction, plan, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const names = collectRealTableNames(plan);
         const tables = await Promise.all(names.map((name) => this.#findTable(name)));
+        throwIfAborted(options.signal);
         const realTables = new Map(tables.map((table) => [table.name, table]));
         const pendingIds = new Set(transaction.pendingSegmentIds);
         const pendingBlocks = new Set(transaction.pendingBlockIds);
         const ourRecord = await this.store.getTransaction(transaction.id);
+        throwIfAborted(options.signal);
         // Pinned to the scope's own snapshot, not the current manifest: the documented contract
         // is "the pre-scope snapshot plus everything this scope staged", and #assertKeysExist
         // already validates against transaction.snapshotVersion — reading the current version
@@ -4628,6 +4934,7 @@ export class MinnowDatabase {
                 getBlocks: async (blockIds) => {
                     const blocks = [];
                     for (let start = 0; start < blockIds.length; start += 64) {
+                        throwIfAborted(options.signal);
                         const window = blockIds.slice(start, start + 64);
                         const committedIds = [];
                         const committedIndexes = [];
@@ -4652,6 +4959,7 @@ export class MinnowDatabase {
                             this.#getBlocksWindowed(committedIds),
                             Promise.all(stagedIds.map((blockId) => transaction.getBlock(blockId))),
                         ]);
+                        throwIfAborted(options.signal);
                         const ordered = new Array(window.length);
                         committedIndexes.forEach((index, offset) => {
                             ordered[index] = committed[offset];
@@ -4670,10 +4978,12 @@ export class MinnowDatabase {
             const transactionRecords = new Map();
             const deferredSegments = transaction.deferredSegments;
             for (const table of tables) {
+                throwIfAborted(options.signal);
                 const segments = [
                     ...(await listTableSegmentsPaged(this.store, table.id)),
                     ...deferredSegments.filter((segment) => segment.tableId === table.id),
                 ];
+                throwIfAborted(options.signal);
                 // Staged segments sort after every committed one; commitOrdinal keeps their
                 // staging order (the journal's id list is sorted, so it cannot).
                 const doctored = segments.map((segment) => pendingIds.has(segment.id)
@@ -4683,6 +4993,7 @@ export class MinnowDatabase {
                 for (const record of await this.#transactionRecordsForSegments(doctored)) {
                     transactionRecords.set(record.id, record);
                 }
+                throwIfAborted(options.signal);
             }
             if (ourRecord !== undefined) {
                 transactionRecords.set(transaction.id, {
@@ -4702,6 +5013,7 @@ export class MinnowDatabase {
     /** Executes one plan at an explicit snapshot and visibility, covering every plan shape. */
     async #queryAtVisibility(plan, snapshot, visibility, realTables, cacheResults = true, options = {}) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         plan = expandFtsColumns(plan, (name) => searchableFtsColumns(realTables.get(name)));
         const typedSchemas = new Map([...realTables.values()].map((table) => [
             table.name,
@@ -4718,16 +5030,22 @@ export class MinnowDatabase {
         const spillPageRows = options.spillPageRows === undefined
             ? undefined
             : positiveWholeNumber(options.spillPageRows, "Query spill page rows");
+        const report = (result) => {
+            throwIfAborted(options.signal);
+            options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
+            return result;
+        };
         try {
             const resolution = subqueryResolutionSteps(plan);
             for (const step of resolution.steps) {
-                step.substitute(await this.#executeBlock(step.block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows));
+                throwIfAborted(options.signal);
+                step.substitute(await this.#executeBlock(step.block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal));
             }
             const wrapper = transparentProjectionSource(resolution.plan);
             if (wrapper !== undefined) {
-                return projectResultColumns(await this.#executeBlock(wrapper.inner, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows), wrapper.aliases);
+                return report(projectResultColumns(await this.#executeBlock(wrapper.inner, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal), wrapper.aliases));
             }
-            return await this.#executeBlock(resolution.plan, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+            return report(await this.#executeBlock(resolution.plan, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, options.signal));
         }
         finally {
             memory.close();
@@ -4812,6 +5130,7 @@ export class MinnowDatabase {
             throw new TypeError(`Table needs a unique key before rows can be updated: ${table.name}`);
         }
         input = normalizeDomainUpdate(table, input);
+        rejectGeneratedUpdateAssignments(table, input);
         const keys = validateUpdateBatch(table, keyColumn, input);
         // Read-your-writes membership: keys staged by this scope pass, keys the scope removed
         // fail, and everything else checks against the committed snapshot as usual.
@@ -4826,11 +5145,17 @@ export class MinnowDatabase {
             await this.#assertKeysExist(table, keyColumn, transaction.snapshotVersion, committedKeys);
         }
         const sessionChecks = table.checks ?? [];
-        const changedForeignKey = (table.foreignKeys ?? []).some((key) => foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
+        let changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+            foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
         const preImages = await this.#triggerPreImages(table, keyColumn, input.keys.filter((key) => key !== null), "update", (preImageSql, params) => this.#sessionQuery(transaction, preImageSql, { params }), sessionChecks.length > 0 ||
             changedForeignKey ||
+            tableGeneratedExpressions(table).length > 0 ||
             secondaryIndexUpdateNeedsPreImages(table, input) ||
             readyUniqueSecondaryIndexes(table).some(({ columns }) => columns.some((column) => input.changes[column.name] !== undefined)));
+        input = applyStoredGeneratedUpdateChanges(table, input, preImages);
+        validateUpdateBatch(table, keyColumn, input);
+        changedForeignKey = (table.foreignKeys ?? []).some((key) => key.enforced !== false &&
+            foreignKeyColumns(key).some((column) => input.changes[column] !== undefined));
         stageSecondaryUniqueMutationChanges(transaction, table, input, preImages);
         const secondaryDeltas = buildSecondaryUpdateDeltas(table, input, preImages);
         if (secondaryDeltas.length > 0) {
@@ -4912,7 +5237,19 @@ export class MinnowDatabase {
             },
         ]);
         await this.#stageTriggerDerivedInserts(transaction, table, "update", input.keys.length, sessionUpdateValueAt, "after", cascadeBudget);
-        return { tableName: table.name, segmentId, rowCount: input.keys.length };
+        return {
+            tableName: table.name,
+            segmentId,
+            rowCount: input.keys.length,
+            ...(tableGeneratedExpressions(table).length === 0
+                ? {}
+                : {
+                    generatedColumns: Object.fromEntries(tableGeneratedExpressions(table).map(({ column }) => [
+                        column.name,
+                        (input.changes[column.name] ?? []).map((value) => externalSqlDomainValue(value)),
+                    ])),
+                }),
+        };
     }
     async #sessionDelete(transaction, tableName, input, cascadeBudget = 1, referentialBudget = REFERENTIAL_CASCADES) {
         const table = await this.#findTable(tableName);
@@ -5249,6 +5586,9 @@ export class MinnowDatabase {
                         ...(columnDefinition.defaultSpec === undefined
                             ? {}
                             : { defaultValue: columnDefinition.defaultSpec }),
+                        ...(columnDefinition.generatedSpec === undefined
+                            ? {}
+                            : { generatedValue: columnDefinition.generatedSpec }),
                         ...(columnDefinition.enumValues === undefined
                             ? {}
                             : { enumValues: columnDefinition.enumValues }),
@@ -5386,10 +5726,37 @@ export class MinnowDatabase {
                     }
                 }
             }
+            // Adopting generation on an existing physical column is metadata-only only when every
+            // stored value already equals the declared expression. This supports migrations from an
+            // application-maintained column without silently blessing stale historical rows.
+            for (const step of steps) {
+                if (step.kind !== "alter-generated" || step.generatedValue === null)
+                    continue;
+                const target = record.columns.find(({ name }) => name === step.columnName);
+                if (target === undefined)
+                    continue;
+                const expression = compileGeneratedColumnExpression(record.name, target.name, step.generatedValue.sql, record.columns);
+                const rows = (await this.query(`SELECT * FROM ${quoteSqlIdentifier(record.name)}`, { memoize: false })).rows;
+                for (const [rowIndex, row] of rows.entries()) {
+                    const expected = normalizeGeneratedColumnValue(target, evaluateRowExpression(expression, record.name, generatedEvaluationRow(record, row)), rowIndex);
+                    const actual = normalizeGeneratedColumnValue(target, row[target.name] ?? null, rowIndex);
+                    const equal = expected instanceof Date && actual instanceof Date
+                        ? dateMilliseconds(expected) === dateMilliseconds(actual)
+                        : Object.is(expected, actual);
+                    if (!equal) {
+                        throw new TypeError(`Generated column cannot be adopted: ${record.name}.${target.name} differs from its expression at row ${String(rowIndex)}`);
+                    }
+                }
+            }
             // The remaining metadata-only steps share one catalog/manifest CAS. Physical drops ran
             // above because segment rewriting and payload retirement have a stronger atomic boundary.
             const columns = applyColumnSteps(record, steps, this.#createId);
-            if (JSON.stringify(columns) === JSON.stringify(record.columns)) {
+            const foreignKeyStep = steps.find((step) => step.kind === "alter-foreign-keys");
+            const foreignKeys = foreignKeyStep?.kind === "alter-foreign-keys"
+                ? foreignKeyStep.foreignKeys.map((key) => ({ ...key }))
+                : record.foreignKeys;
+            if (JSON.stringify(columns) === JSON.stringify(record.columns) &&
+                JSON.stringify(foreignKeys ?? []) === JSON.stringify(record.foreignKeys ?? [])) {
                 if (changed)
                     alteredTables.push(tableName);
                 continue;
@@ -5400,6 +5767,7 @@ export class MinnowDatabase {
             assertDependentViewsKeepSchema(proof.records, record, candidateSchemas);
             const updated = await this.store.updateTable(record.id, record.revision, {
                 columns,
+                ...(foreignKeyStep === undefined ? {} : { foreignKeys }),
                 ...(autoIncrementSeed === undefined ? {} : { autoIncrementSeed }),
                 expectedManifestVersion: { value: proof.manifestVersion },
                 expectedCatalogEpoch: proof.catalogEpoch,
@@ -5533,6 +5901,8 @@ export class MinnowDatabase {
      */
     async #assertForeignKeysPresent(table, rowsByColumn, read, transaction) {
         for (const key of table.foreignKeys ?? []) {
+            if (key.enforced === false)
+                continue;
             const childNames = foreignKeyColumns(key);
             const parentNames = foreignKeyParentColumns(key);
             if (childNames.length > 1) {
@@ -5671,7 +6041,7 @@ export class MinnowDatabase {
     async #applyReferentialActions(parent, keys, session, cascadeBudget) {
         if (keys.length === 0)
             return;
-        const children = await this.#childForeignKeys(parent.name);
+        const children = (await this.#childForeignKeys(parent.name)).filter(({ key }) => key.enforced !== false);
         if (children.length === 0)
             return;
         if (cascadeBudget < 0) {
@@ -5929,6 +6299,7 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filledProposed = await fillColumnDefaults(table, proposedBatch, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
         normalizeDomainBatch(table, filledProposed.batch);
+        fillStoredGeneratedColumns(table, filledProposed.batch, statement.rows.length, filledProposed.generated);
         fillCompositePrimaryKey(table, filledProposed.batch, statement.rows.length);
         const proposed = filledProposed.batch;
         // UPSERT only handles a uniqueness conflict. Other INSERT-domain failures are still errors,
@@ -5999,7 +6370,10 @@ export class MinnowDatabase {
             // and UUID defaults twice and could even change which row conflicts.
             const columns = visibleTableColumns(table).map(({ name }) => name);
             const deferredAutoIncrement = new Set(filledProposed.autoIncrement?.missingIndexes ?? []);
-            const rows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => name === filledProposed.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex)
+            const generatedColumns = new Set(table.columns.flatMap((column) => column.generatedValue === undefined ? [] : [column.name]));
+            const rows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => generatedColumns.has(name) ||
+                (name === filledProposed.autoIncrement?.column.name &&
+                    deferredAutoIncrement.has(rowIndex))
                 ? { default: true }
                 : (proposed.columns[name]?.[rowIndex] ?? null)));
             return this.runStatement({
@@ -6055,7 +6429,12 @@ export class MinnowDatabase {
                     return value;
                 });
                 const selected = await transaction.query(`SELECT * FROM ${quoteSqlIdentifier(table.name)} WHERE ${quoteSqlIdentifier(keyColumn.name)} IN (${keys.map(() => "?").join(", ")})`, { params: keys });
-                const currentByKey = new Map(selected.rows.map((row) => [keyToken(row[keyColumn.name] ?? null), row]));
+                const currentByKey = new Map(selected.rows.map((row) => {
+                    const value = keyColumn.hidden
+                        ? compositeKeyValue(primaryKeyColumns(table), primaryKeyColumns(table).map(({ name }) => row[name] ?? null))
+                        : (row[keyColumn.name] ?? null);
+                    return [keyToken(value), row];
+                }));
                 const updateKeys = [];
                 const changes = Object.fromEntries(assignments.map(({ column }) => [column, []]));
                 for (const [position, rowIndex] of conflictingRows.entries()) {
@@ -6088,6 +6467,8 @@ export class MinnowDatabase {
             if (freshRows.length > 0) {
                 const columns = {};
                 for (const column of table.columns) {
+                    if (column.generatedValue !== undefined)
+                        continue;
                     columns[column.name] = freshRows.map((rowIndex) => proposed.columns[column.name]?.[rowIndex] ?? null);
                 }
                 await transaction.insertBatch(table.name, { columns });
@@ -6126,7 +6507,9 @@ export class MinnowDatabase {
             table: statement.table,
             rowCount: outcome.affectedRows.length,
             ...(version === null || version === undefined ? {} : { version }),
-            ...(outcome.returnedRows === undefined ? {} : { returnedRows: outcome.returnedRows }),
+            ...(outcome.returnedRows === undefined || returningColumns === undefined
+                ? {}
+                : returningExecuteFields(table, returningColumns, outcome.returnedRows)),
         };
     }
     /** ON CONFLICT DO NOTHING: drops insert rows whose unique key already exists at a snapshot. */
@@ -6149,10 +6532,13 @@ export class MinnowDatabase {
         const statementNow = this.#now();
         const filled = await fillColumnDefaults(table, proposed, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
         normalizeDomainBatch(table, filled.batch);
+        fillStoredGeneratedColumns(table, filled.batch, statement.rows.length, filled.generated);
         fillCompositePrimaryKey(table, filled.batch, statement.rows.length);
         const columns = visibleTableColumns(table).map(({ name }) => name);
         const deferredAutoIncrement = new Set(filled.autoIncrement?.missingIndexes ?? []);
-        const materializedRows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => name === filled.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex)
+        const generatedColumns = new Set(table.columns.flatMap((column) => (column.generatedValue === undefined ? [] : [column.name])));
+        const materializedRows = Array.from({ length: statement.rows.length }, (_, rowIndex) => columns.map((name) => generatedColumns.has(name) ||
+            (name === filled.autoIncrement?.column.name && deferredAutoIncrement.has(rowIndex))
             ? { default: true }
             : (filled.batch.columns[name]?.[rowIndex] ?? null)));
         const keys = filled.batch.columns[keyColumn.name] ?? [];
@@ -6457,7 +6843,11 @@ export class MinnowDatabase {
                     const stageRows = async (rows) => {
                         if (rows.length === 0)
                             return;
-                        const batchResult = { columns: tableColumns.map(({ name }) => name), rows: [...rows] };
+                        const batchResult = {
+                            columns: tableColumns.map(({ name }) => name),
+                            columnDomains: tableColumns.map(({ sqlDomain }) => sqlDomain ?? null),
+                            rows: [...rows],
+                        };
                         if (queryResultRetainedBytes(batchResult) > executionMemoryBudgetBytes) {
                             throw new QueryMemoryBudgetError("CREATE TABLE AS result batch", queryResultRetainedBytes(batchResult), 0, executionMemoryBudgetBytes);
                         }
@@ -6592,7 +6982,7 @@ export class MinnowDatabase {
                     }
                     const record = proof.records.find((candidate) => candidate.name === addColumnStatement.table);
                     if (record === undefined)
-                        throw new TypeError(`Unknown table: ${addColumnStatement.table}`);
+                        throw new UnknownTableError(addColumnStatement.table);
                     if (record.view !== undefined)
                         throw new TypeError(`${addColumnStatement.table} is a view, not a table`);
                     pinnedTableId ??= record.id;
@@ -6607,6 +6997,9 @@ export class MinnowDatabase {
                     if (record.columns.some(({ name }) => name === added.name)) {
                         throw new TypeError(`Column already exists: ${addColumnStatement.table}.${added.name}`);
                     }
+                    if (added.generatedValue !== undefined) {
+                        throw new TypeError("ALTER TABLE cannot add a generated column without rewriting existing rows");
+                    }
                     if (added.defaultValue !== undefined) {
                         validateColumnDefault({
                             name: added.name,
@@ -6765,11 +7158,19 @@ export class MinnowDatabase {
             return this.#mergeConflictingInsertRows(statement, options);
         }
         if (statement.kind === "insert" && statement.rows.length === 0) {
+            const table = await this.#findTable(statement.table);
+            const returningColumns = options.returning === undefined
+                ? undefined
+                : options.returning === "*"
+                    ? visibleTableColumns(table).map(({ name }) => name)
+                    : [...options.returning];
             return {
                 kind: "insert",
                 table: statement.table,
                 rowCount: 0,
-                ...(options.returning === undefined ? {} : { returnedRows: [] }),
+                ...(returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, [])),
             };
         }
         if (statement.kind === "insert") {
@@ -6831,7 +7232,7 @@ export class MinnowDatabase {
                 ...(returningColumns === undefined
                     ? {}
                     : {
-                        returnedRows: statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns.map((name) => {
+                        ...returningExecuteFields(table, returningColumns, statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns.map((name) => {
                             const column = table.columns.find((candidate) => candidate.name === name);
                             const position = statement.columns.indexOf(name);
                             const inserted = position < 0 ? undefined : row[position];
@@ -6841,7 +7242,7 @@ export class MinnowDatabase {
                                     ? null
                                     : boundInsertValue(inserted));
                             return [name, executionSqlValueFromInput(column, value)];
-                        }))),
+                        })))),
                     }),
             };
         }
@@ -6903,6 +7304,32 @@ export class MinnowDatabase {
             having: [],
             orderBy: [],
         };
+        if (statement.kind === "delete" && returningColumns === undefined) {
+            const internalWriter = options.writer;
+            if (internalWriter.queryFirstColumn !== undefined) {
+                const selectedKeys = await internalWriter.queryFirstColumn(plan);
+                if (selectedKeys !== undefined) {
+                    const keys = selectedKeys;
+                    if (keyColumn.type === "string" && keyColumn.sqlDomain === undefined) {
+                        for (let index = 0; index < keys.length; index += 1) {
+                            keys[index] = storedSqlValueFromExecution(keyColumn, keys[index] ?? null);
+                        }
+                    }
+                    if (keys.some((key) => key === null)) {
+                        throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
+                    }
+                    if (keys.length === 0) {
+                        return { kind: "delete", table: table.name, rowCount: 0 };
+                    }
+                    const deleted = await internalWriter.deleteBatch(table.name, { keys });
+                    return {
+                        kind: "delete",
+                        table: table.name,
+                        rowCount: deleted.rowCount,
+                    };
+                }
+            }
+        }
         let rows;
         if (options.writer !== undefined) {
             // Inside a scope the rows to touch are the ones the scope can see, which includes what it
@@ -6930,7 +7357,9 @@ export class MinnowDatabase {
                     kind: "delete",
                     table: table.name,
                     rowCount: 0,
-                    ...(returnedRows === undefined ? {} : { returnedRows }),
+                    ...(returnedRows === undefined || returningColumns === undefined
+                        ? {}
+                        : returningExecuteFields(table, returningColumns, returnedRows)),
                 };
             }
             const deleted = options.writer === undefined
@@ -6943,7 +7372,9 @@ export class MinnowDatabase {
                 ...(deleted.version === undefined || deleted.version === null
                     ? {}
                     : { version: deleted.version }),
-                ...(returnedRows === undefined ? {} : { returnedRows }),
+                ...(returnedRows === undefined || returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, returnedRows)),
             };
         }
         if (keys.length === 0) {
@@ -6951,7 +7382,9 @@ export class MinnowDatabase {
                 kind: "update",
                 table: table.name,
                 rowCount: 0,
-                ...(returningColumns === undefined ? {} : { returnedRows: [] }),
+                ...(returningColumns === undefined
+                    ? {}
+                    : returningExecuteFields(table, returningColumns, [])),
             };
         }
         const changes = {};
@@ -6984,7 +7417,9 @@ export class MinnowDatabase {
                 name,
                 returnedChanges !== undefined && name in returnedChanges
                     ? (returnedChanges[name]?.[index] ?? null)
-                    : (row[name] ?? null),
+                    : updated.generatedColumns?.[name] !== undefined
+                        ? (updated.generatedColumns[name][index] ?? null)
+                        : (row[name] ?? null),
             ])));
         return {
             kind: "update",
@@ -6993,7 +7428,9 @@ export class MinnowDatabase {
             ...(updated.version === undefined || updated.version === null
                 ? {}
                 : { version: updated.version }),
-            ...(returnedRows === undefined ? {} : { returnedRows }),
+            ...(returnedRows === undefined || returningColumns === undefined
+                ? {}
+                : returningExecuteFields(table, returningColumns, returnedRows)),
         };
     }
     /**
@@ -7028,6 +7465,7 @@ export class MinnowDatabase {
      */
     async #queryStreamed(plan, options, spillPageRows, probe, cursor) {
         options = this.#effectiveQueryOptions(options);
+        throwIfAborted(options.signal);
         const tableNames = [plan.base.table, ...plan.joins.map((join) => join.table)];
         const uniqueTableNames = [...new Set(tableNames)];
         if (options.version === undefined) {
@@ -7057,6 +7495,7 @@ export class MinnowDatabase {
         });
     }
     async #queryStreamedAtSnapshot(plan, options, spillPageRows, snapshot, tables, visibility, cursor) {
+        throwIfAborted(options.signal);
         // Copy-on-write: expansion clones only full-text plans, leaving the compile cache's copy
         // untouched.
         plan = expandFtsColumns(plan, (tableName) => searchableFtsColumns(tables.find((table) => table.name === tableName)));
@@ -7077,7 +7516,9 @@ export class MinnowDatabase {
         const visibleByTable = new Map();
         const rowCounts = new Map();
         for (const table of tables) {
+            throwIfAborted(options.signal);
             const segments = await this.#visibleSegmentRecords(table, snapshot, visibility);
+            throwIfAborted(options.signal);
             visibleByTable.set(table.name, segments);
             if (segments.every((segment) => {
                 const kind = segment.kind;
@@ -7092,7 +7533,7 @@ export class MinnowDatabase {
             plan = chooseJoinOrder(plan, rowCounts);
         const baseTable = tables.find((table) => table.name === plan.base.table);
         if (baseTable === undefined)
-            throw new TypeError(`Unknown table: ${plan.base.table}`);
+            throw new UnknownTableError(plan.base.table);
         const requestedBaseColumns = columns.get(baseTable.name) ?? [];
         const projectedBaseColumns = requestedBaseColumns.length === 0 ? [] : resolveReadColumns(baseTable, requestedBaseColumns);
         if (secondaryIndexOrderForPlan(plan, baseTable, projectedBaseColumns, false) !== undefined) {
@@ -7111,6 +7552,7 @@ export class MinnowDatabase {
                 record.name,
                 record.id === freshBaseTable.id ? freshBaseTable : record,
             ])), snapshot, visibility);
+            throwIfAborted(options.signal);
             if (planContainsFts(plan, "bm25") && ftsStats === undefined)
                 return undefined;
             // The streamed scan honors the same index pruning as the materialized path; a budgeted
@@ -7119,11 +7561,14 @@ export class MinnowDatabase {
                 (await this.#visibleSegmentRecords(freshBaseTable, snapshot, visibility));
             this.#maybeScheduleAutoCompaction(freshBaseTable, visibleBaseSegments);
             const ftsSegments = await this.#ftsPrunedSegments(freshBaseTable, visibleBaseSegments, plan, snapshot);
+            throwIfAborted(options.signal);
             const indexed = await this.#secondaryIndexPrunedSegments(freshBaseTable, ftsSegments, plan, snapshot);
+            throwIfAborted(options.signal);
             const baseSegments = indexed.segments;
             // Zone-map elimination composes after index pruning: whole row groups whose statistics
             // reject the plan's predicates never stream at all.
             const zonePruned = await this.#zonePrunedStreamSegments(plan, freshBaseTable, projectedBaseColumns, baseSegments, snapshot);
+            throwIfAborted(options.signal);
             const baseView = this.#streamedViewFactory(baseTable, projectedBaseColumns, zonePruned?.segments ?? baseSegments, snapshot, zonePruned?.storedBlocks, zonePruned !== undefined || indexed.pruned);
             if (baseView === undefined)
                 return undefined;
@@ -7145,26 +7590,31 @@ export class MinnowDatabase {
                         const budget = options.executionMemoryBudgetBytes;
                         const estimate = estimatedColumnarBytes(buildSegments, projectedBuildColumns);
                         if (buildView !== undefined && estimate > budget / 4) {
-                            return this.#runPartitionedJoin(plan, budget, estimate, baseView, buildView, buildTable.name, partitionedShape.buildKeyName);
+                            return this.#runPartitionedJoin(plan, budget, estimate, baseView, buildView, buildTable.name, partitionedShape.buildKeyName, options.signal);
                         }
                     }
                 }
             }
             const runStreamedExecution = async (attempt) => {
+                throwIfAborted(options.signal);
                 const memory = new QueryMemoryContext(options.executionMemoryBudgetBytes);
                 let prepared;
                 try {
                     const streamed = await baseView.create(memory);
+                    throwIfAborted(options.signal);
                     const inputTables = new Map([[baseTable.name, streamed.table]]);
                     for (const table of tables) {
+                        throwIfAborted(options.signal);
                         if (table.name === baseTable.name)
                             continue;
                         const requestedColumns = columns.get(table.name) ?? [];
                         inputTables.set(table.name, await this.#materializeColumnarTableAtSnapshot(table, snapshot, requestedColumns.length === 0 ? [] : resolveReadColumns(table, requestedColumns), visibility));
+                        throwIfAborted(options.signal);
                     }
                     prepared = createPreparedColumnarQuery(plan, inputTables, memory, {
                         ...(ftsStats === undefined ? {} : { ftsStats }),
                         outputNeedsExternalization: queryResultNeedsExternalization(plan, typedSchemas),
+                        outputColumnDomains: inferResultColumnDomains(plan, typedSchemas),
                     });
                     if (cursor !== undefined) {
                         const emission = { happened: false };
@@ -7172,20 +7622,37 @@ export class MinnowDatabase {
                             batchRows: cursor.batchRows,
                             signal: cursor.signal,
                             loadScanWindow: streamed.load,
+                            ...(cursor.consumeFirstColumn === undefined
+                                ? {}
+                                : {
+                                    consumeFirstColumn: async (values) => {
+                                        emission.happened = true;
+                                        await cursor.consumeFirstColumn?.(values);
+                                    },
+                                }),
                         }, async (batch) => {
                             emission.happened = true;
                             await cursor.consume(externalizeQueryResult(batch));
                         });
                         if (!emission.happened) {
-                            await cursor.consume({ columns: [...columns], rows: [] });
+                            await cursor.consume({
+                                columns: [...columns],
+                                columnDomains: inferResultColumnDomains(plan, typedSchemas),
+                                rows: [],
+                            });
                         }
                         options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
-                        return { columns: [...columns], rows: [] };
+                        return {
+                            columns: [...columns],
+                            columnDomains: inferResultColumnDomains(plan, typedSchemas),
+                            rows: [],
+                        };
                     }
                     if (!attempt.spill) {
                         try {
                             const streamedResult = await prepared.executeAsync({
                                 loadScanWindow: streamed.load,
+                                ...(options.signal === undefined ? {} : { signal: options.signal }),
                             });
                             options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
                             return streamedResult;
@@ -7200,6 +7667,7 @@ export class MinnowDatabase {
                         ...(spillPageRows === undefined ? {} : { spillPageRows }),
                         spillStore: this.#leasedSpillStore(),
                         loadScanWindow: streamed.load,
+                        ...(options.signal === undefined ? {} : { signal: options.signal }),
                     });
                     options.onStats?.({ peakMemoryBytes: memory.usage.peakBytes });
                     return spilledResult;
@@ -7449,7 +7917,8 @@ export class MinnowDatabase {
      * like any unordered query. The rescans trade time for bounded memory; the decoded-block
      * cache keeps repeat decodes cheap.
      */
-    async #runPartitionedJoin(plan, budgetBytes, estimatedBuildBytes, baseView, buildView, buildTableName, buildKeyName) {
+    async #runPartitionedJoin(plan, budgetBytes, estimatedBuildBytes, baseView, buildView, buildTableName, buildKeyName, signal) {
+        throwIfAborted(signal);
         // One partition should fit in an eighth of the budget: the resident partition briefly
         // exists twice (boxed rows, then their vectors) and shares the budget with both streamed
         // windows and the accumulating result.
@@ -7462,6 +7931,7 @@ export class MinnowDatabase {
         try {
             const combined = [];
             for (let partition = 0; partition < partitions; partition += 1) {
+                throwIfAborted(signal);
                 if (combined.length >= wantedRows)
                     break;
                 const passMemory = root.createChild();
@@ -7472,6 +7942,7 @@ export class MinnowDatabase {
                     const collectMemory = passMemory.createChild();
                     const buildScanMemory = collectMemory.createChild();
                     const build = await buildView.create(buildScanMemory);
+                    throwIfAborted(signal);
                     let buildRows = [];
                     const buildColumns = [...build.table.columns.entries()];
                     // Small steps keep the collection windows a minor budget term next to the resident
@@ -7479,8 +7950,10 @@ export class MinnowDatabase {
                     // consumed length clamps to the returned resident end.
                     const step = 1_024;
                     for (let start = 0; start < build.table.rowCount;) {
+                        throwIfAborted(signal);
                         let length = Math.min(step, build.table.rowCount - start);
                         const residentEnd = await build.load(start, length);
+                        throwIfAborted(signal);
                         if (typeof residentEnd === "number" && residentEnd > start) {
                             length = Math.min(length, residentEnd - start);
                         }
@@ -7511,13 +7984,17 @@ export class MinnowDatabase {
                     const buildInput = columnarTableFromRows(buildTableName, buildRows, undefined, false);
                     buildRows = [];
                     const streamedBase = await baseView.create(passMemory);
+                    throwIfAborted(signal);
                     const inputTables = new Map([
                         [buildTableName, buildInput],
                         [streamedBase.table.name, streamedBase.table],
                     ]);
                     prepared = createPreparedColumnarQuery(strippedPlan, inputTables, passMemory);
                     collectMemory.close();
-                    const result = await prepared.executeAsync({ loadScanWindow: streamedBase.load });
+                    const result = await prepared.executeAsync({
+                        loadScanWindow: streamedBase.load,
+                        ...(signal === undefined ? {} : { signal }),
+                    });
                     for (const row of result.rows) {
                         if (combined.length >= wantedRows)
                             break;
@@ -7534,7 +8011,8 @@ export class MinnowDatabase {
             const rows = startRow > 0 || limit !== undefined
                 ? combined.slice(startRow, limit === undefined ? undefined : startRow + limit)
                 : combined;
-            return { columns: plan.select.map((item) => item.alias), rows };
+            const columns = plan.select.map((item) => item.alias);
+            return { columns, columnDomains: unknownColumnDomains(columns), rows };
         }
         finally {
             root.close();
@@ -8080,17 +8558,24 @@ export class MinnowDatabase {
         };
     }
     /** Prepares one block's inputs and executes it, returning the caller-owned result. */
-    async #executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const ftsStats = await this.#ftsIndexStats(block, realTables, snapshot, visibility);
-        const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows);
+        throwIfAborted(signal);
+        const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         const prepared = createPreparedColumnarQuery(block, inputs, memory.createChild(), ftsStats === undefined ? {} : { ftsStats });
         try {
             if (!allowSpill || memory.usage.budgetBytes === Number.MAX_SAFE_INTEGER) {
-                return prepared.execute();
+                const result = prepared.execute();
+                throwIfAborted(signal);
+                return result;
             }
             if (!forceSpill) {
                 try {
-                    return prepared.execute();
+                    const result = prepared.execute();
+                    throwIfAborted(signal);
+                    return result;
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
@@ -8100,6 +8585,7 @@ export class MinnowDatabase {
             return await prepared.executeAsync({
                 spillStore: this.#leasedSpillStore(),
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
+                ...(signal === undefined ? {} : { signal }),
             });
         }
         finally {
@@ -8113,14 +8599,17 @@ export class MinnowDatabase {
      * real tables it references, so an identical block over identical table states reuses
      * the previous result instead of re-reading and re-executing.
      */
-    async #executeBlockCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlockCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const key = await this.#blockResultCacheKey(block, snapshot, visibility, realTables, cacheResults);
+        throwIfAborted(signal);
         if (key !== undefined) {
             const cached = this.#cacheGet(key);
             if (cached !== undefined)
                 return cached;
         }
-        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         if (key !== undefined)
             this.#cachePut(key, result, queryResultRetainedBytes(result));
         return result;
@@ -8131,15 +8620,18 @@ export class MinnowDatabase {
      * synthetic sources in typedSchemas, and a later cache hit skips that registration, so
      * re-inferring the schema at hit time would find those names missing.
      */
-    async #executeBlockWithSchemaCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows) {
+    async #executeBlockWithSchemaCached(block, snapshot, visibility, memory, realTables, typedSchemas, cacheResults = true, allowSpill = true, forceSpill = false, spillPageRows, signal) {
+        throwIfAborted(signal);
         const key = await this.#blockResultCacheKey(block, snapshot, visibility, realTables, cacheResults);
+        throwIfAborted(signal);
         const schemaKey = key === undefined ? undefined : `s${key}`;
         if (schemaKey !== undefined) {
             const cached = this.#cacheGet(schemaKey);
             if (cached !== undefined)
                 return cached;
         }
-        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows);
+        const result = await this.#executeBlock(block, snapshot, visibility, memory, realTables, typedSchemas, undefined, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
+        throwIfAborted(signal);
         const schema = inferBlockSchema(block, typedSchemas);
         const entry = { result, schema };
         if (schemaKey !== undefined) {
@@ -10512,7 +11004,7 @@ export class MinnowDatabase {
             if (recoveredManifest === undefined) {
                 throw new Error(`Compaction manifest is missing: ${String(linkedTransaction.committedVersion)}`);
             }
-            this.#afterCompactionCommit(recoveredManifest);
+            this.#afterCompactionCommit(recoveredManifest, table.id);
             return this.#publishedCompactionProgress(table, job);
         }
         const rewritePlan = job.rewritePlan;
@@ -10698,7 +11190,7 @@ export class MinnowDatabase {
                 let publicationConflict;
                 try {
                     manifest = await transaction.commit();
-                    this.#afterCompactionCommit(manifest);
+                    this.#afterCompactionCommit(manifest, table.id);
                     break;
                 }
                 catch (error) {
@@ -11531,7 +12023,7 @@ export class MinnowDatabase {
         }
         const table = tables.find((candidate) => candidate.name === tableName);
         if (table === undefined || table.view !== undefined) {
-            throw new TypeError(`Unknown table: ${tableName}`);
+            throw new UnknownTableError(tableName);
         }
         if (indexColumns.length === 0)
             throw new TypeError("An index needs at least one column");
@@ -13739,7 +14231,7 @@ export class MinnowDatabase {
         validateName(name, "Table");
         const table = await this.store.getTableByName(name);
         if (table === undefined)
-            throw new Error(`Table not found: ${name}`);
+            throw new UnknownTableError(name);
         // Reads resolve a view into its query before reaching here, so a view arriving at this
         // point is a write, a DDL statement, or a path that forgot to rewrite: all of them errors.
         if (table.view !== undefined)
@@ -13939,13 +14431,27 @@ function assertTriggerBodyTargetSchema(compiled, target) {
                 if (column !== undefined &&
                     isDefaultInsertValue(value) &&
                     !column.nullable &&
-                    column.defaultValue === undefined) {
+                    column.defaultValue === undefined &&
+                    column.generatedValue === undefined) {
                     throw new TypeError(`Trigger body INSERT uses DEFAULT for a non-nullable column without a default: ${column.name}`);
                 }
             }
         }
+        for (const [index, column] of insertColumns.entries()) {
+            if (column.generatedValue === undefined)
+                continue;
+            for (const row of compiled.rows) {
+                const value = row[index];
+                if (value === undefined || !isDefaultInsertValue(value)) {
+                    throw new TypeError(`Trigger body INSERT assigns generated column: ${column.name}`);
+                }
+            }
+        }
         for (const column of columns) {
-            if (!provided.has(column.name) && !column.nullable && column.defaultValue === undefined) {
+            if (!provided.has(column.name) &&
+                !column.nullable &&
+                column.defaultValue === undefined &&
+                column.generatedValue === undefined) {
                 throw new TypeError(`Trigger body INSERT omits a non-nullable column without a default: ${column.name}`);
             }
         }
@@ -13967,6 +14473,9 @@ function assertTriggerBodyTargetSchema(compiled, target) {
             if (assignedColumn === undefined) {
                 throw new TypeError(`Trigger body UPDATE assignment column does not exist: ${assignment.column}`);
             }
+            if (assignedColumn.generatedValue !== undefined) {
+                throw new TypeError(`Trigger body UPDATE assigns generated column: ${assignment.column}`);
+            }
             if (assignedColumn.id === target.uniqueKeyColumnId ||
                 (target.primaryKeyColumnIds ?? []).includes(assignedColumn.id)) {
                 throw new TypeError(`Trigger body UPDATE cannot update a key column: ${assignment.column}`);
@@ -14116,6 +14625,7 @@ function visibleSegmentManifestVersion(value, label) {
  */
 const compiledChecks = new Map();
 const COMPILED_CHECK_CACHE_LIMIT = 64;
+const compiledGeneratedColumns = new Map();
 function tableChecks(table) {
     const key = `${table.id}/${String(table.revision)}`;
     const cached = compiledChecks.get(key);
@@ -14138,6 +14648,84 @@ function tableChecks(table) {
     compiledChecks.set(key, compiled);
     return compiled;
 }
+function tableGeneratedExpressions(table) {
+    const key = `${table.id}/${String(table.revision)}`;
+    const cached = compiledGeneratedColumns.get(key);
+    if (cached !== undefined)
+        return cached;
+    const compiled = table.columns.flatMap((column) => column.generatedValue === undefined
+        ? []
+        : [
+            {
+                column,
+                expression: compileGeneratedColumnExpression(table.name, column.name, column.generatedValue.sql, table.columns),
+            },
+        ]);
+    if (compiledGeneratedColumns.size >= COMPILED_CHECK_CACHE_LIMIT) {
+        const oldest = compiledGeneratedColumns.keys().next().value;
+        if (oldest !== undefined)
+            compiledGeneratedColumns.delete(oldest);
+    }
+    compiledGeneratedColumns.set(key, compiled);
+    return compiled;
+}
+function normalizeGeneratedColumnValue(column, value, rowIndex) {
+    const stored = column.sqlDomain === undefined
+        ? storedSqlValueFromExecution(column, value)
+        : normalizeSqlDomainValue(column.sqlDomain, value);
+    validateValue(column, stored, rowIndex);
+    return stored;
+}
+/** Computes every stored generated column after defaults/domains have produced the base row. */
+function fillStoredGeneratedColumns(table, batch, rowCount, generated) {
+    for (const { column, expression } of tableGeneratedExpressions(table)) {
+        const values = new Array(rowCount);
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+            const row = batchRowAt(table, batch, rowIndex);
+            const value = evaluateRowExpression(expression, table.name, row);
+            values[rowIndex] = normalizeGeneratedColumnValue(column, value, rowIndex);
+        }
+        batch.columns[column.name] = values;
+        generated?.set(column.name, values.map((value) => externalSqlDomainValue(value)));
+    }
+}
+function rejectGeneratedUpdateAssignments(table, input) {
+    for (const column of table.columns) {
+        if (column.generatedValue !== undefined && input.changes[column.name] !== undefined) {
+            throw new TypeError(`Generated column cannot be assigned: ${column.name}`);
+        }
+    }
+}
+function generatedEvaluationRow(table, source) {
+    const row = {};
+    for (const column of table.columns) {
+        const value = source[column.name] ?? null;
+        row[column.name] =
+            column.sqlDomain === undefined
+                ? executionSqlValueFromStorage(column, value)
+                : normalizeSqlDomainValue(column.sqlDomain, value);
+    }
+    return row;
+}
+function applyStoredGeneratedUpdateChanges(table, input, preImages) {
+    const generated = tableGeneratedExpressions(table);
+    if (generated.length === 0)
+        return input;
+    const changes = { ...input.changes };
+    for (const { column, expression } of generated) {
+        changes[column.name] = input.keys.map((_, rowIndex) => {
+            const old = preImages[rowIndex];
+            if (old === undefined)
+                throw new Error(`Generated-column pre-image is missing: ${table.name}`);
+            const row = generatedEvaluationRow(table, old);
+            for (const [name, values] of Object.entries(input.changes)) {
+                row[name] = values[rowIndex] ?? null;
+            }
+            return normalizeGeneratedColumnValue(column, evaluateRowExpression(expression, table.name, row), rowIndex);
+        });
+    }
+    return { keys: input.keys, changes };
+}
 /**
  * Applies a table's CHECK constraints to one row (E141-06). A constraint fails only when it
  * evaluates to false: SQL's three-valued logic lets an unknown pass, which is why a NULL column
@@ -14995,32 +15583,72 @@ function compositeKeyValue(columns, values) {
 /** Canonicalizes logical PostgreSQL domains before validation and primitive block encoding. */
 function normalizeDomainBatch(table, input) {
     for (const column of table.columns) {
-        const domain = column.sqlDomain;
-        if (domain === undefined)
-            continue;
         const values = input.columns[column.name];
         if (values === undefined)
             continue;
-        input.columns[column.name] = values.map((value) => normalizeSqlDomainValue(domain, value));
+        if (column.sqlDomain !== undefined || column.type === "datetime") {
+            input.columns[column.name] = values.map((value) => normalizeColumnLogicalValue(column, value));
+        }
     }
 }
+function normalizeColumnLogicalValue(column, value) {
+    if (column.sqlDomain !== undefined)
+        return normalizeSqlDomainValue(column.sqlDomain, value);
+    if (column.type === "datetime" && isDateDomainValue(value)) {
+        const external = externalSqlDomainValue(value);
+        if (typeof external !== "string")
+            throw new TypeError("Invalid DATE value");
+        return new Date(`${external}T00:00:00.000Z`);
+    }
+    return value;
+}
+function selectBatchRows(input, indexes) {
+    return {
+        columns: Object.fromEntries(Object.entries(input.columns).map(([name, values]) => [
+            name,
+            indexes.map((index) => values[index] ?? null),
+        ])),
+        ...(input.omitted === undefined
+            ? {}
+            : {
+                omitted: Object.fromEntries(Object.entries(input.omitted).map(([name, values]) => [
+                    name,
+                    indexes.map((index) => values[index] ?? false),
+                ])),
+            }),
+        rowCount: indexes.length,
+    };
+}
+function normalizeUpsertConflictWhere(table, predicate) {
+    const operators = ["=", "!=", "<>", ">", ">=", "<", "<="];
+    if (!operators.includes(predicate.operator)) {
+        throw new TypeError(`Unsupported upsert conflict operator: ${predicate.operator}`);
+    }
+    const column = visibleTableColumns(table).find(({ name }) => name === predicate.column);
+    if (column === undefined) {
+        throw new TypeError(`Unknown upsert conflict column: ${table.name}.${predicate.column}`);
+    }
+    const value = normalizeColumnLogicalValue(column, predicate.value);
+    if (value !== null)
+        validateValue({ ...column, nullable: true }, value, 0);
+    return { column, operator: predicate.operator, value };
+}
 function normalizeDomainUpdate(table, input) {
-    if (!table.columns.some((column) => column.sqlDomain !== undefined))
+    if (!table.columns.some((column) => column.sqlDomain !== undefined || column.type === "datetime"))
         return input;
     let changed = false;
     const changes = { ...input.changes };
     for (const [name, values] of Object.entries(input.changes)) {
-        const domain = table.columns.find((column) => column.name === name)?.sqlDomain;
-        if (domain === undefined)
+        const column = table.columns.find((candidate) => candidate.name === name);
+        if (column === undefined || (column.sqlDomain === undefined && column.type !== "datetime"))
             continue;
         changed = true;
-        changes[name] = values.map((value) => normalizeSqlDomainValue(domain, value));
+        changes[name] = values.map((value) => normalizeColumnLogicalValue(column, value));
     }
     const key = getUniqueKeyColumn(table);
-    const keyDomain = key?.sqlDomain;
-    const keys = keyDomain === undefined
+    const keys = key === undefined || (key.sqlDomain === undefined && key.type !== "datetime")
         ? input.keys
-        : input.keys.map((value) => normalizeSqlDomainValue(keyDomain, value));
+        : input.keys.map((value) => normalizeColumnLogicalValue(key, value));
     return changed || keys !== input.keys ? { keys, changes } : input;
 }
 /** Coerces literals and bound parameters opposite a domain column before planning/index probes. */
@@ -15217,7 +15845,7 @@ function tryKeyToken(type, value) {
  * (level one and above) are the folded state, not fragmentation, and do not count — a large
  * keyed table is many partitions by design.
  */
-function autoCompactionDue(segments) {
+function autoCompactionHint(version, segments) {
     let levelZero = 0;
     let deltas = 0;
     for (const segment of segments) {
@@ -15227,7 +15855,18 @@ function autoCompactionDue(segments) {
         if (kind !== "insert" && kind !== "base")
             deltas += 1;
     }
-    return levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
+    return {
+        version,
+        visible: segments.length,
+        levelZero,
+        deltas,
+    };
+}
+function autoCompactionDueHint(hint) {
+    return hint.levelZero >= AUTO_COMPACT_SCAN_SEGMENTS || hint.deltas >= AUTO_COMPACT_DELTA_SEGMENTS;
+}
+function autoCompactionDue(segments) {
+    return autoCompactionDueHint(autoCompactionHint(null, segments));
 }
 /** A macrotask boundary, so background work lets queued queries and writes run between steps. */
 function yieldToEventLoop() {
@@ -16233,6 +16872,17 @@ function columnVectorKeyToken(type, vector, row) {
     }
     throw new Error("Column vector type mismatch");
 }
+function normalizedDatetimeLiteral(value) {
+    if (value instanceof Date)
+        return Number.isFinite(dateMilliseconds(value)) ? value : undefined;
+    if (!isDateDomainValue(value))
+        return undefined;
+    const external = externalSqlDomainValue(value);
+    if (typeof external !== "string")
+        return undefined;
+    const date = new Date(`${external}T00:00:00.000Z`);
+    return Number.isFinite(dateMilliseconds(date)) ? date : undefined;
+}
 function zonePredicates(plan, table) {
     if (plan.joins.length > 0 || plan.base.table !== table.name)
         return [];
@@ -16251,10 +16901,11 @@ function zonePredicates(plan, table) {
     const literalValue = (column, expression) => {
         if (expression.kind !== "literal")
             return undefined;
+        const datetime = column.type === "datetime" ? normalizedDatetimeLiteral(expression.value) : undefined;
         const value = column.type === "datetime"
-            ? expression.value instanceof Date
-                ? dateMilliseconds(expression.value)
-                : undefined
+            ? datetime === undefined
+                ? undefined
+                : dateMilliseconds(datetime)
             : typeof expression.value === "number"
                 ? expression.value
                 : undefined;
@@ -16297,10 +16948,11 @@ function zonePredicates(plan, table) {
         const column = leftColumn ?? rightColumn;
         if (column === undefined || literal.kind !== "literal")
             continue;
+        const datetime = column.type === "datetime" ? normalizedDatetimeLiteral(literal.value) : undefined;
         const value = column.type === "datetime"
-            ? literal.value instanceof Date
-                ? dateMilliseconds(literal.value)
-                : undefined
+            ? datetime === undefined
+                ? undefined
+                : dateMilliseconds(datetime)
             : typeof literal.value === "number"
                 ? literal.value
                 : undefined;
@@ -16330,9 +16982,16 @@ function secondaryIndexPredicates(plan, table) {
     const literalValue = (column, expression) => {
         if (expression.kind !== "literal" || expression.value === null)
             return undefined;
+        let value = expression.value;
+        if (column.type === "datetime" && isDateDomainValue(value)) {
+            const datetime = normalizedDatetimeLiteral(value);
+            if (datetime === undefined)
+                return undefined;
+            value = datetime;
+        }
         try {
-            secondaryIndexTerm(column.type, expression.value);
-            return expression.value;
+            secondaryIndexTerm(column.type, value);
+            return value;
         }
         catch {
             return undefined;