@crvouga/sqlite-mem 1.7.0 → 1.8.1

package/COMPATIBILITY-AUDIT.md

@@ -13,7 +13,7 @@ Reference SQLite compile options:
   Full list: `bun run inventory`
 
 sqlite-mem version:
-  0.1.0
+  0.0.0-development (package.json; publish via semantic-release)
 
 Scope:
   Scope 3 — every oracle-exposed SQL builtin/module is in-scope except
@@ -35,7 +35,8 @@ SQL grammar / operators / expressions:
   VERIFIED — contracts + row-value comparisons + ->/->> precedence
 
 Types / affinity / NULL:
-  VERIFIED
+  VERIFIED — affinity matrix, typeof/REAL (incl. unary ± float literals),
+  truthiness/3VL, JS-leak bind probes (differential + documented divergences)
 
 Functions (oracle surface):
   VERIFIED — inventory missingOracleFunctions = 0 (163 names covered)
@@ -44,13 +45,15 @@ JSON / JSONB:
   VERIFIED
 
 Aggregates / windows:
-  VERIFIED — includes string_agg, ntile, cume_dist, percent_rank, EXCLUDE
+  VERIFIED — includes string_agg, ntile, cume_dist, percent_rank, EXCLUDE;
+  unaliased aggregate column names (`sum(v)`, `count(*)`) match oracle
 
 CTEs / transactions / savepoints / constraints / FK / triggers:
-  VERIFIED (deferred FK + composite FK)
+  VERIFIED (deferred FK + composite FK + MATCH SIMPLE/FULL + statement ABORT)
 
 Indexes / views / generated / STRICT / WITHOUT ROWID:
-  VERIFIED — partial/expression indexes, STRICT tables, leftmost prefix
+  VERIFIED — partial/expression indexes, STRICT tables, leftmost prefix;
+  WITHOUT ROWID UPSERT; generated STORED/VIRTUAL WHERE/ORDER BY
 
 PRAGMAs:
   PARTIALLY VERIFIED — schema/FK; storage pragmas N/A or :memory: no-op
@@ -66,20 +69,30 @@ ANALYZE / REINDEX / VACUUM:
   VERIFIED (:memory: observable parity)
 
 Prepared statements / errors / snapshot:
-  VERIFIED — schema invalidation re-prepares; SQLM logical round-trip VERIFIED
+  VERIFIED — schema invalidation re-prepares; SQLM logical round-trip VERIFIED;
+  post-restore A/B lockstep + dumpLogicalState vs oracle
 
-  Differential tests:
-  Total: 872 under `bun test` (contract + fuzz + harness) after hardening pass
-  Passed: 872
+  Differential tests (2026-08-21 audit refresh):
+  Total: 1912 under `bun test` / `bun run test:sqlite-compat`
+    (contract + fuzz + harness; Bun 1.4.0, SQLite 3.51.0)
+  Passed: 1912
   Failed: 0
+  expect() calls: 7314
 
 Stateful / fuzz:
   Seeds: 0x5a17e0e1 (+ SQLITE_MEM_FUZZ_SEED override)
   Combination fuzz: tests/fuzz/combinations-scope3.test.ts
   FTS fuzz: tests/fuzz/fts.test.ts
-  Collate / window / CTE+DML / JSON subtype fuzz extended
+  Long deterministic scripts: tests/contract/transactions/stateful.test.ts
+  Collate / window / CTE+DML / JSON subtype / affinity / conflicts fuzz
   Mismatches: 0
 
+Harness integrity (Phase 1):
+  RealSqliteAdapter DML via prepare().run() with live changes/lastInsertRowid
+  sequenceParity compares DML counters; DDL/txn/PRAGMA allowlist neutralized
+  errorParity via deepCompareResults; dumpLogicalState + compareFinalState
+  Comparator meta-tests: tests/harness/normalize.test.ts
+
 Hardening pass (2026-08-19) — incompatibilities found & fixed:
   1. Comparison affinity (INTEGER/TEXT/NUMERIC column vs literal) missing
   2. WITH on UPDATE/DELETE/INSERT VALUES dispatched as SELECT only
@@ -92,24 +105,36 @@ Hardening pass (2026-08-19) — incompatibilities found & fixed:
   9. Window GROUPS/RANGE frames, window FILTER, recursive CTE queue edges
   10. Collation-aware GROUP BY; FTS3 matchinfo format variants; external-content delete
 
+Audit refresh (2026-08-21) — additional findings & fixes:
+  11. sequenceParity previously ignored all DML write counters (hid divergences)
+  12. Unary +/- on float literals dropped REAL storage class (`typeof(-0.0)`)
+  13. UPDATE OR REPLACE counted conflict deletions in changes() (oracle = 1)
+  14. Empty-result column names + unaliased aggregate headers asserted vs oracle
+  15. JS bind edges: empty TEXT/BLOB, BigInt@MAX_SAFE, intentional Number/BigInt
+      bind-class divergences pinned via divergence()
+  16. Snapshot post-restore A/B + state dump vs live oracle
+
 Remaining known differences / intentional:
   Custom SQLM snapshots; deterministic random()/'now' by default
   (`random: "os"` / `now: "system"` match SQLite entropy and wall clock);
   EXPLAIN stubs (shape contracts only); INDEXED BY no-op (documented);
   ATTACH file path records filename but opens empty in-memory schema;
-  some PRAGMA storage no-ops; FTS shadow-table changes() diverge;
+  some PRAGMA storage no-ops; FTS shadow-table changes()/total_changes diverge
+  (sequenceParity neutralizeCounters on FTS maintenance paths);
   MATERIALIZED/NOT MATERIALIZED stored but both materialize today;
   compile_options / function_list content is sqlite-mem's;
   generate_series is sqlite-mem extension (not in bun:sqlite default);
+  Number.MAX_SAFE_INTEGER JS bind typeof (mem integer vs bun real);
   BigInt beyond Number.MAX_SAFE_INTEGER without bun safeIntegers;
   NOT APPLICABLE C API / on-disk / VFS surfaces; uri.html remapped N/A.
 
 Final assessment:
-  Verified against SQLite 3.51.0 (bun:sqlite). Oracle function/module
-  inventory is closed (0 missing). Requirements matrix ingested with
-  zero unknown statuses. Gate: `bun run test:sqlite-compat`.
-  Hardening pass closed construct-level P0 gaps from docs/PARITY-GAPS.md;
-  FTS/EXPLAIN remain PARTIALLY VERIFIED honestly.
+  Verified against SQLite 3.51.0 (bun:sqlite on Bun 1.4.0). Oracle
+  function/module inventory is closed (0 missing). Requirements matrix
+  ingested with zero unknown statuses. Gate: `bun run test:sqlite-compat`.
+  Harness now compares live DML counters; green means stronger evidence than
+  pre-2026-08-21. FTS/EXPLAIN remain PARTIALLY VERIFIED honestly — not
+  “fully compatible because green.”
 ```
 
 ---

package/dist/index.js

@@ -5788,8 +5788,14 @@ function evalExpr(expr, ctx) {
         return truth === null ? null : booleanValue(!truth);
       }
       if (value === null) return null;
-      if (expr.op === "+") return asNumber(numberValue(value));
-      if (expr.op === "-") return asNumber(-numberValue(value));
+      if (expr.op === "+") {
+        const n = asNumber(numberValue(value));
+        return storageClassOf(value) === "real" ? asSqlReal(n) : n;
+      }
+      if (expr.op === "-") {
+        const n = asNumber(-numberValue(value));
+        return storageClassOf(value) === "real" ? asSqlReal(n) : n;
+      }
       return ~integerValue(value);
     }
     case "is_bool": {
@@ -12920,7 +12926,6 @@ function executeUpdateCore(stmt, 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);