@crvouga/sqlite-mem 1.4.0 → 1.6.0

package/compat/scenarios.ts

@@ -818,6 +818,16 @@ const TAIL: CatalogSection[] = [
       ["win-01", "window frame fuzz", F],
       ["up-01", "UPSERT fuzz", F],
       ["date-01", "date modifier fuzz", F],
+      ["trig-01", "BEFORE/AFTER trigger + RAISE fuzz", F],
+      ["genc-01", "STORED/VIRTUAL generated column fuzz", F],
+      ["notin-01", "NOT IN / IN NULL + scalar cardinality fuzz", F],
+      ["cnt-01", "changes/total_changes/last_insert_rowid fuzz", F],
+      ["fkedge-01", "FK SET NULL/DEFAULT/MATCH edge fuzz", F],
+      ["tlp-01", "ternary logic partitioning metamorphic", F],
+      ["norec-01", "NoREC metamorphic rewrite", F],
+      ["robust-01", "SqliteError-only / timeout / SQLM bit-flip", F],
+      ["slt-01", "sqllogictest vendor corpus differential", F],
+      ["dst-01", "mixed dump-after-each DST engine", F],
       ["prop-01", "snapshot restore idempotence", P],
       ["prop-02", "insert then delete snapshot bytes", P],
       ["prop-03", "index-added vs index-free equivalence", P],

package/compat/sqllogictest-skip.json

@@ -0,0 +1,5 @@
+{
+  "files": [],
+  "prefixes": [],
+  "notes": "Add vendor/sqllogictest/test/<file> or <file>#<line> entries when a record is intentionally unsupported."
+}

package/dist/index.js

@@ -1677,10 +1677,19 @@ var Parser = class {
   parseFkActions() {
     let onDelete = null;
     let onUpdate = null;
+    while (this.match("MATCH")) {
+      this.parseIdent();
+    }
     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");
+      while (this.match("MATCH")) {
+        this.parseIdent();
+      }
+    }
+    while (this.match("MATCH")) {
+      this.parseIdent();
     }
     return { onDelete, onUpdate };
   }
@@ -4341,6 +4350,21 @@ function applyModifier(date, modifier, flags) {
   }
   return result;
 }
+function applyModifiers(date, modifiers) {
+  const flags = { subsec: false };
+  let current = date;
+  for (const modifier of modifiers) {
+    if (typeof modifier !== "string") return null;
+    const next = applyModifier(current, modifier, flags);
+    if (!next) return null;
+    current = next;
+  }
+  return { date: current, subsec: flags.subsec };
+}
+function fromUnixSeconds(seconds) {
+  const date = new Date(seconds * 1e3);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
 function resolveDate(args, context) {
   let source = args[0];
   let modifiers = args.slice(1);
@@ -4348,23 +4372,26 @@ function resolveDate(args, context) {
   if (modifiers[0] === "unixepoch") {
     const seconds = coerceToNumber(source);
     if (seconds === null) return null;
-    source = seconds / 86400 + JULIAN_UNIX_EPOCH;
-    modifiers = modifiers.slice(1);
-  } else if (typeof modifiers[0] === "string" && modifiers[0].trim().toLowerCase() === "auto") {
+    const date2 = fromUnixSeconds(seconds);
+    if (!date2) return null;
+    return applyModifiers(date2, modifiers.slice(1));
+  }
+  if (typeof modifiers[0] === "string" && modifiers[0].trim().toLowerCase() === "auto") {
     const number = coerceToNumber(source);
-    if (number === null) return null;
-    source = number >= 0 && number < 53734845e-1 ? number : number / 86400 + JULIAN_UNIX_EPOCH;
-    modifiers = modifiers.slice(1);
+    if (number === null) {
+      modifiers = modifiers.slice(1);
+    } else if (number >= 0 && number < 53734845e-1) {
+      source = number;
+      modifiers = modifiers.slice(1);
+    } else {
+      const date2 = fromUnixSeconds(number);
+      if (!date2) return null;
+      return applyModifiers(date2, modifiers.slice(1));
+    }
   }
-  let date = parseDate(source, context);
+  const date = parseDate(source, context);
   if (!date) return null;
-  const flags = { subsec: false };
-  for (const modifier of modifiers) {
-    if (typeof modifier !== "string") return null;
-    date = applyModifier(date, modifier, flags);
-    if (!date) return null;
-  }
-  return { date, subsec: flags.subsec };
+  return applyModifiers(date, modifiers);
 }
 function pad(value, length = 2) {
   return String(value).padStart(length, "0");
@@ -8873,7 +8900,11 @@ var Reader = class {
     return utf8Decode(this.raw(this.u32()));
   }
   json() {
-    return JSON.parse(this.text(), jsonReviver);
+    try {
+      return JSON.parse(this.text(), jsonReviver);
+    } catch {
+      throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+    }
   }
   value() {
     const tag = this.u8();
@@ -8951,6 +8982,14 @@ function encodeDatabaseState(state, runtime) {
   return writer.finish();
 }
 function decodeDatabaseState(snapshot) {
+  try {
+    return decodeDatabaseStateInner(snapshot);
+  } catch (error) {
+    if (error instanceof SqliteError) throw error;
+    throw new SqliteError("invalid or truncated sqlite-mem snapshot", "other");
+  }
+}
+function decodeDatabaseStateInner(snapshot) {
   const reader = new Reader(snapshot);
   const magic = reader.raw(4);
   if (!magic.every((byte, index) => byte === MAGIC[index]))
@@ -9103,12 +9142,20 @@ var TransactionManager = class {
   }
   rollback(savepoint) {
     this.requireTransaction("cannot rollback - no transaction is active");
+    const preserved = {
+      totalChanges: this.state.totalChanges,
+      changes: this.state.changes,
+      lastInsertRowid: this.state.lastInsertRowid
+    };
     if (savepoint !== void 0) {
       const index = this.findSavepoint(savepoint);
       const snapshot2 = this.savepoints[index];
       if (!snapshot2) throw new SqliteError(`no such savepoint: ${savepoint}`, "transaction", "SQLITE_ERROR");
       this.state.replaceWith(snapshot2.state, { adopt: true });
       this.prng.setState(snapshot2.prngState);
+      this.state.totalChanges = preserved.totalChanges;
+      this.state.changes = preserved.changes;
+      this.state.lastInsertRowid = preserved.lastInsertRowid;
       this.savepoints.splice(index + 1);
       return;
     }
@@ -9119,6 +9166,9 @@ var TransactionManager = class {
     }
     this.state.replaceWith(snapshot, { adopt: true });
     this.prng.setState(prngState);
+    this.state.totalChanges = preserved.totalChanges;
+    this.state.changes = preserved.changes;
+    this.state.lastInsertRowid = preserved.lastInsertRowid;
     this.transactionSnapshot = null;
     this.transactionPrngState = null;
     this.savepoints = [];
@@ -9858,11 +9908,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;
@@ -11321,10 +11373,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;
@@ -13225,17 +13287,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");
   }
 }
@@ -13276,7 +13349,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");