@crvouga/sqlite-mem 1.13.0 → 1.14.0

package/dist/indexes/index.d.ts

@@ -5,6 +5,7 @@ export declare class IndexStore {
     private entries;
     private keyValues;
     private sortedKeys;
+    private mapsShared;
     frozen: boolean;
     constructor(name?: string, entries?: ReadonlyMap<string, readonly Rowid[]>, keyValues?: ReadonlyMap<string, readonly SqlValue[]>);
     checkUnique(values: readonly SqlValue[], rowid?: Rowid): void;
@@ -39,6 +40,7 @@ export declare class IndexStore {
     get size(): number;
     private orderedKeys;
     private assertMutable;
+    private forkMaps;
 }
 /** Hash-join / covering-hash key: NULL components never match. */
 export declare function serializeIndexKey(values: readonly SqlValue[]): string | null;

package/dist/runtime/assert.d.ts

@@ -0,0 +1,11 @@
+import type { Row } from "../storage/row.js";
+import type { Table } from "../storage/table.js";
+/** Always-on invariant check (Tiger Style — not stripped in production). */
+export declare function assert(condition: boolean, message: string): asserts condition;
+/** Exhaustive switch helper — call when a union case should be impossible. */
+export declare function assertUnreachable(value: never, message?: string): never;
+/** Row payload must align with table column count after insert/update. */
+export declare function assertRowShape(table: Table, row: Row): void;
+/** Maximum blob/string length enforced before allocation (matches bun:sqlite TOOBIG). */
+export declare const SQLITE_MAX_LENGTH = 2147483647;
+export declare function assertBlobLength(length: number, _feature: string): void;

package/dist/runtime/catch.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorCategory } from "../errors/index.js";
+/** True when an error is an expected fast-path miss (fall through to full executor). */
+export declare function isExpectedFastPathMiss(error: unknown, categories?: readonly ErrorCategory[]): boolean;

package/dist/unstable.js

@@ -2219,6 +2219,23 @@ var mathFunctions = {
   }
 };
 
+// src/runtime/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new SqliteError(`internal assertion failed: ${message}`, "other");
+  }
+}
+function assertRowShape(table, row) {
+  assert(row.values.length === table.columns.length, `row.values.length !== table.columns.length for ${table.name}`);
+}
+var SQLITE_MAX_LENGTH = 2147483647;
+function assertBlobLength(length, _feature) {
+  if (!Number.isFinite(length) || length < 0) return;
+  if (length >= SQLITE_MAX_LENGTH) {
+    throw new SqliteError(`string or blob too big`, "other", "SQLITE_TOOBIG");
+  }
+}
+
 // src/expressions/like.ts
 function escapeRegexChar(char) {
   return /[\\^$.*+?()[\]{}|]/.test(char) ? `\\${char}` : char;
@@ -2478,6 +2495,7 @@ var scalarFunctions = {
     requireArgs3("randomblob", args, 1);
     if (args[0] === null) return null;
     const length = Math.max(0, Math.trunc(numeric(args[0])));
+    assertBlobLength(length, "randomblob");
     const out = new Uint8Array(length);
     let offset = 0;
     while (offset < length) {
@@ -2492,6 +2510,7 @@ var scalarFunctions = {
     requireArgs3("zeroblob", args, 1);
     if (args[0] === null) return null;
     const length = Math.max(0, Math.trunc(numeric(args[0])));
+    assertBlobLength(length, "zeroblob");
     return new Uint8Array(length);
   },
   hex(args) {
@@ -2974,10 +2993,19 @@ function evalBinary(op, leftExpr, rightExpr, ctx) {
   if (left === null || right === null) return null;
   switch (op) {
     case "+":
+      if (storageClassOf(left) === "integer" && storageClassOf(right) === "integer") {
+        return integerArithmetic("+", left, right);
+      }
       return asNumber(numberValue(left) + numberValue(right));
     case "-":
+      if (storageClassOf(left) === "integer" && storageClassOf(right) === "integer") {
+        return integerArithmetic("-", left, right);
+      }
       return asNumber(numberValue(left) - numberValue(right));
     case "*":
+      if (storageClassOf(left) === "integer" && storageClassOf(right) === "integer") {
+        return integerArithmetic("*", left, right);
+      }
       return asNumber(numberValue(left) * numberValue(right));
     case "/": {
       const divisor = numberValue(right);
@@ -3014,6 +3042,17 @@ function evalBinary(op, leftExpr, rightExpr, ctx) {
 function safeIntegerResult(value) {
   return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : value;
 }
+var I64_MIN = -(2n ** 63n);
+var I64_MAX = 2n ** 63n - 1n;
+function integerArithmetic(op, left, right) {
+  const a = integerValue(left);
+  const b = integerValue(right);
+  const result = op === "+" ? a + b : op === "-" ? a - b : a * b;
+  if (result < I64_MIN || result > I64_MAX) {
+    return asSqlReal(Number(result));
+  }
+  return safeIntegerResult(result);
+}
 function compareRowValues(op, leftExprs, rightExprs, ctx) {
   if (leftExprs.length !== rightExprs.length) {
     throw new SqliteError("row value misused", "misuse");
@@ -5815,6 +5854,7 @@ var IndexStore = class _IndexStore {
   entries;
   keyValues;
   sortedKeys;
+  mapsShared = false;
   frozen = false;
   constructor(name = "index", entries, keyValues) {
     this.name = name;
@@ -5868,10 +5908,22 @@ var IndexStore = class _IndexStore {
     if (values.some((value) => value === null)) return [];
     const prefix = serializeIndexEntry(values);
     const exact = this.entries.get(prefix);
-    const needle = `${prefix}|`;
     const rowids = exact ? [...exact] : [];
-    for (const [key, ids] of this.entries) {
-      if (key.startsWith(needle)) rowids.push(...ids);
+    const keys = this.orderedKeys();
+    let start = 0;
+    let end = keys.length;
+    while (start < end) {
+      const mid = start + end >>> 1;
+      const kv = this.keyValues.get(keys[mid]);
+      if (!kv || prefixKeyLess(kv, values)) start = mid + 1;
+      else end = mid;
+    }
+    for (let i = start; i < keys.length; i++) {
+      const kv = this.keyValues.get(keys[i]);
+      if (!kv || !prefixKeyMatches(kv, values)) break;
+      const key = keys[i];
+      if (key === prefix) continue;
+      rowids.push(...this.entries.get(key) ?? []);
     }
     return rowids;
   }
@@ -5880,9 +5932,12 @@ var IndexStore = class _IndexStore {
    * `op` applies to the first key component.
    */
   rangeLookup(op, bound, bound2) {
-    const rowids = [];
     const keys = this.orderedKeys();
-    for (const key of keys) {
+    const rowids = [];
+    const start = lowerBoundKeyValues(keys, this.keyValues, bound, op === ">" ? "gt" : op === ">=" ? "ge" : "any");
+    const end = op === "<" || op === "<=" ? upperBoundKeyValues(keys, this.keyValues, bound, op === "<" ? "lt" : "le") : op === "between" && bound2 !== void 0 ? upperBoundKeyValues(keys, this.keyValues, bound2, "le") : keys.length;
+    for (let i = start; i < end; i++) {
+      const key = keys[i];
       const values = this.keyValues.get(key);
       if (!values || values[0] === void 0 || values[0] === null) continue;
       const cmp = compareSerializedOrder(values[0], bound);
@@ -5939,7 +5994,12 @@ var IndexStore = class _IndexStore {
     this.sortedKeys = null;
   }
   clone() {
-    return new _IndexStore(this.name, this.entries, this.keyValues);
+    const copy = new _IndexStore(this.name);
+    copy.entries = this.entries;
+    copy.keyValues = this.keyValues;
+    copy.sortedKeys = this.sortedKeys;
+    copy.mapsShared = true;
+    return copy;
   }
   freeze() {
     this.frozen = true;
@@ -5995,6 +6055,18 @@ var IndexStore = class _IndexStore {
   }
   assertMutable() {
     if (this.frozen) throw new SqliteError("internal: cannot mutate a frozen index", "other");
+    this.forkMaps();
+  }
+  forkMaps() {
+    if (!this.mapsShared) return;
+    const entries = /* @__PURE__ */ new Map();
+    for (const [key, rowids] of this.entries) entries.set(key, [...rowids]);
+    const keyValues = /* @__PURE__ */ new Map();
+    for (const [key, values] of this.keyValues) keyValues.set(key, [...values]);
+    this.entries = entries;
+    this.keyValues = keyValues;
+    this.mapsShared = false;
+    this.sortedKeys = null;
   }
 };
 function serializeIndexKey(values) {
@@ -6033,6 +6105,53 @@ function serializeValue(value) {
 function compareSerializedOrder(left, right) {
   return compareSql(left, right) ?? 0;
 }
+function prefixKeyLess(keyValues, prefix) {
+  for (let i = 0; i < prefix.length; i++) {
+    const cmp = compareSerializedOrder(keyValues[i] ?? null, prefix[i]);
+    if (cmp !== 0) return cmp < 0;
+  }
+  return false;
+}
+function prefixKeyMatches(keyValues, prefix) {
+  for (let i = 0; i < prefix.length; i++) {
+    if (compareSerializedOrder(keyValues[i] ?? null, prefix[i]) !== 0) return false;
+  }
+  return true;
+}
+function lowerBoundKeyValues(keys, keyValues, bound, mode) {
+  let lo = 0;
+  let hi = keys.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const value = keyValues.get(keys[mid])?.[0];
+    if (value === void 0 || value === null) {
+      lo = mid + 1;
+      continue;
+    }
+    const cmp = compareSerializedOrder(value, bound);
+    const before = mode === "gt" ? cmp <= 0 : mode === "ge" ? cmp < 0 : false;
+    if (before) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function upperBoundKeyValues(keys, keyValues, bound, mode) {
+  let lo = 0;
+  let hi = keys.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const value = keyValues.get(keys[mid])?.[0];
+    if (value === void 0 || value === null) {
+      lo = mid + 1;
+      continue;
+    }
+    const cmp = compareSerializedOrder(value, bound);
+    const after = mode === "lt" ? cmp >= 0 : cmp > 0;
+    if (after) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
 function sameRowid(left, right) {
   return typeof left === "bigint" || typeof right === "bigint" ? BigInt(left) === BigInt(right) : left === right;
 }
@@ -6553,6 +6672,9 @@ function parseFts5Query(input) {
     }
     if (p.kind === "TERM") {
       next();
+      if (p.prefix && (p.value === "" || p.value.includes("*"))) {
+        throw new SqliteError(`unknown special query: ${p.value}`, "other");
+      }
       return { type: "term", value: p.value, prefix: p.prefix, column: null, columns: null };
     }
     throw new SqliteError(`fts5: syntax error near "${displayTok(p)}"`, "syntax");
@@ -6719,17 +6841,7 @@ function displayTok(t) {
   }
 }
 function parseFts3Query(input) {
-  try {
-    return parseFts5Query(input);
-  } catch {
-    const terms = input.split(/\s+/).filter(Boolean).filter((t) => !/^(AND|OR|NOT|NEAR)$/i.test(t));
-    if (terms.length === 0) return { type: "true" };
-    const nodes = terms.map((t) => {
-      const prefix = t.endsWith("*");
-      return { type: "term", value: prefix ? t.slice(0, -1) : t, prefix, column: null, columns: null };
-    });
-    return nodes.length === 1 ? nodes[0] : { type: "and", children: nodes };
-  }
+  return parseFts5Query(input);
 }
 
 // src/vtable/fts/porter.ts
@@ -7792,11 +7904,6 @@ function rowValues(values) {
   }
   return result;
 }
-function cloneRow(row) {
-  const values = new Array(row.values.length);
-  for (let i = 0; i < row.values.length; i++) values[i] = cloneSqlValue(row.values[i]);
-  return { rowid: row.rowid, values };
-}
 function isValueArray(values) {
   return Array.isArray(values);
 }
@@ -7935,6 +8042,7 @@ var Table = class _Table {
     this.scanCache = null;
   }
   commitRow(row) {
+    assertRowShape(this, row);
     this.indexEquality(row);
     this.invalidateScan();
   }
@@ -8157,16 +8265,11 @@ var Table = class _Table {
     copy.nextRowid = this.nextRowid;
     copy.maximumRowid = this.maximumRowid;
     if (this.slab) {
-      let max = null;
-      for (const row of this.slab.scan()) {
-        copy.rows.set(row.rowid, cloneRow(row));
-        if (max === null || compareRowids(row.rowid, max) > 0) max = row.rowid;
-      }
-      copy.maximumRowid = max ?? void 0;
+      for (const row of this.slab.scan()) copy.rows.set(row.rowid, row);
     } else {
-      for (const [rowid, row] of this.rows) copy.rows.set(rowid, cloneRow(row));
+      for (const [rowid, row] of this.rows) copy.rows.set(rowid, row);
     }
-    for (const [clusterKey, row] of this.clusteredRows) copy.clusteredRows.set(clusterKey, cloneRow(row));
+    for (const [clusterKey, row] of this.clusteredRows) copy.clusteredRows.set(clusterKey, row);
     return copy;
   }
   freeze() {