@crvouga/sqlite-mem 1.5.0 → 1.7.0

package/dist/index.js

@@ -1037,7 +1037,7 @@ var Parser = class {
       if (this.at("SELECT") || this.at("WITH") || this.at("VALUES")) {
         const select = this.at("SELECT") || this.at("WITH") ? this.parseSelectStmt() : this.parseValuesAsSelect();
         this.expect("RPAREN");
-        const alias3 = this.optionalAlias() ?? this.syntaxError("subquery in FROM requires an alias");
+        const alias3 = this.optionalAlias() ?? `__subq_${this.pos}`;
         return { type: "subquery", select, alias: alias3 };
       }
       const item = this.parseFromItem();
@@ -1264,13 +1264,15 @@ var Parser = class {
   // ── DELETE ──────────────────────────────────────────────────────────────
   parseDeleteStmt(withClause = this.parseOptionalWith()) {
     this.expect("DELETE");
+    const or = this.parseOrConflict();
     this.expect("FROM");
     const table = this.parseTableName();
     const alias = this.optionalAlias();
     let where = null;
     if (this.match("WHERE")) where = this.parseExpr();
     const returning = this.parseReturning();
-    return { type: "delete", with: withClause, table, alias, where, returning };
+    const orMode = or === null ? null : or === "REPLACE" ? "replace" : or === "IGNORE" ? "ignore" : or === "ABORT" ? "abort" : or === "ROLLBACK" ? "rollback" : "fail";
+    return { type: "delete", with: withClause, or: orMode, table, alias, where, returning };
   }
   // ── CREATE ──────────────────────────────────────────────────────────────
   parseCreateStmt() {
@@ -1559,9 +1561,9 @@ var Parser = class {
       } while (this.match("COMMA"));
       this.expect("RPAREN");
     }
-    const { onDelete, onUpdate } = this.parseFkActions();
+    const { onDelete, onUpdate, match } = this.parseFkActions();
     const { deferrable, initiallyDeferred } = this.parseDeferrable();
-    return { type: "references", table, columns, onDelete, onUpdate, deferrable, initiallyDeferred };
+    return { type: "references", table, columns, onDelete, onUpdate, match, deferrable, initiallyDeferred };
   }
   parseTableConstraint() {
     let name = null;
@@ -1607,7 +1609,7 @@ var Parser = class {
         } while (this.match("COMMA"));
         this.expect("RPAREN");
       }
-      const { onDelete, onUpdate } = this.parseFkActions();
+      const { onDelete, onUpdate, match } = this.parseFkActions();
       const { deferrable, initiallyDeferred } = this.parseDeferrable();
       return {
         type: "foreign_key",
@@ -1616,6 +1618,7 @@ var Parser = class {
         refColumns,
         onDelete,
         onUpdate,
+        match,
         name,
         deferrable,
         initiallyDeferred
@@ -1677,12 +1680,24 @@ var Parser = class {
   parseFkActions() {
     let onDelete = null;
     let onUpdate = null;
+    let match = "SIMPLE";
+    const readMatch = () => {
+      while (this.match("MATCH")) {
+        const word = this.parseIdent().toUpperCase();
+        if (word === "FULL") match = "FULL";
+        else if (word === "PARTIAL") match = "PARTIAL";
+        else match = "SIMPLE";
+      }
+    };
+    readMatch();
     while (this.at("ON")) {
       if (this.peek().kind === "DELETE") onDelete = this.parseFkAction("DELETE");
       else if (this.peek().kind === "UPDATE") onUpdate = this.parseFkAction("UPDATE");
       else this.syntaxError("expected ON DELETE or ON UPDATE");
+      readMatch();
     }
-    return { onDelete, onUpdate };
+    readMatch();
+    return { onDelete, onUpdate, match };
   }
   parseDeferrable() {
     let deferrable = false;
@@ -2557,32 +2572,46 @@ function applyAffinity(value, affinity) {
   if (value === null) return null;
   switch (affinity) {
     case "TEXT":
-      if (value instanceof Uint8Array) return utf8Decode(value);
+      if (value instanceof Uint8Array) return value;
       if (value instanceof SqlJsonText) return value.value;
       if (typeof value === "string") return value;
-      if (value instanceof SqlReal) return String(value.value);
+      if (value instanceof SqlReal) return formatRealAsText(value.value);
+      if (typeof value === "number") return String(canonicalizeNumber(value));
+      if (typeof value === "bigint") return value.toString();
       return String(value);
     case "INTEGER": {
+      if (value instanceof Uint8Array) return value;
       const n = coerceToNumber(value);
       if (n === null) return value;
       if (typeof value === "bigint") return value;
       return Number.isInteger(n) && Number.isSafeInteger(n) ? Math.trunc(n) : canonicalizeNumber(n);
     }
     case "REAL": {
+      if (value instanceof Uint8Array) return value;
       const n = coerceToNumber(value);
       return n === null ? value : asSqlReal(n);
     }
     case "NUMERIC": {
+      if (value instanceof Uint8Array) return value;
       const n = coerceToNumber(value);
       if (n === null) return value;
       if (Number.isInteger(n) && Number.isSafeInteger(n)) return Math.trunc(n);
       return canonicalizeNumber(n);
     }
     case "BLOB":
-      if (typeof value === "number") return canonicalizeNumber(value);
       return value;
   }
 }
+function formatRealAsText(value) {
+  const n = canonicalizeNumber(value);
+  if (Object.is(n, -0) || n === 0) return "0.0";
+  if (Number.isInteger(n) && Number.isSafeInteger(n)) return `${n}.0`;
+  const abs = Math.abs(n);
+  if (abs >= 1e16 || abs > 0 && abs < 1e-4) {
+    return n.toExponential(1).replace(/e([+-])(\d)$/, "e$10$2").replace(/e\+/, "e+");
+  }
+  return String(n);
+}
 function applyComparisonAffinity(left, right, leftAffinity, rightAffinity) {
   const leftNumeric = leftAffinity === "INTEGER" || leftAffinity === "REAL" || leftAffinity === "NUMERIC";
   const rightNumeric = rightAffinity === "INTEGER" || rightAffinity === "REAL" || rightAffinity === "NUMERIC";
@@ -8393,6 +8422,7 @@ var DatabaseState = class _DatabaseState {
             refColumns: constraint.columns,
             onDelete: constraint.onDelete,
             onUpdate: constraint.onUpdate,
+            match: constraint.match,
             name: null,
             deferrable: constraint.deferrable,
             initiallyDeferred: constraint.initiallyDeferred
@@ -9899,11 +9929,13 @@ function pragmaTableInfo(args, env, xinfo) {
   const tableName = requireNameArg(args, "table_info");
   const table = env.state.tables.get(tableName.toLowerCase());
   if (!table) return { columns: xinfoColumns(xinfo), rows: [] };
-  const rows = table.columns.map((column, cid) => {
+  const visible = xinfo ? table.columns : table.columns.filter((column) => !column.generated);
+  const rows = visible.map((column, cid) => {
     const pkIndex = table.columns.filter((c) => c.primaryKey).findIndex((c) => c.name === column.name);
     const pk = column.primaryKey ? pkIndex >= 0 ? pkIndex + 1 : 1 : 0;
     const dflt = column.defaultExpr ? defaultLiteral(column.defaultExpr) : null;
-    const base = [cid, column.name, column.typeName ?? "", column.notNull ? 1 : 0, dflt, pk];
+    const notNull = column.notNull || table.withoutRowid && column.primaryKey ? 1 : 0;
+    const base = [cid, column.name, column.typeName ?? "", notNull, dflt, pk];
     if (xinfo) {
       let hidden = 0;
       if (column.generated && !column.generated.stored) hidden = 2;
@@ -11362,10 +11394,20 @@ function scanFrom(item, env, parent) {
     if (item.joinType === "RIGHT" || item.joinType === "FULL") {
       right.forEach((rhs, rightIndex) => {
         if (matchedRight.has(rightIndex)) return;
-        const rightCells = using ? rhs.cells.map(
-          (cell) => using.some((name) => name.toLowerCase() === cell.name.toLowerCase()) ? { ...cell, hiddenByUsing: true } : cell
-        ) : rhs.cells;
-        result.push({ cells: [...nullLeft, ...rightCells] });
+        if (using) {
+          const leftCells = nullLeft.map((cell) => {
+            const shared = using.some((name) => name.toLowerCase() === cell.name.toLowerCase());
+            if (!shared) return cell;
+            const fromRight = rhs.cells.find((c) => c.name.toLowerCase() === cell.name.toLowerCase());
+            return { ...cell, value: fromRight?.value ?? null, hiddenByUsing: false };
+          });
+          const rightOnly = rhs.cells.filter(
+            (cell) => !using.some((name) => name.toLowerCase() === cell.name.toLowerCase())
+          );
+          result.push({ cells: [...leftCells, ...rightOnly] });
+        } else {
+          result.push({ cells: [...nullLeft, ...rhs.cells] });
+        }
       });
     }
     return result;
@@ -12567,7 +12609,7 @@ function executeInsertCore(stmt, env) {
   if (view) return executeViewInsert(stmt, view, env, totalBefore);
   const fast = tryFastInsert(stmt, env);
   if (fast) return fast;
-  const table = env.state.getWritableTable(stmt.table);
+  let table = env.state.getWritableTable(stmt.table);
   const columnNames = stmt.columns ?? table.columns.map((column) => column.name);
   const rowidIndexes = columnNames.map((name, index) => isRowidName3(name) ? index : -1).filter((index) => index >= 0);
   if (rowidIndexes.length > 1) throw new SqliteError("duplicate column name: rowid", "other");
@@ -12603,116 +12645,141 @@ function executeInsertCore(stmt, env) {
     env.state.recordChange(changes, last);
     return emptyResult(changes, last);
   }
-  for (const source of sourceRows) {
-    if (source.length !== columnNames.length)
-      throw new SqliteError(
-        stmt.columns ? `${source.length} values for ${columnNames.length} columns` : `table ${table.name} has ${columnNames.length} columns but ${source.length} values were supplied`,
-        "other"
-      );
-    const values = /* @__PURE__ */ new Map();
-    for (const column of table.columns) {
-      if (column.generated) continue;
-      const suppliedIndex = suppliedIndexes[table.columns.indexOf(column)] ?? -1;
-      const value = suppliedIndex >= 0 ? source[suppliedIndex] ?? null : column.defaultExpr ? evalExpr(column.defaultExpr, env.createEvalContext()) : null;
-      values.set(column.nameLower ?? column.name.toLowerCase(), storeColumnValue(table, column, value));
+  const abortMode = insertAbortResolution(stmt.mode) === "abort";
+  const undoInserted = [];
+  const undoRemoved = [];
+  const undoStatement = () => {
+    if (!abortMode) return;
+    for (let i = undoInserted.length - 1; i >= 0; i--) {
+      const row = table.rows.get(undoInserted[i]);
+      if (row) removeOne(table, row, env);
+    }
+    for (let i = undoRemoved.length - 1; i >= 0; i--) {
+      const row = undoRemoved[i];
+      table = env.state.ensureWritableTable(table);
+      table.rows.set(row.rowid, row);
+      if (table.indexes.length > 0) addIndexes(table, row, env);
     }
-    for (const column of table.columns) {
-      if (!column.generated) continue;
-      if (columnNames.some((name) => name.toLowerCase() === column.name.toLowerCase())) {
-        throw new SqliteError(`cannot INSERT into generated column "${column.name}"`, "misuse");
-      }
-      if (column.generated.stored) {
-        const genCtx = env.createEvalContext({
-          cells: table.columns.filter((c) => !c.generated || c === column).flatMap((c) => {
-            if (c.generated && c !== column) return [];
-            if (c === column) return [];
-            return [
-              {
-                table: table.name,
-                name: c.name,
-                value: values.get(normalizeColumnName(c.name)) ?? null,
-                affinity: c.affinity,
-                collate: c.collate
-              }
-            ];
-          })
-        });
-        const computed = evalExpr(column.generated.expr, genCtx);
-        values.set(normalizeColumnName(column.name), storeColumnValue(table, column, computed));
-      } else {
-        values.set(normalizeColumnName(column.name), null);
+  };
+  try {
+    for (const source of sourceRows) {
+      if (source.length !== columnNames.length)
+        throw new SqliteError(
+          stmt.columns ? `${source.length} values for ${columnNames.length} columns` : `table ${table.name} has ${columnNames.length} columns but ${source.length} values were supplied`,
+          "other"
+        );
+      const values = /* @__PURE__ */ new Map();
+      for (const column of table.columns) {
+        if (column.generated) continue;
+        const suppliedIndex = suppliedIndexes[table.columns.indexOf(column)] ?? -1;
+        const value = suppliedIndex >= 0 ? source[suppliedIndex] ?? null : column.defaultExpr ? evalExpr(column.defaultExpr, env.createEvalContext()) : null;
+        values.set(column.nameLower ?? column.name.toLowerCase(), storeColumnValue(table, column, value));
       }
-    }
-    if (fireInsertTriggers("BEFORE", table, values, null, env) === "ignore") continue;
-    const conflicts = conflictingRows(table, values, env);
-    if (conflicts.length > 0) {
-      if (stmt.upsert) {
-        const targetConflicts = conflictsForUpsert(table, values, env, stmt.upsert);
-        if (targetConflicts.length === 0) {
+      for (const column of table.columns) {
+        if (!column.generated) continue;
+        if (columnNames.some((name) => name.toLowerCase() === column.name.toLowerCase())) {
+          throw new SqliteError(`cannot INSERT into generated column "${column.name}"`, "misuse");
+        }
+        if (column.generated.stored) {
+          const genCtx = env.createEvalContext({
+            cells: table.columns.filter((c) => !c.generated || c === column).flatMap((c) => {
+              if (c.generated && c !== column) return [];
+              if (c === column) return [];
+              return [
+                {
+                  table: table.name,
+                  name: c.name,
+                  value: values.get(normalizeColumnName(c.name)) ?? null,
+                  affinity: c.affinity,
+                  collate: c.collate
+                }
+              ];
+            })
+          });
+          const computed = evalExpr(column.generated.expr, genCtx);
+          values.set(normalizeColumnName(column.name), storeColumnValue(table, column, computed));
+        } else {
+          values.set(normalizeColumnName(column.name), null);
+        }
+      }
+      if (fireInsertTriggers("BEFORE", table, values, null, env) === "ignore") continue;
+      const conflicts = conflictingRows(table, values, env);
+      if (conflicts.length > 0) {
+        if (stmt.upsert) {
+          const targetConflicts = conflictsForUpsert(table, values, env, stmt.upsert);
+          if (targetConflicts.length === 0) {
+            throw new SqliteError(
+              `UNIQUE constraint failed: ${table.name}`,
+              "constraint_unique",
+              "SQLITE_CONSTRAINT_UNIQUE"
+            );
+          }
+          if (stmt.upsert.action === "nothing") continue;
+          const row = targetConflicts[0];
+          const scope = scopeFor(table, row, stmt.table, env);
+          const excluded = {
+            cells: table.columns.map((column) => ({
+              table: "excluded",
+              name: column.name,
+              value: values.get(normalizeColumnName(column.name)) ?? null
+            }))
+          };
+          const merged = { cells: [...scope.cells, ...excluded.cells], rowid: row.rowid, sourceTable: table.name };
+          const ctx = env.createEvalContext(merged);
+          if (stmt.upsert.action.where && isTruthySql(evalExpr(stmt.upsert.action.where, ctx)) !== true) continue;
+          const updates = evaluateSet(stmt.upsert.action.set, table, ctx);
+          const updated = updateOne(table, row, updates, env);
+          changes += 1 + updated.cascaded;
+          if (stmt.returning.length)
+            returningRows.push(projectReturning(stmt.returning, scopeFor(table, updated.row, stmt.table, env), env));
+          continue;
+        }
+        const mode = stmt.mode;
+        if (mode === "insert_or_ignore") continue;
+        if (mode === "replace" || mode === "insert_or_replace") {
+          for (const row of conflicts) {
+            if (abortMode) undoRemoved.push(cloneRow(row));
+            removeOne(table, row, env);
+          }
+        } else {
           throw new SqliteError(
             `UNIQUE constraint failed: ${table.name}`,
             "constraint_unique",
             "SQLITE_CONSTRAINT_UNIQUE"
           );
         }
-        if (stmt.upsert.action === "nothing") continue;
-        const row = targetConflicts[0];
-        const scope = scopeFor(table, row, stmt.table, env);
-        const excluded = {
-          cells: table.columns.map((column) => ({
-            table: "excluded",
-            name: column.name,
-            value: values.get(normalizeColumnName(column.name)) ?? null
-          }))
-        };
-        const merged = { cells: [...scope.cells, ...excluded.cells], rowid: row.rowid, sourceTable: table.name };
-        const ctx = env.createEvalContext(merged);
-        if (stmt.upsert.action.where && isTruthySql(evalExpr(stmt.upsert.action.where, ctx)) !== true) continue;
-        const updates = evaluateSet(stmt.upsert.action.set, table, ctx);
-        const updated = updateOne(table, row, updates, env);
-        changes += 1 + updated.cascaded;
-        if (stmt.returning.length)
-          returningRows.push(projectReturning(stmt.returning, scopeFor(table, updated.row, stmt.table, env), env));
-        continue;
       }
-      const mode = stmt.mode;
-      if (mode === "insert_or_ignore") continue;
-      if (mode === "replace" || mode === "insert_or_replace") {
-        for (const row of conflicts) removeOne(table, row, env);
-      } else {
-        throw new SqliteError(
-          `UNIQUE constraint failed: ${table.name}`,
-          "constraint_unique",
-          "SQLITE_CONSTRAINT_UNIQUE"
-        );
+      let insertedRowid;
+      try {
+        const suppliedRowid = rowidIndexes.length ? asExplicitRowid(source[rowidIndexes[0]] ?? null) : void 0;
+        const rowid = table.insert({ values, rowid: suppliedRowid }, { prepared: true });
+        insertedRowid = rowid;
+        const row = table.rows.get(rowid);
+        validateRow(table, row, env);
+        if (table.indexes.length > 0) addIndexes(table, row, env);
+        if (env.state.foreignKeysEnabled) checkForeignKeys(table, row, env);
+        if (!table.withoutRowid) {
+          last = rowid;
+          env.state.lastInsertRowid = rowid;
+        }
+        fireInsertTriggers("AFTER", table, row.values, null, env);
+        changes++;
+        if (abortMode) undoInserted.push(rowid);
+        if (stmt.returning.length)
+          returningRows.push(projectReturning(stmt.returning, scopeFor(table, row, stmt.table, env), env));
+      } catch (error) {
+        if (insertedRowid !== void 0) {
+          const inserted = table.rows.get(insertedRowid);
+          if (inserted) removeOne(table, inserted, env);
+        }
+        if (stmt.mode === "insert_or_ignore" && error instanceof SqliteError && error.category.startsWith("constraint") && error.category !== "constraint_foreign")
+          continue;
+        throw error;
       }
     }
-    let insertedRowid;
-    try {
-      const suppliedRowid = rowidIndexes.length ? asExplicitRowid(source[rowidIndexes[0]] ?? null) : void 0;
-      const rowid = table.insert({ values, rowid: suppliedRowid }, { prepared: true });
-      insertedRowid = rowid;
-      const row = table.rows.get(rowid);
-      validateRow(table, row, env);
-      if (table.indexes.length > 0) addIndexes(table, row, env);
-      if (env.state.foreignKeysEnabled) checkForeignKeys(table, row, env);
-      if (!table.withoutRowid) {
-        last = rowid;
-        env.state.lastInsertRowid = rowid;
-      }
-      fireInsertTriggers("AFTER", table, row.values, null, env);
-      changes++;
-      if (stmt.returning.length)
-        returningRows.push(projectReturning(stmt.returning, scopeFor(table, row, stmt.table, env), env));
-    } catch (error) {
-      if (insertedRowid !== void 0) {
-        const inserted = table.rows.get(insertedRowid);
-        if (inserted) removeOne(table, inserted, env);
-      }
-      if (stmt.mode === "insert_or_ignore" && error instanceof SqliteError && error.category.startsWith("constraint"))
-        continue;
-      throw error;
-    }
+  } catch (error) {
+    undoStatement();
+    throw error;
   }
   const reportedChanges = finalizeDmlChanges(totalBefore, changes, env, last);
   if (stmt.returning.length === 0) return emptyResult(reportedChanges, last);
@@ -12725,8 +12792,6 @@ function evaluateInsertSource(stmt, env) {
   return stmt.values.map(
     (items) => items.map((expr) => {
       if (expr.type === "parameter") return env.getBoundParameter(expr.name);
-      if (expr.type === "literal") return expr.value;
-      if (expr.type === "null") return null;
       return evalExpr(expr, ctx);
     })
   );
@@ -12784,7 +12849,7 @@ function buildFastInsertPlan(stmt, env) {
       const name = expr.name;
       slots.push({ key, affinity: column.affinity, read: (exec) => exec.getBoundParameter(name) });
     } else if (expr.type === "literal") {
-      const value = expr.value;
+      const value = expr.forceReal && typeof expr.value === "number" ? asSqlReal(expr.value) : expr.value;
       slots.push({ key, affinity: column.affinity, read: () => value });
     } else if (expr.type === "null") {
       slots.push({ key, affinity: column.affinity, read: () => null });
@@ -12807,13 +12872,13 @@ function executeUpdateCore(stmt, env) {
   const totalBefore = env.state.totalChanges;
   const view = writableView(stmt.table, "UPDATE", env);
   if (view) return executeViewUpdate(stmt, view, env, totalBefore);
-  const table = env.state.getWritableTable(stmt.table);
+  const scanTable = env.state.getTable(stmt.table);
   const alias = stmt.alias ?? stmt.table;
   const candidates = [];
   if (stmt.from) {
     const fromRows = scanFrom(stmt.from, env);
-    for (const row of table.scan()) {
-      const targetScope = scopeFor(table, row, alias, env);
+    for (const row of scanTable.scan()) {
+      const targetScope = scopeFor(scanTable, row, alias, env);
       let matchedScope = null;
       for (const fromRow of fromRows) {
         const joined = {
@@ -12827,47 +12892,69 @@ function executeUpdateCore(stmt, env) {
     }
   } else {
     const indexed = stmt.where === null ? null : tryIndexedTableRows({ type: "table", schema: null, name: stmt.table, alias: stmt.alias }, stmt.where, env);
-    const scanRows = indexed ? indexed.rows : table.scan();
+    const scanRows = indexed ? indexed.rows : scanTable.scan();
     for (const row of scanRows) {
-      const scope = scopeFor(table, row, alias, env);
+      const scope = scopeFor(scanTable, row, alias, env);
       if (stmt.where && isTruthySql(evalExpr(stmt.where, env.createEvalContext(scope))) !== true) continue;
       candidates.push({ row, scope });
     }
   }
-  const returningRows = [];
-  let changes = 0;
-  for (const { row, scope } of candidates) {
-    const ctx = env.createEvalContext(scope);
-    const updates = evaluateSet(stmt.set, table, ctx);
-    const newValues = mergedValues(table, row, updates);
-    const updatedColumns = new Set(
-      [...updates.keys()].map((key) => {
-        const column = table.columns.find((item) => normalizeColumnName(item.name) === key);
-        return column?.name ?? key;
-      })
-    );
-    if (fireUpdateTriggers("BEFORE", table, row, newValues, updatedColumns, env) === "ignore") continue;
-    try {
-      const updated = updateOne(table, row, updates, env);
-      fireUpdateTriggers("AFTER", table, row, updated.row.values, updatedColumns, env);
-      changes += 1 + updated.cascaded;
-      if (stmt.returning.length)
-        returningRows.push(projectReturning(stmt.returning, scopeFor(table, updated.row, alias, env), env));
-    } catch (error) {
-      if (stmt.or === "ignore" && error instanceof SqliteError && error.category.startsWith("constraint")) continue;
-      throw error;
+  const applyUpdates = () => {
+    let table = env.state.getWritableTable(stmt.table);
+    const returningRows = [];
+    let changes = 0;
+    for (const { row, scope } of candidates) {
+      const ctx = env.createEvalContext(scope);
+      const updates = evaluateSet(stmt.set, table, ctx);
+      const newValues = mergedValues(table, row, updates);
+      const updatedColumns = new Set(
+        [...updates.keys()].map((key) => {
+          const column = table.columns.find((item) => normalizeColumnName(item.name) === key);
+          return column?.name ?? key;
+        })
+      );
+      if (fireUpdateTriggers("BEFORE", table, row, newValues, updatedColumns, env) === "ignore") continue;
+      try {
+        if (stmt.or === "replace") {
+          for (const conflict of conflictingRows(table, newValues, env)) {
+            if (conflict.rowid === row.rowid) continue;
+            removeOne(table, conflict, env);
+            table = env.state.getWritableTable(stmt.table);
+            changes++;
+          }
+        }
+        const updated = updateOne(table, row, updates, env);
+        table = env.state.getWritableTable(stmt.table);
+        fireUpdateTriggers("AFTER", table, row, updated.row.values, updatedColumns, env);
+        changes += 1 + updated.cascaded;
+        if (stmt.returning.length)
+          returningRows.push(projectReturning(stmt.returning, scopeFor(table, updated.row, alias, env), env));
+      } catch (error) {
+        if (stmt.or === "ignore" && error instanceof SqliteError && error.category.startsWith("constraint") && error.category !== "constraint_foreign")
+          continue;
+        throw error;
+      }
     }
+    const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
+    return valuesToResult(
+      returningNames(stmt.returning, table),
+      returningRows,
+      reportedChanges,
+      env.state.lastInsertRowid
+    );
+  };
+  if (updateAbortResolution(stmt.or) === "abort" && candidates.length > 1) {
+    return withStatementAtomicity(env, "abort", applyUpdates);
   }
-  const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
-  return valuesToResult(
-    returningNames(stmt.returning, table),
-    returningRows,
-    reportedChanges,
-    env.state.lastInsertRowid
-  );
+  return applyUpdates();
 }
 function executeDelete(stmt, env) {
-  return withDmlCtes(stmt.with, env, () => executeDeleteCore(stmt, env));
+  try {
+    return withDmlCtes(stmt.with, env, () => executeDeleteCore(stmt, env));
+  } catch (error) {
+    handleConflictRollback(stmt.or === "rollback", error, env);
+    throw error;
+  }
 }
 function executeDeleteCore(stmt, env) {
   if (env.state.isVirtualTable(stmt.table)) {
@@ -12876,30 +12963,49 @@ function executeDeleteCore(stmt, env) {
   const totalBefore = env.state.totalChanges;
   const view = writableView(stmt.table, "DELETE", env);
   if (view) return executeViewDelete(stmt, view, env, totalBefore);
-  const table = env.state.getWritableTable(stmt.table);
+  const scanTable = env.state.getTable(stmt.table);
   const selectedSource = stmt.where === null ? null : tryIndexedTableRows({ type: "table", schema: null, name: stmt.table, alias: stmt.alias }, stmt.where, env);
-  const selected = [...selectedSource ? selectedSource.rows : table.scan()].filter((row) => {
+  const selected = [...selectedSource ? selectedSource.rows : scanTable.scan()].filter((row) => {
     if (!stmt.where) return true;
-    return isTruthySql(evalExpr(stmt.where, env.createEvalContext(scopeFor(table, row, stmt.alias ?? stmt.table, env)))) === true;
+    return isTruthySql(
+      evalExpr(stmt.where, env.createEvalContext(scopeFor(scanTable, row, stmt.alias ?? stmt.table, env)))
+    ) === true;
   });
-  const returningRows = [];
-  let changes = 0;
-  for (const row of selected) {
-    if (fireDeleteTriggers("BEFORE", table, row, env) === "ignore") continue;
-    if (stmt.returning.length)
-      returningRows.push(projectReturning(stmt.returning, scopeFor(table, row, stmt.alias ?? stmt.table, env), env));
-    changes += applyReferentialDelete(table, row, env);
-    removeOne(table, row, env);
-    fireDeleteTriggers("AFTER", table, row, env);
-    changes++;
+  const applyDeletes = () => {
+    let table = env.state.getWritableTable(stmt.table);
+    const returningRows = [];
+    let changes = 0;
+    for (const row of selected) {
+      try {
+        if (fireDeleteTriggers("BEFORE", table, row, env) === "ignore") continue;
+        if (stmt.returning.length)
+          returningRows.push(
+            projectReturning(stmt.returning, scopeFor(table, row, stmt.alias ?? stmt.table, env), env)
+          );
+        changes += applyReferentialDelete(table, row, env);
+        table = env.state.getWritableTable(stmt.table);
+        removeOne(table, row, env);
+        table = env.state.getWritableTable(stmt.table);
+        fireDeleteTriggers("AFTER", table, row, env);
+        changes++;
+      } catch (error) {
+        if (stmt.or === "ignore" && error instanceof SqliteError && error.category.startsWith("constraint") && error.category !== "constraint_foreign")
+          continue;
+        throw error;
+      }
+    }
+    const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
+    return valuesToResult(
+      returningNames(stmt.returning, table),
+      returningRows,
+      reportedChanges,
+      env.state.lastInsertRowid
+    );
+  };
+  if (deleteAbortResolution(stmt.or) === "abort" && selected.length > 1) {
+    return withStatementAtomicity(env, "abort", applyDeletes);
   }
-  const reportedChanges = finalizeDmlChanges(totalBefore, changes, env);
-  return valuesToResult(
-    returningNames(stmt.returning, table),
-    returningRows,
-    reportedChanges,
-    env.state.lastInsertRowid
-  );
+  return applyDeletes();
 }
 function withDmlCtes(withClause, env, execute) {
   if (!withClause) return execute();
@@ -12917,6 +13023,40 @@ function handleConflictRollback(rollback, error, env) {
     env.transactions.rollback();
   }
 }
+var statementSavepointSeq = 0;
+var statementAtomicityDepth = 0;
+function withStatementAtomicity(env, resolution, run) {
+  if (resolution === "fail") return run();
+  if (statementAtomicityDepth > 0) return run();
+  const name = `__mem_stmt_${++statementSavepointSeq}`;
+  statementAtomicityDepth++;
+  env.transactions.savepoint(name);
+  try {
+    const result = run();
+    env.transactions.release(name);
+    return result;
+  } catch (error) {
+    if (env.transactions.inTransaction) {
+      try {
+        env.transactions.rollback(name);
+        env.transactions.release(name);
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    statementAtomicityDepth--;
+  }
+}
+function insertAbortResolution(mode) {
+  return mode === "insert_or_fail" ? "fail" : "abort";
+}
+function updateAbortResolution(or) {
+  return or === "fail" ? "fail" : "abort";
+}
+function deleteAbortResolution(or) {
+  return or === "fail" ? "fail" : "abort";
+}
 function writableView(name, event, env) {
   const { schema, bare } = splitQualifiedName(name);
   const db = env.state.databaseForSchema(schema, name);
@@ -12926,7 +13066,6 @@ function writableView(name, event, env) {
     (trigger) => trigger.tableName.toLowerCase() === bare.toLowerCase() && trigger.event === event && trigger.timing === "INSTEAD"
   );
   if (!hasInsteadOf) {
-    env.state.getWritableTable(name);
     throw new SqliteError(`cannot modify ${bare} because it is a view`, "other");
   }
   const names = view.columns ?? executeSelect2(view.select, env).columns;
@@ -13043,6 +13182,7 @@ function evaluateSet(items, table, ctx) {
   return updates;
 }
 function updateOne(table, row, updates, env) {
+  table = env.state.ensureWritableTable(table);
   const before = { rowid: row.rowid, values: new Map(row.values) };
   let after;
   let indexesAdded = false;
@@ -13114,6 +13254,7 @@ function removeIndexes(table, row, env) {
   }
 }
 function removeOne(table, row, env) {
+  table = env.state.ensureWritableTable(table);
   removeIndexes(table, row, env);
   table.delete(row.rowid);
 }
@@ -13266,17 +13407,28 @@ function checkForeignKeys(table, row, env) {
 function fkIsDeferred(constraint, env) {
   return env.transactions.inTransaction && constraint.initiallyDeferred;
 }
-function assertForeignKeySatisfied(row, constraint, env) {
+function assertForeignKeySatisfied(row, constraint, env, excludeParent = null) {
   const values = constraint.columns.map((name) => row.values.get(normalizeColumnName(name)) ?? null);
+  assertForeignKeyValues(values, constraint, env, excludeParent);
+}
+function assertForeignKeySatisfiedWithUpdates(row, constraint, updates, env, excludeParent) {
+  const values = constraint.columns.map((name) => {
+    const key = normalizeColumnName(name);
+    return updates.has(key) ? updates.get(key) ?? null : row.values.get(key) ?? null;
+  });
+  assertForeignKeyValues(values, constraint, env, excludeParent);
+}
+function assertForeignKeyValues(values, constraint, env, excludeParent) {
   if (values.some((value) => value === null)) return;
   const parent = env.state.getTable(constraint.refTable);
   const parentColumns = constraint.refColumns ?? parent.columns.filter((column) => column.primaryKey).map((column) => column.name);
-  if (![...parent.scan()].some(
-    (candidate) => values.every((value, index) => {
+  if (![...parent.scan()].some((candidate) => {
+    if (excludeParent && candidate.rowid === excludeParent.rowid) return false;
+    return values.every((value, index) => {
       const parentColumn = parentColumns[index];
       return parentColumn !== void 0 && compareSql(value, candidate.values.get(normalizeColumnName(parentColumn)) ?? null) === 0;
-    })
-  )) {
+    });
+  })) {
     throw new SqliteError("FOREIGN KEY constraint failed", "constraint_foreign", "SQLITE_CONSTRAINT_FOREIGNKEY");
   }
 }
@@ -13293,10 +13445,13 @@ function applyReferentialDelete(parent, row, env) {
   if (!env.state.foreignKeysEnabled) return 0;
   let changes = 0;
   const parentPk = parent.columns.filter((column) => column.primaryKey).map((column) => column.name);
-  for (const child of env.state.tables.values()) {
+  for (const childKey of [...env.state.tables.keys()]) {
+    let child = env.state.tables.get(childKey);
+    if (!child) continue;
     for (const constraint of child.constraints) {
       if (constraint.type !== "foreign_key" || constraint.refTable.toLowerCase() !== parent.name.toLowerCase())
         continue;
+      child = env.state.ensureWritableTable(child);
       const referenced = constraint.refColumns ?? parentPk;
       const matches = [...child.scan()].filter(
         (candidate) => !(child === parent && candidate.rowid === row.rowid) && foreignKeyMatches(constraint.columns, candidate, referenced, row)
@@ -13317,7 +13472,9 @@ function applyReferentialDelete(parent, row, env) {
           );
           changes += 1 + updated.cascaded;
         } else if (constraint.onDelete === "SET DEFAULT") {
-          const updated = updateOne(child, candidate, defaultUpdates(child, constraint.columns, env), env);
+          const updates = defaultUpdates(child, constraint.columns, env);
+          assertForeignKeySatisfiedWithUpdates(candidate, constraint, updates, env, row);
+          const updated = updateOne(child, candidate, updates, env);
           changes += 1 + updated.cascaded;
         } else if (constraint.onDelete === "RESTRICT" || !fkIsDeferred(constraint, env)) {
           throw new SqliteError("FOREIGN KEY constraint failed", "constraint_foreign", "SQLITE_CONSTRAINT_FOREIGNKEY");
@@ -13331,10 +13488,13 @@ function applyReferentialUpdate(parent, before, after, env) {
   if (!env.state.foreignKeysEnabled) return 0;
   let changes = 0;
   const parentPk = parent.columns.filter((column) => column.primaryKey).map((column) => column.name);
-  for (const child of env.state.tables.values()) {
+  for (const childKey of [...env.state.tables.keys()]) {
+    let child = env.state.tables.get(childKey);
+    if (!child) continue;
     for (const constraint of child.constraints) {
       if (constraint.type !== "foreign_key" || constraint.refTable.toLowerCase() !== parent.name.toLowerCase())
         continue;
+      child = env.state.ensureWritableTable(child);
       const referenced = constraint.refColumns ?? parentPk;
       const oldValues = referenced.map((name) => before.values.get(normalizeColumnName(name)) ?? null);
       const newValues = referenced.map((name) => after.values.get(normalizeColumnName(name)) ?? null);