@crvouga/sqlite-mem 1.5.0 → 1.6.0

package/compat/scenarios.ts

@@ -818,6 +818,11 @@ 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],

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 };
   }
@@ -9899,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;
@@ -11362,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;
@@ -13266,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");
   }
 }
@@ -13317,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");