@minnowdb/core 0.7.1 → 0.7.5

package/dist/storage/toolkit/record-core.js

@@ -1655,6 +1655,8 @@ class RecordCore {
       const active = activePostingStorageColumnIds(currentTable);
       if (!active.has(column.columnId))
         continue;
+      if (column.postings.length === 0)
+        continue;
       const key = `${changes.tableId}/${column.columnId}`;
       const deltas = this.#ftsDeltas.get(key) ?? /* @__PURE__ */ new Map();
       if (!deltas.has(version) && deltas.size >= MAX_FTS_DELTA_CHUNKS) {
@@ -4330,8 +4332,11 @@ class RecordCore {
       this.#nextAutoIncrement.set(key, next);
     for (const [key, base] of cloned.ftsBases)
       this.#ftsBases.set(key, base);
-    for (const [key, deltas] of cloned.ftsDeltas)
-      this.#ftsDeltas.set(key, new Map(deltas));
+    for (const [key, deltas] of cloned.ftsDeltas) {
+      const retained = deltas.filter(([, delta]) => delta.postings.length > 0);
+      if (retained.length > 0)
+        this.#ftsDeltas.set(key, new Map(retained));
+    }
     for (const [tableId, tokens] of cloned.uniqueKeys) {
       this.#uniqueKeys.set(tableId, new OrderedStringSet(tokens));
     }
@@ -5425,7 +5430,14 @@ function validateRecordCoreState(state, physical) {
         throw new TypeError(`Full-text delta ${key} repeats a version`);
       versions.add(version);
       whole(delta.totalTokens, `Full-text delta ${key} token count`);
-      if (validateFtsPostingChunks([delta.postings], `Full-text delta ${key}`) !== delta.totalTokens) {
+      if (!Array.isArray(delta.postings)) {
+        throw new TypeError(`Full-text delta ${key} postings must be an array`);
+      }
+      if (delta.postings.length === 0) {
+        if (delta.totalTokens !== 0) {
+          throw new TypeError(`Empty full-text delta ${key} must have a zero token total`);
+        }
+      } else if (validateFtsPostingChunks([delta.postings], `Full-text delta ${key}`) !== delta.totalTokens) {
         throw new TypeError(`Full-text delta ${key} token total does not match its postings`);
       }
     }

package/dist/testing/sqllogictest.js

@@ -166,7 +166,9 @@ function parseExpected(lines, file, line) {
   return { kind: "hash", valueCount, hash: (match[2] ?? "").toLowerCase() };
 }
 function tokenizeDirective(line) {
-  return line.trim().split(/\s+/u);
+  const hash = line.indexOf("#");
+  const directive = hash === -1 ? line : line.slice(0, hash);
+  return directive.trim().split(/\s+/u);
 }
 function sqlLines(lines) {
   return lines.map((line) => line.text).join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.1",
+  "version": "0.7.5",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",

package/postgres-feature-profile.json

@@ -31,7 +31,7 @@
     {
       "id": "expression.arithmetic",
       "classification": "different",
-      "reason": "Minnow has one JavaScript number type: integer-looking division stays fractional, and division by zero returns NULL instead of raising PostgreSQL's error."
+      "reason": "Division by zero returns NULL instead of raising PostgreSQL's error. Integer division itself follows PostgreSQL: two integer operands truncate toward zero."
     },
     {
       "id": "expression.round",
@@ -43,6 +43,11 @@
       "classification": "extension",
       "reason": "PostgreSQL uses $n parameters. Minnow also accepts ? as adapter-friendly shorthand."
     },
+    {
+      "id": "mutation.truncate",
+      "classification": "different",
+      "reason": "TRUNCATE reports the number of rows it removed, where PostgreSQL's command tag carries no count. The resulting table state is identical."
+    },
     {
       "id": "mutation.upsert-replace",
       "classification": "extension",
@@ -91,7 +96,7 @@
     {
       "id": "expression.modulo",
       "classification": "different",
-      "reason": "Minnow permits % on its number type; PostgreSQL has no % operator for double precision."
+      "reason": "Minnow permits % on double precision values; PostgreSQL has no % operator for double precision."
     },
     {
       "id": "expression.date-trunc",
@@ -101,7 +106,7 @@
     {
       "id": "function.numeric-core",
       "classification": "different",
-      "reason": "Minnow's one number type accepts combinations that PostgreSQL's distinct integer, numeric, and double-precision overloads do not."
+      "reason": "Minnow's numeric functions accept integer, exact, and double-precision arguments interchangeably, where PostgreSQL's distinct integer, numeric, and double-precision overloads do not."
     },
     {
       "id": "function.string-extended",
@@ -247,7 +252,7 @@
     {
       "id": "transaction.isolation-level",
       "classification": "inapplicable",
-      "reason": "Minnow exposes one snapshot transaction model, so there is no session isolation level to configure."
+      "reason": "Every transaction reads one snapshot and commits atomically, which satisfies READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ, so those levels are accepted and ignored. SERIALIZABLE promises more than one snapshot can, and is refused rather than silently downgraded."
     },
     {
       "id": "privileges.grant",