@minnowdb/core 0.7.1 → 0.7.5

package/dist/engine/database.js

@@ -1,3 +1,4 @@
+import { crossJoinPlan } from "../plan/model.js";
 import { toColumnarBatch } from "./batch.js";
 import { ArtifactCache } from "./artifact-cache.js";
 import { estimateBatchBytes, estimateRowBytes, estimateValuesBytes } from "./byte-estimates.js";
@@ -15,13 +16,13 @@ import { cachedQueryTerms, FTS_TOKENIZER_VERSION, renderDocumentValue, tokenize
 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, bindPendingSelectShapes, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDeferredInsertExpression, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, forEachNestedBlock, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, volatileScalarFunctionNames } from "./query.js";
+import { applyWindowFunctions, bindPendingSelectShapes, bindPlanParameters, bindStatementParameters, DUAL_TABLE, dualTableRows, blockHasSubqueries, combineUnionResults, compileCheckExpression, compileQuery, hasAggregate, createRecursiveCteState, annotateAvgArgumentScales, compileStatement, comparisonHolds, createPreparedColumnarQuery, evaluateJoinedRowExpression, evaluateRowExpression, externalizeQueryResult, expressionColumnNames, inferBlockSchema, inferResultColumnDomains, isDeferredInsertExpression, isDefaultInsertValue, referencedColumns, childExpressions, expandFtsColumns, expandNaturalJoins, expandSourceColumnAliases, expandViewSources, forEachBlockExpression, forEachNestedBlock, planContainsFts, planHasNaturalJoins, planHasSourceColumnAliases, planReadsTable, planReadsViews, planReadsBeyondSingleScan, projectResultColumns, queryResultNeedsExternalization, resolveStatementDatetimes, subqueryResolutionSteps, topLevelFtsMatchConjuncts, transparentProjectionSource, unknownColumnDomains, validateDefaultExpression, windowOutputDomain, windowOutputType, volatileScalarFunctionNames, annotatePlanIntegerDivision, clonePlanTree, planMayHaveIntegerDivision, foldIdentifierCase, extendGroupByWithKeyDependents, expandRowReferences } 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, optimizePlan, qualifyCorrelatedReferences, renderPlan } from "./optimizer.js";
-import { encodeSqlEqualityValue, parseSqlTimestampText } from "./sql-semantics.js";
-import { exactNumericAsNumber, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue } from "./sql-domains.js";
+import { encodeSqlEqualityValue, readUntypedText } from "./sql-semantics.js";
+import { exactNumericAsNumber, exactNumericValue, externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
 import { applyColumnSteps, assertColumnDroppable, compileGeneratedColumnExpression, declaredForeignKeys, isDestructiveStep, planMigration } from "./schema.js";
 import { columnarTableFromRows, createColumnarTable, vectorValue } from "./vector.js";
@@ -77,6 +78,9 @@ const AUTO_COLLECT_RETRY_MIN_MS = 1e3;
 const AUTO_COLLECT_RETRY_MAX_MS = 6e4;
 const AUTO_COMPACT_STEP_BLOCKS = 4;
 const AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS = 256;
+const AUTO_COMPACT_RETRY_MIN_MS = 250;
+const AUTO_COMPACT_RETRY_MAX_MS = 6e4;
+const MAX_COMPACTION_PUBLICATION_CONFLICTS = 64;
 const ZONE_DESCRIPTION_CACHE_BYTES = 160;
 const STAGED_OVERLAY_ORDER_BASE = 2 ** 52;
 class StaleTriggerDerivationsError extends Error {
@@ -202,6 +206,7 @@ function projectReturningItems(table, alias, items, rows, facts) {
     having: [],
     orderBy: []
   }, facts.domains, facts.types);
+  annotatePlanIntegerDivision(plan, (name) => facts.integers.get(name));
   const visible = visibleTableColumns(table);
   const columns = new Map(visible.map((column) => [
     column.name,
@@ -338,6 +343,18 @@ function resolveMutationStatementDatetimes(statement, now) {
       }
     };
   }
+  const sources = (from) => from === void 0 ? {} : {
+    from: {
+      ...from,
+      predicates: predicates(from.predicates),
+      joins: from.joins.map((join) => ({
+        ...join,
+        left: expression(join.left),
+        right: expression(join.right),
+        ...join.on === void 0 ? {} : { on: expression(join.on) }
+      }))
+    }
+  };
   if (statement.kind === "update") {
     return {
       ...statement,
@@ -345,11 +362,16 @@ function resolveMutationStatementDatetimes(statement, now) {
         ...assignment,
         expression: expression(assignment.expression)
       })),
-      predicates: predicates(statement.predicates)
+      predicates: predicates(statement.predicates),
+      ...sources(statement.from)
     };
   }
   if (statement.kind === "delete") {
-    return { ...statement, predicates: predicates(statement.predicates) };
+    return {
+      ...statement,
+      predicates: predicates(statement.predicates),
+      ...sources(statement.from)
+    };
   }
   if (statement.kind === "merge") {
     return {
@@ -580,6 +602,9 @@ class MinnowDatabase {
   #commitsSinceCompactionCheck = /* @__PURE__ */ new Map();
   #compactionSteps = /* @__PURE__ */ new Map();
   #writeChain = Promise.resolve();
+  #pendingCompactionPublications = /* @__PURE__ */ new Set();
+  #commitSignal;
+  #pendingEventLoopTurn;
   #pendingWriteReservations = 0;
   #activeReadReservations = 0;
   #autoCollectionTask;
@@ -695,6 +720,10 @@ class MinnowDatabase {
     this.#gzipVerdicts.clear();
     this.#autoCompactionsRequested.clear();
     this.#idleCompactionTableIds.clear();
+    for (const backoff of this.#autoCompactionBackoff.values()) {
+      if (backoff.retryTimer !== void 0)
+        clearTimeout(backoff.retryTimer);
+    }
     this.#autoCompactionBackoff.clear();
     this.#autoCompactionHints.clear();
     this.#commitsSinceCompactionCheck.clear();
@@ -980,6 +1009,7 @@ class MinnowDatabase {
   }
   async #runWrite(run) {
     const restarting = async () => {
+      await this.#publishPendingCompactions();
       await this.#assistAutomaticCollection();
       for (let attempt = 0; ; attempt += 1) {
         try {
@@ -1012,6 +1042,57 @@ class MinnowDatabase {
         this.#writeChain = Promise.resolve();
     }
   }
+  async #withCompactionPublicationSlot(attempt) {
+    return new Promise((resolve, reject) => {
+      let settled;
+      const claim = () => {
+        settled ??= (async () => {
+          try {
+            resolve(await attempt());
+          } catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+          } finally {
+            this.#pendingCompactionPublications.delete(claim);
+          }
+        })();
+        return settled;
+      };
+      this.#pendingCompactionPublications.add(claim);
+      void this.#eventLoopTurn().then(claim);
+    });
+  }
+  async #publishPendingCompactions() {
+    while (this.#pendingCompactionPublications.size > 0) {
+      const [claim] = this.#pendingCompactionPublications;
+      if (claim === void 0)
+        return;
+      await claim();
+    }
+  }
+  #eventLoopTurn() {
+    const pending = this.#pendingEventLoopTurn;
+    if (pending !== void 0)
+      return pending;
+    const turn = yieldToEventLoop().then(() => {
+      if (this.#pendingEventLoopTurn === turn)
+        this.#pendingEventLoopTurn = void 0;
+    });
+    this.#pendingEventLoopTurn = turn;
+    return turn;
+  }
+  #nextLocalCommit() {
+    if (this.#commitSignal === void 0) {
+      let resolve = () => void 0;
+      const promise = new Promise((settle) => {
+        resolve = settle;
+      });
+      this.#commitSignal = { promise, resolve };
+    }
+    return this.#commitSignal.promise;
+  }
+  async #yieldMaintenance() {
+    await Promise.race([this.#eventLoopTurn(), this.#nextLocalCommit()]);
+  }
   async #withWriteReservation(run) {
     if (this.#pendingWriteReservations >= MAX_DATABASE_PENDING_WRITES) {
       throw new RangeError(`A database cannot queue more than ${String(MAX_DATABASE_PENDING_WRITES)} writes; await a write for backpressure`);
@@ -2492,7 +2573,7 @@ class MinnowDatabase {
           catalogEpoch: after.catalogEpoch
         };
       }
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
   }
   async #acquireSharedLease(version) {
@@ -2667,7 +2748,15 @@ class MinnowDatabase {
             }
             memberSchema.forEach((column, index) => {
               const expected = schema2?.[index];
-              if (expected !== void 0 && (column.type !== expected.type || JSON.stringify(column.sqlDomain ?? null) !== JSON.stringify(expected.sqlDomain ?? null))) {
+              if (expected === void 0)
+                return;
+              if (column.type === expected.type && column.sqlDomain?.kind === "numeric" && expected.sqlDomain?.kind === "numeric") {
+                if (JSON.stringify(column.sqlDomain) !== JSON.stringify(expected.sqlDomain)) {
+                  schema2 = schema2?.map((entry, position) => position === index ? { ...entry, sqlDomain: { kind: "numeric" } } : entry);
+                }
+                return;
+              }
+              if (column.type !== expected.type || JSON.stringify(column.sqlDomain ?? null) !== JSON.stringify(expected.sqlDomain ?? null)) {
                 throw new TypeError(`UNION member column types must match: ${expected.name}`);
               }
             });
@@ -2782,7 +2871,13 @@ class MinnowDatabase {
       if (template !== null) {
         const shape = resolvePointReadShape(template, options.params ?? []);
         if (shape !== void 0) {
-          const point = await this.#pointReadResult(shape, options);
+          let point;
+          try {
+            point = await this.#pointReadResult(shape, options);
+          } catch (error) {
+            if (!(error instanceof UnknownTableError))
+              throw error;
+          }
           throwIfAborted(options.signal);
           if (point !== void 0)
             return externalizeQueryResult(point);
@@ -2905,9 +3000,11 @@ class MinnowDatabase {
   async #applyCatalogRewrites(plan, probe) {
     const aliased = planHasSourceColumnAliases(plan);
     const natural = planHasNaturalJoins(plan);
-    const { views, domains, types, columns: catalogColumns } = await this.#catalogFacts(probe);
+    const { views, domains, types, integers, keys, columns: catalogColumns } = await this.#catalogFacts(probe);
     let rewritten = plan.usesSequenceCalls === true ? await this.#resolveSequenceCalls(plan) : plan;
-    if (views.size > 0 && planReadsViews(plan, (name) => views.has(name))) {
+    rewritten = foldIdentifierCase(rewritten, catalogColumns);
+    rewritten = expandRowReferences(rewritten, (name) => catalogColumns.get(name));
+    if (views.size > 0 && planReadsViews(rewritten, (name) => views.has(name))) {
       const bodies = /* @__PURE__ */ new Map();
       rewritten = expandViewSources(rewritten, (name) => {
         const sql = views.get(name);
@@ -2924,6 +3021,13 @@ class MinnowDatabase {
     if (planReadsTable(rewritten, (name) => domains.has(name) || types.has(name))) {
       rewritten = normalizePlanDomainLiterals(rewritten, domains, types);
     }
+    if (integers.size > 0 && planMayHaveIntegerDivision(rewritten)) {
+      rewritten = clonePlanTree(rewritten);
+      annotatePlanIntegerDivision(rewritten, (name) => integers.get(name));
+    }
+    if (keys.size > 0) {
+      rewritten = extendGroupByWithKeyDependents(rewritten, (name) => keys.get(name), (name) => catalogColumns.get(name));
+    }
     const columnsOf = (name) => {
       const columns = catalogColumns.get(name);
       if (columns === void 0)
@@ -3034,6 +3138,14 @@ class MinnowDatabase {
       item.expression = await rewrite(item.expression);
     return resolved;
   }
+  async #foldTableName(name) {
+    const { columns } = await this.#catalogFacts();
+    if (columns.has(name))
+      return name;
+    const lowered = name.toLowerCase();
+    const matches = [...columns.keys()].filter((candidate) => candidate.toLowerCase() === lowered);
+    return matches.length === 1 ? matches[0] ?? name : name;
+  }
   async #catalogFacts(probe) {
     probe ??= await this.store.getCatalogProbe();
     const epoch = probe.catalogEpoch;
@@ -3045,10 +3157,23 @@ class MinnowDatabase {
     const domains = /* @__PURE__ */ new Map();
     const columns = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Map();
+    const integers = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Map();
     for (const table of await this.store.listTables()) {
       const visible = table.columns.filter(({ hidden }) => hidden !== true);
+      const keyColumn = getUniqueKeyColumn(table);
+      const keyNames = keyColumn !== void 0 && !keyColumn.hidden ? [keyColumn.name] : (table.primaryKeyColumnIds ?? []).flatMap((columnId) => {
+        const column = table.columns.find((candidate) => candidate.id === columnId);
+        return column === void 0 ? [] : [column.name];
+      });
+      if (keyNames.length > 0)
+        keys.set(table.name, keyNames);
       columns.set(table.name, visible.map(({ name }) => name));
       types.set(table.name, new Map(visible.map((column) => [column.name, column.type])));
+      const integerColumns = visible.filter((column) => column.integer === true);
+      if (integerColumns.length > 0) {
+        integers.set(table.name, new Set(integerColumns.map(({ name }) => name)));
+      }
       const tableDomains = new Map(table.columns.flatMap((column) => column.sqlDomain === void 0 ? [] : [[column.name, column.sqlDomain]]));
       if (tableDomains.size > 0)
         domains.set(table.name, tableDomains);
@@ -3062,7 +3187,7 @@ class MinnowDatabase {
           existing.push({ table, key });
       }
     }
-    const facts = { views, childKeys, domains, columns, types };
+    const facts = { views, childKeys, domains, columns, types, integers, keys };
     this.#catalogCache = { epoch, facts };
     return facts;
   }
@@ -3558,7 +3683,7 @@ class MinnowDatabase {
       if (page.nextCursor === null)
         break;
       cursor = page.nextCursor;
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
     return result;
   }
@@ -3583,7 +3708,7 @@ class MinnowDatabase {
       if (page.nextCursor === null)
         break;
       cursor = page.nextCursor;
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
     }
     return result;
   }
@@ -3793,8 +3918,11 @@ class MinnowDatabase {
       return;
     if (!autoCompactionDueHint(hint))
       return;
-    if (hint.visible < (this.#autoCompactionBackoff.get(table.id) ?? 0))
-      return;
+    const backoff = this.#autoCompactionBackoff.get(table.id);
+    if (backoff !== void 0) {
+      if (backoff.retryTimer !== void 0 || hint.visible < backoff.minimumSegments)
+        return;
+    }
     if (this.#autoCompactionsInFlight.has(table.id)) {
       this.#autoCompactionsRequested.add(table.id);
       return;
@@ -3802,22 +3930,43 @@ class MinnowDatabase {
     const run = this.#runAutoCompaction(table).then((folded) => {
       if (folded)
         this.#autoCompactionBackoff.delete(table.id);
-      else {
-        this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
-      }
+      else
+        this.#backOffAutoCompaction(table.id, hint.visible);
     }).catch(() => {
-      this.#autoCompactionBackoff.set(table.id, Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, hint.visible * 2)));
+      this.#backOffAutoCompaction(table.id, hint.visible);
     }).finally(() => {
       if (this.#autoCompactionsInFlight.get(table.id) === run) {
         this.#autoCompactionsInFlight.delete(table.id);
       }
       if (this.#autoCompactionsRequested.delete(table.id)) {
-        void yieldToEventLoop().then(() => this.#checkAutoCompaction(table.id));
+        void this.#yieldMaintenance().then(() => this.#checkAutoCompaction(table.id));
       }
     });
     this.#autoCompactionsInFlight.set(table.id, run);
     void run;
   }
+  #backOffAutoCompaction(tableId, visible) {
+    if (this.#closed)
+      return;
+    const previous = this.#autoCompactionBackoff.get(tableId);
+    if (previous?.retryTimer !== void 0)
+      clearTimeout(previous.retryTimer);
+    const failures = (previous?.failures ?? 0) + 1;
+    const delay = Math.min(AUTO_COMPACT_RETRY_MAX_MS, AUTO_COMPACT_RETRY_MIN_MS * 2 ** Math.min(16, failures - 1));
+    const timer = setTimeout(() => {
+      const current = this.#autoCompactionBackoff.get(tableId);
+      if (current?.retryTimer === timer) {
+        this.#autoCompactionBackoff.set(tableId, { ...current, retryTimer: void 0 });
+      }
+      void this.#checkAutoCompaction(tableId);
+    }, delay);
+    timer.unref?.();
+    this.#autoCompactionBackoff.set(tableId, {
+      minimumSegments: Math.min(AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS, Math.max(2, visible * 2)),
+      failures,
+      retryTimer: timer
+    });
+  }
   async #assertCompactionCapacity(table, transaction) {
     transaction?.limitLevelZeroSegments(table.id, MAX_LEVEL_ZERO_SEGMENTS);
     if (!this.#autoCompact)
@@ -3834,6 +3983,7 @@ class MinnowDatabase {
     }
     if (levelZero < MAX_LEVEL_ZERO_SEGMENTS)
       return;
+    await this.#publishPendingCompactions();
     await this.compactTableStep(table.name, {
       maxBlocks: AUTO_COMPACT_STEP_BLOCKS,
       maxLevel0Segments: AUTO_COMPACT_MAX_LEVEL_ZERO_SEGMENTS
@@ -3859,14 +4009,14 @@ class MinnowDatabase {
       while (progress.result === null) {
         if (progress.jobId === null)
           throw new Error("Compaction progress lost its job ID");
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
         progress = await this.resumeCompactionJob(progress.jobId, options);
       }
       if (!progress.result.compacted)
         return folded;
       folded = true;
       this.#maybeScheduleAutoCollection();
-      await yieldToEventLoop();
+      await this.#yieldMaintenance();
       const current = await this.store.getTable(table.id);
       if (current === void 0 || !autoCompactionDue(await this.#currentVisibleSegments(current))) {
         return folded;
@@ -3887,6 +4037,9 @@ class MinnowDatabase {
     return segments;
   }
   #afterCommit(manifest, transaction) {
+    const signal = this.#commitSignal;
+    this.#commitSignal = void 0;
+    signal?.resolve();
     if (this.#closed)
       return;
     const contribution = transaction?.committedCatalogContribution;
@@ -4265,6 +4418,7 @@ class MinnowDatabase {
     const statementNow = this.#now();
     const materialized = await this.#materializeInsertExpressions({ ...compiled, rows: derivedRows }, statementNow);
     const input = insertStatementBatch(materialized);
+    coerceSqlWriteBatch(target, input);
     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);
@@ -4293,6 +4447,9 @@ class MinnowDatabase {
       const bound = bindStatementParameters(compiled, params);
       if (bound.kind !== "update" && bound.kind !== "delete")
         continue;
+      if (bound.from !== void 0) {
+        throw new TypeError(`Trigger body ${bound.kind.toUpperCase()}s cannot join other sources`);
+      }
       const referenced = /* @__PURE__ */ new Set([keyColumn.name]);
       if (bound.kind === "update") {
         for (const assignment of bound.assignments) {
@@ -4417,6 +4574,7 @@ class MinnowDatabase {
     return this.#openWriteScope((session) => action(session));
   }
   async #openWriteScope(action, options = {}) {
+    await this.#publishPendingCompactions();
     await this.#assistAutomaticCollection();
     const transaction = await this.#transactions.beginDeferred({
       durableSnapshot: options.durableSnapshot ?? true
@@ -4458,6 +4616,9 @@ class MinnowDatabase {
           }));
         }
         const statement = bindStatementParameters(compiled, params);
+        if (statement.kind === "set" || statement.kind === "show") {
+          return externalizeExecuteResult(await this.runStatement(statement));
+        }
         if (!isTransactionalStatement(statement)) {
           throw new TypeError(`${statement.kind.toUpperCase().replace("-", " ")} is not allowed inside a write scope`);
         }
@@ -5371,15 +5532,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         })
       };
     }
+    if (statement.kind === "set" || statement.kind === "show") {
+      return externalizeExecuteResult(await this.runStatement(statement));
+    }
     const open = this.#openTransaction;
     if (open !== void 0) {
-      const boundStatement = bindStatementParameters(statement, params);
-      if (!isTransactionalStatement(boundStatement)) {
-        throw new TypeError(`${boundStatement.kind.toUpperCase().replace("-", " ")} is not allowed inside a transaction`);
+      const boundStatement2 = bindStatementParameters(statement, params);
+      if (!isTransactionalStatement(boundStatement2)) {
+        throw new TypeError(`${boundStatement2.kind.toUpperCase().replace("-", " ")} is not allowed inside a transaction`);
       }
-      return externalizeExecuteResult(await this.#projectReturningItems(boundStatement, await this.#duringTransaction(open, () => open.session.executeStatement(boundStatement))));
+      return externalizeExecuteResult(await this.#projectReturningItems(boundStatement2, await this.#duringTransaction(open, () => open.session.executeStatement(boundStatement2))));
     }
-    return externalizeExecuteResult(await this.#projectReturningItems(statement, await this.runStatement(bindStatementParameters(statement, params))));
+    const boundStatement = bindStatementParameters(statement, params);
+    return externalizeExecuteResult(await this.#projectReturningItems(boundStatement, await this.runStatement(boundStatement)));
   }
   async #assertForeignKeysPresent(table, rowsByColumn, read, transaction) {
     for (const key of table.foreignKeys ?? []) {
@@ -5691,12 +5856,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (keyColumn === void 0 || conflictColumns.length !== addressColumns.length || conflictColumns.some((name, index) => name !== addressColumns[index])) {
       throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
     }
+    statement = foldInsertColumns(table, statement);
     for (const name of statement.columns) {
       if (!table.columns.some((column) => column.name === name)) {
         throw new TypeError(`INSERT column does not exist: ${name}`);
       }
     }
     const proposedBatch = insertStatementBatch(statement);
+    coerceSqlWriteBatch(table, proposedBatch);
     const statementNow = this.#now();
     const filledProposed = await fillColumnDefaults(table, proposedBatch, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
     normalizeDomainBatch(table, filledProposed.batch);
@@ -5892,6 +6059,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
     }
     const proposed = insertStatementBatch(statement);
+    coerceSqlWriteBatch(table, proposed);
     const statementNow = this.#now();
     const filled = await fillColumnDefaults(table, proposed, (sql) => this.#evaluateDefaultExpression(sql, statementNow), statement.rows.length);
     normalizeDomainBatch(table, filled.batch);
@@ -6064,6 +6232,38 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (statement.kind === "select") {
       return { kind: "rows", result: await this.query(statement.sql) };
     }
+    if (statement.kind === "set") {
+      return { kind: "set", action: statement.action, name: statement.name };
+    }
+    if (statement.kind === "show") {
+      const settings = {
+        search_path: "public",
+        server_version: "16.0",
+        server_version_num: "160000",
+        timezone: "UTC",
+        time_zone: "UTC",
+        transaction_isolation: "repeatable read",
+        default_transaction_isolation: "repeatable read",
+        client_encoding: "UTF8",
+        server_encoding: "UTF8",
+        standard_conforming_strings: "on",
+        integer_datetimes: "on",
+        datestyle: "ISO, MDY",
+        intervalstyle: "postgres",
+        application_name: "",
+        is_superuser: "on",
+        max_identifier_length: "63"
+      };
+      const name = statement.name.toLowerCase();
+      const value = settings[name];
+      if (value === void 0) {
+        throw new TypeError(`unrecognized configuration parameter "${statement.name}"`);
+      }
+      return {
+        kind: "rows",
+        result: await this.query(`SELECT $1 AS ${quoteIdentifier(name)}`, { params: [value] })
+      };
+    }
     if (statement.kind === "create-enum") {
       const values = validateEnumValues(statement.values, statement.name);
       const storageName = `${ENUM_TYPE_PREFIX}${statement.name}`;
@@ -6495,12 +6695,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           throw new TypeError(`ON CONFLICT targets the table's primary or unique key columns: ${addressColumns.join(", ") || "(none)"}`);
         }
       }
-      for (const name of statement.columns) {
+      const spelledColumns = foldInsertColumns(table2, statement).columns;
+      for (const name of spelledColumns) {
         if (!table2.columns.some((column) => column.name === name)) {
           throw new TypeError(`INSERT column does not exist: ${name}`);
         }
       }
-      const input = insertStatementBatch(statement);
+      const input = insertStatementBatch({ ...statement, columns: spelledColumns });
+      coerceSqlWriteBatch(table2, input);
       normalizeDomainBatch(table2, input);
       let returningColumns2;
       if (options.returning !== void 0) {
@@ -6514,7 +6716,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       const writer = options.writer;
       const stagedKeyColumn = writer === void 0 ? void 0 : getUniqueKeyColumn(table2);
       if (writer !== void 0 && !viaUpsert && stagedKeyColumn !== void 0) {
-        const assignedGenerated = table2.columns.find((column) => column.generatedValue !== void 0 && statement.columns.includes(column.name));
+        const assignedGenerated = table2.columns.find((column) => column.generatedValue !== void 0 && spelledColumns.includes(column.name));
         if (assignedGenerated !== void 0) {
           throw new TypeError(`Generated column cannot be assigned: ${assignedGenerated.name}`);
         }
@@ -6530,7 +6732,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         ...returningColumns2 === void 0 ? {} : {
           ...returningExecuteFields(table2, returningColumns2, statement.rows.map((row, rowIndex) => Object.fromEntries(returningColumns2.map((name) => {
             const column = table2.columns.find((candidate) => candidate.name === name);
-            const position = statement.columns.indexOf(name);
+            const position = spelledColumns.indexOf(name);
             const inserted = position < 0 ? void 0 : row[position];
             const value = generated[name]?.[rowIndex] ?? input.columns[name]?.[rowIndex] ?? (inserted === void 0 || isDefaultInsertValue(inserted) ? null : boundInsertValue(inserted));
             return [name, executionSqlValueFromInput(column, value)];
@@ -6545,8 +6747,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     }
     const returningColumns = options.returning === void 0 ? void 0 : options.returning === "*" ? visibleTableColumns(table).map(({ name }) => name) : [...options.returning];
     const updateAssignments = statement.kind !== "update" ? [] : await (async () => {
+      const spelled = foldAssignmentColumns(table, statement.assignments);
       if (!table.columns.some((column) => column.sqlDomain !== void 0)) {
-        return statement.assignments;
+        return spelled;
       }
       const { domains } = await this.#catalogFacts();
       if (!domains.has(table.name))
@@ -6555,7 +6758,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         sql: `UPDATE ${table.name}`,
         base: { table: table.name, alias: table.name },
         joins: [],
-        select: statement.assignments.map((assignment) => ({
+        select: spelled.map((assignment) => ({
           expression: assignment.expression,
           alias: assignment.column
         })),
@@ -6564,20 +6767,25 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         having: [],
         orderBy: []
       }, domains);
-      return statement.assignments.map((assignment, index) => ({
+      return spelled.map((assignment, index) => ({
         ...assignment,
         expression: normalized.select[index]?.expression ?? assignment.expression
       }));
     })();
     const referenced = /* @__PURE__ */ new Set([keyColumn.name, ...returningColumns ?? []]);
     const assignmentAlias = (column) => `\0set:${column}`;
+    const targetAlias = statement.alias ?? table.name;
+    const from = statement.from;
     const plan = optimizePlan({
       sql: `(${statement.kind})`,
-      base: { table: table.name, alias: statement.alias ?? table.name },
-      joins: [],
+      base: { table: table.name, alias: targetAlias },
+      joins: from === void 0 ? [] : [crossJoinPlan(from.base), ...from.joins],
       select: [
         ...[...referenced].map((name) => ({
-          expression: { kind: "column", reference: name },
+          expression: {
+            kind: "column",
+            reference: from === void 0 ? name : `${targetAlias}.${name}`
+          },
           alias: name
         })),
         ...statement.kind === "update" ? updateAssignments.map((assignment) => ({
@@ -6585,12 +6793,12 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
           alias: assignmentAlias(assignment.column)
         })) : []
       ],
-      predicates: statement.predicates,
+      predicates: from === void 0 ? statement.predicates : [...statement.predicates, ...from.predicates],
       groupBy: [],
       having: [],
       orderBy: []
     });
-    if (statement.kind === "delete" && returningColumns === void 0) {
+    if (statement.kind === "delete" && returningColumns === void 0 && from === void 0) {
       const internalWriter = options.writer;
       if (internalWriter.queryFirstColumn !== void 0) {
         const selectedKeys = await internalWriter.queryFirstColumn(plan);
@@ -6622,6 +6830,16 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     } else {
       rows = (await this.#queryCompiled(plan)).rows;
     }
+    if (from !== void 0) {
+      const seen = /* @__PURE__ */ new Set();
+      rows = rows.filter((row) => {
+        const key = JSON.stringify(row[keyColumn.name] ?? null);
+        if (seen.has(key))
+          return false;
+        seen.add(key);
+        return true;
+      });
+    }
     const keys = keyColumn.type === "string" && keyColumn.sqlDomain === void 0 ? rows.map((row) => storedSqlValueFromExecution(keyColumn, row[keyColumn.name] ?? null)) : rows.map((row) => row[keyColumn.name] ?? null);
     if (keys.some((key) => key === null)) {
       throw new TypeError(`Unique key values must not be null: ${keyColumn.name}`);
@@ -6665,8 +6883,9 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         if (typeof value === "number" && !Number.isFinite(value)) {
           throw new TypeError(`UPDATE assignment produced a non-finite number: ${assignment.column}`);
         }
-        executionValues?.push(value);
-        return column.type === "string" && column.sqlDomain === void 0 ? storedSqlValueFromExecution(column, value) : value;
+        const stored = storedSqlValueFromExecution(column, value);
+        executionValues?.push(column.type === "string" && column.sqlDomain === void 0 ? value : stored);
+        return stored;
       });
       if (executionValues !== void 0 && returnedChanges !== void 0) {
         returnedChanges[assignment.column] = executionValues;
@@ -8050,7 +8269,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return active;
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return void 0;
   }
@@ -8088,11 +8307,15 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
   }
   async collectGarbage(options = {}) {
     const maxItems = boundedMaintenanceBatchItems(options.maxItemsPerStep ?? 64, "Garbage collection items per step");
+    let reconciliationCursor = null;
+    do {
+      reconciliationCursor = (await this.#reconcileCompactionPage(reconciliationCursor)).nextCursor;
+    } while (reconciliationCursor !== null);
     let progress = await this.collectGarbageStep({
       maxItems,
       ...options.maxPlanningItems === void 0 ? {} : { maxPlanningItems: options.maxPlanningItems },
@@ -8129,7 +8352,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         return active;
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return void 0;
   }
@@ -8170,14 +8393,14 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     this.#autoCollectionRequested = false;
     this.#commitsSinceCollection = 0;
     this.#lastCollectionAt = dateMilliseconds(this.#now());
-    const run = this.#runAutoCollection().then((moreWork) => {
+    const run = this.#runAutoCollection().then(({ moreWork, reclaimed }) => {
       this.#autoCollectionConsecutiveFailures = 0;
       this.#autoCollectionLastError = void 0;
       this.#lastCollectionCompletedAt = dateMilliseconds(this.#now());
       this.#autoCollectionRetryAt = void 0;
       if (moreWork)
         this.#autoCollectionRequested = true;
-      else
+      if (reclaimed || !moreWork)
         this.#autoCollectionDebtCommits = 0;
     }).catch((error) => {
       this.#autoCollectionConsecutiveFailures += 1;
@@ -8193,7 +8416,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         this.#autoCollectionTask = void 0;
       this.#autoCollectionInFlight = false;
       if (this.#autoCollectionRequested) {
-        void yieldToEventLoop().then(() => {
+        void this.#yieldMaintenance().then(() => {
           if (this.#closed) {
             this.#autoCollectionRequested = false;
             return;
@@ -8238,6 +8461,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   async #runAutoCollection() {
     const reconciliationMoreWork = await this.#reconcileCompactionMaintenance();
     let moreWork = false;
+    let reclaimed = false;
     for (let pass = 0; pass < AUTO_COLLECT_MAX_PASSES; pass += 1) {
       if (this.#closed)
         break;
@@ -8248,7 +8472,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         retainRecentVersions: AUTO_COLLECT_RETAINED_VERSIONS
       }, AUTO_COLLECT_RETAINED_VERSION_MS);
       while (progress.result === null) {
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
         progress = await this.resumeGarbageCollectionJob(progress.jobId, {
           maxItems: AUTO_COLLECT_STEP_ITEMS
         });
@@ -8258,14 +8482,19 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       if (!moreWork) {
         break;
       }
-      await yieldToEventLoop();
+      reclaimed = true;
+      await this.#yieldMaintenance();
     }
     await this.#pruneFinishedJobRecords();
-    return moreWork || reconciliationMoreWork;
+    return { moreWork: moreWork || reconciliationMoreWork, reclaimed };
   }
   async #reconcileCompactionMaintenance() {
-    const page = await this.store.listCompactionJobPage(this.#compactionReconciliationCursor, AUTO_COMPACTION_RECONCILE_RECORDS);
-    this.#compactionReconciliationCursor = page.nextCursor;
+    const { nextCursor, moreWork } = await this.#reconcileCompactionPage(this.#compactionReconciliationCursor);
+    this.#compactionReconciliationCursor = nextCursor;
+    return moreWork;
+  }
+  async #reconcileCompactionPage(cursor) {
+    const page = await this.store.listCompactionJobPage(cursor, AUTO_COMPACTION_RECONCILE_RECORDS);
     let moreWork = page.nextCursor !== null;
     const cutoff = dateIsoString(this.#now());
     for (const listed of page.records) {
@@ -8309,14 +8538,22 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
         continue;
       }
-      const progress = await this.resumeCompactionJob(job.id, { maxBlocks: 1 });
-      if (progress.result !== null) {
-        job = await this.store.getCompactionJob(job.id) ?? job;
-        if (!isActiveCompactionState(job.state))
+      try {
+        const progress = await this.resumeCompactionJob(job.id, { maxBlocks: 1 });
+        if (progress.result !== null) {
+          job = await this.store.getCompactionJob(job.id) ?? job;
+          if (!isActiveCompactionState(job.state))
+            continue;
+        }
+      } catch (error) {
+        if (error instanceof CompactionJobCancelledError)
           continue;
+        if (this.#closed)
+          throw error;
+        this.#maybeScheduleAutoCompaction(table, await this.#currentVisibleSegments(table));
       }
     }
-    return moreWork;
+    return { nextCursor: page.nextCursor, moreWork };
   }
   async #pruneFinishedJobRecords() {
     const newestFirst = (left, right) => right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id);
@@ -8337,7 +8574,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const retainedCompactionIds = new Set(newestCompactions.map((job) => job.id));
     cursor = null;
@@ -8387,7 +8624,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const newestCollections = [];
     cursor = null;
@@ -8399,7 +8636,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     const retainedCollectionIds = new Set(newestCollections.map((job) => job.id));
     cursor = null;
@@ -8412,7 +8649,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
   }
   async listGarbageCollectionJobs() {
@@ -8479,7 +8716,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return newest?.discovery === void 0 ? void 0 : { jobId: newest.id, discovery: newest.discovery };
   }
@@ -9137,7 +9374,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       cursor = page.nextCursor;
       if (cursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (cursor !== null);
     return largest;
   }
@@ -9716,7 +9953,17 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
     if (job.state === "published") {
       return this.#publishedCompactionProgress(table, job);
     }
-    const linkedTransaction = job.transactionId === null ? void 0 : await this.store.getTransaction(job.transactionId);
+    let linkedTransaction = job.transactionId === null ? void 0 : await this.store.getTransaction(job.transactionId);
+    if (job.transactionId !== null && linkedTransaction?.status === "active" && Date.parse(linkedTransaction.expiresAt) <= dateMilliseconds(this.#now())) {
+      const cutoff = dateIsoString(this.#now());
+      await this.store.abortTransactionIfExpired({
+        transactionId: linkedTransaction.id,
+        expectedOwnerId: linkedTransaction.ownerId,
+        expiresAtCutoff: cutoff,
+        updatedAt: cutoff
+      });
+      linkedTransaction = await this.store.getTransaction(job.transactionId);
+    }
     if (linkedTransaction?.status === "committed" && linkedTransaction.committedVersion !== null) {
       job = await this.#markCompactionPublished(job, linkedTransaction.committedVersion);
       const recoveredManifest = await this.store.getManifest(linkedTransaction.committedVersion);
@@ -9881,18 +10128,20 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       transaction.setCompactionIntent(job.id, job.sourceBlockIds);
       transaction.markLogicallyUnchanged();
-      let manifest;
-      for (; ; ) {
-        let publicationConflict;
+      let publicationConflict;
+      const publish = async () => {
         try {
-          manifest = await transaction.commit();
-          this.#afterCompactionCommit(manifest, table.id);
-          break;
+          const manifest2 = await transaction.commit();
+          this.#afterCompactionCommit(manifest2, table.id);
+          return manifest2;
         } catch (error) {
           if (!(error instanceof WriteConflictError))
             throw error;
           publicationConflict = error;
+          return void 0;
         }
+      };
+      const rebaseOverConcurrentCommits = async () => {
         const currentVersion = await this.store.getCurrentManifestVersion();
         const sourcePresence = await this.#manifestBlockPresence(currentVersion, job.sourceBlockIds);
         if (sourcePresence.some((present) => !present)) {
@@ -9919,7 +10168,24 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
         }
         transaction.setCompactionIntent(job.id, job.sourceBlockIds);
         transaction.markLogicallyUnchanged();
-        await yieldToEventLoop();
+      };
+      let manifest = await publish();
+      if (manifest === void 0) {
+        manifest = await this.#withCompactionPublicationSlot(async () => {
+          for (let conflicts = 1; conflicts <= MAX_COMPACTION_PUBLICATION_CONFLICTS; conflicts += 1) {
+            await rebaseOverConcurrentCommits();
+            const published = await publish();
+            if (published !== void 0)
+              return published;
+          }
+          return void 0;
+        });
+        if (manifest === void 0) {
+          if (transaction.status === "active")
+            await transaction.abort();
+          job = await this.#abortCompactionJob(job, `Compaction publication lost ${String(MAX_COMPACTION_PUBLICATION_CONFLICTS + 1)} manifest races`);
+          throw new Error(job.error, { cause: publicationConflict });
+        }
       }
       job = await this.#markCompactionPublished(job, manifest.version);
       return compactionProgress(table.name, job, this.#compactionResult(table, job, manifest.version));
@@ -10079,7 +10345,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
       }
       segmentCursor = page.nextCursor;
       if (segmentCursor !== null)
-        await yieldToEventLoop();
+        await this.#yieldMaintenance();
     } while (segmentCursor !== null);
     if (job.outputPartitionOrdinal === void 0 && job.targetLevel === 1 && plan.kind !== "copy-v1" && plan.partitions !== void 0) {
       const table = await this.store.getTable(job.tableId);
@@ -12633,7 +12899,7 @@ ${notes.map((note) => `-- ${note}`).join("\n")}`;
   }
   async #findTable(name) {
     validateName(name, "Table");
-    const table = await this.store.getTableByName(name);
+    const table = await this.store.getTableByName(name) ?? await this.store.getTableByName(await this.#foldTableName(name));
     if (table === void 0)
       throw new UnknownTableError(name);
     if (table.view !== void 0)
@@ -13328,7 +13594,26 @@ function postingFrequencyTotal(postings) {
 }
 const secondaryNumberBits = new DataView(new ArrayBuffer(8));
 function storedSqlValueFromExecution(column, value) {
-  return column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string" ? externalSqlTextValue(value) : value;
+  if (column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string") {
+    return externalSqlTextValue(value);
+  }
+  return coerceSqlWriteValue(column, value);
+}
+function coerceSqlWriteValue(column, value) {
+  if (column === void 0 || column.sqlDomain !== void 0 || column.type === "string" || typeof value !== "string" || isSqlDomainValue(value)) {
+    return value;
+  }
+  return readUntypedText(column.type, value);
+}
+function coerceSqlWriteBatch(table, input) {
+  for (const column of table.columns) {
+    if (column.type === "string" || column.sqlDomain !== void 0)
+      continue;
+    const values = input.columns[column.name];
+    if (!values?.some((value) => typeof value === "string"))
+      continue;
+    input.columns[column.name] = values.map((value) => coerceSqlWriteValue(column, value));
+  }
 }
 function executionSqlValueFromStorage(column, value) {
   return column?.type === "string" && column.sqlDomain === void 0 && typeof value === "string" ? protectedSqlTextValue(value) : value;
@@ -13815,6 +14100,28 @@ function compositeKeyValue(columns, values) {
   }
   return columns.map((column, index) => secondaryTupleComponent(column.type, values[index] ?? null)).join("");
 }
+function foldColumnName(table, name) {
+  const columns = visibleTableColumns(table);
+  if (columns.some((column) => column.name === name))
+    return name;
+  const lowered = name.toLowerCase();
+  const matches = columns.filter((column) => column.name.toLowerCase() === lowered);
+  return matches.length === 1 ? matches[0]?.name ?? name : name;
+}
+function foldInsertColumns(table, statement) {
+  const columns = statement.columns.map((name) => foldColumnName(table, name));
+  return columns.some((name, index) => name !== statement.columns[index]) ? { ...statement, columns } : statement;
+}
+function foldAssignmentColumns(table, assignments) {
+  const folded = assignments.map((assignment) => {
+    const column = foldColumnName(table, assignment.column);
+    return column === assignment.column ? assignment : { ...assignment, column };
+  });
+  return folded.some((assignment, index) => assignment !== assignments[index]) ? folded : assignments;
+}
+function quoteIdentifier(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
 function normalizeDomainBatch(table, input) {
   for (const column of table.columns) {
     const values = input.columns[column.name];
@@ -13899,23 +14206,8 @@ function normalizeDomainUpdate(table, input) {
 function normalizePlanDomainLiterals(input, domains, types = /* @__PURE__ */ new Map()) {
   const pass = { probing: true, needed: false };
   const coerceText = (type, text) => {
-    if (type === "datetime")
-      return parseSqlTimestampText(text);
-    if (type === "number") {
-      const trimmed = text.trim();
-      if (trimmed === "")
-        return void 0;
-      const parsed = Number(trimmed);
-      return Number.isFinite(parsed) ? parsed : void 0;
-    }
-    if (type === "boolean") {
-      const lowered = text.trim().toLowerCase();
-      if (lowered === "t" || lowered === "true" || lowered === "1")
-        return true;
-      if (lowered === "f" || lowered === "false" || lowered === "0")
-        return false;
-    }
-    return void 0;
+    const read = readUntypedText(type, text);
+    return read === text ? void 0 : read;
   };
   const rewriteBlock = (block) => {
     if (pass.probing && pass.needed)
@@ -14493,9 +14785,15 @@ function installStreamedWindow(vector, resident, windowStart, windowRows, memory
   mutable.window = { start: windowStart, length: windowRows };
 }
 function derivedColumnarTable(name, result, schema) {
-  const columns = new Map(schema.map(({ name: columnName, type }) => [
+  const columns = new Map(schema.map(({ name: columnName, type, sqlDomain }) => [
     columnName,
-    { type, values: result.rows.map((row) => row[columnName] ?? null) }
+    {
+      type,
+      values: sqlDomain?.kind === "numeric" ? result.rows.map((row) => {
+        const value = row[columnName] ?? null;
+        return typeof value === "number" ? exactNumericValue(value) : value;
+      }) : result.rows.map((row) => row[columnName] ?? null)
+    }
   ]));
   return createColumnarTable(name, columns);
 }