@crvouga/sqlite-mem 1.1.2 → 1.3.0

package/dist/unstable.js

@@ -125,6 +125,23 @@ function applyAffinity(value, affinity) {
       return value;
   }
 }
+function applyComparisonAffinity(left, right, leftAffinity, rightAffinity) {
+  const leftNumeric = leftAffinity === "INTEGER" || leftAffinity === "REAL" || leftAffinity === "NUMERIC";
+  const rightNumeric = rightAffinity === "INTEGER" || rightAffinity === "REAL" || rightAffinity === "NUMERIC";
+  const leftNone = leftAffinity === null || leftAffinity === "BLOB";
+  const rightNone = rightAffinity === null || rightAffinity === "BLOB";
+  if (leftNumeric && (rightAffinity === "TEXT" || rightNone)) {
+    const affinity = leftAffinity === "REAL" ? "REAL" : "NUMERIC";
+    return [left, applyAffinity(right, affinity)];
+  }
+  if (rightNumeric && (leftAffinity === "TEXT" || leftNone)) {
+    const affinity = rightAffinity === "REAL" ? "REAL" : "NUMERIC";
+    return [applyAffinity(left, affinity), right];
+  }
+  if (leftAffinity === "TEXT" && rightNone) return [left, applyAffinity(right, "TEXT")];
+  if (rightAffinity === "TEXT" && leftNone) return [applyAffinity(left, "TEXT"), right];
+  return [left, right];
+}
 function coerceToNumber(value) {
   if (value === null) return null;
   if (value instanceof SqlReal) return value.value;
@@ -281,14 +298,18 @@ function jsonErrorPosition(input) {
   }
 }
 function isValidJsonText(input, flags = 0) {
-  const allowJson5 = (flags & 2) !== 0 || (flags & 1) !== 0;
+  const allowCanonical = flags === 0 || (flags & 1) !== 0;
+  const allowJson5 = (flags & 2) !== 0;
   try {
     if (allowJson5) {
       parseJsonText(input);
       return true;
     }
-    parseJsonText(input, { strictCanonical: true });
-    return true;
+    if (allowCanonical) {
+      parseJsonText(input, { strictCanonical: true });
+      return true;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -1694,7 +1715,11 @@ function applyModifier(date, modifier) {
   const normalized = modifier.trim().toLowerCase();
   if (normalized === "unixepoch") return new Date((date.getTime() / 864e5 + JULIAN_UNIX_EPOCH) * 1e3);
   if (normalized === "utc" || normalized === "localtime") return result;
-  if (normalized === "start of day") result.setUTCHours(0, 0, 0, 0);
+  const weekday = /^weekday\s+([0-6])$/.exec(normalized);
+  if (weekday) {
+    const target = Number(weekday[1]);
+    result.setUTCDate(result.getUTCDate() + (target - result.getUTCDay() + 7) % 7);
+  } else if (normalized === "start of day") result.setUTCHours(0, 0, 0, 0);
   else if (normalized === "start of month") {
     result.setUTCDate(1);
     result.setUTCHours(0, 0, 0, 0);
@@ -2152,13 +2177,15 @@ var mathFunctions = {
 function escapeRegexChar(char) {
   return /[\\^$.*+?()[\]{}|]/.test(char) ? `\\${char}` : char;
 }
-function likeLiteral(char) {
-  const code = char.codePointAt(0);
-  if (code >= 65 && code <= 90) return `[${char}${char.toLowerCase()}]`;
-  if (code >= 97 && code <= 122) return `[${char}${char.toUpperCase()}]`;
+function likeLiteral(char, caseSensitive) {
+  if (!caseSensitive) {
+    const code = char.codePointAt(0);
+    if (code >= 65 && code <= 90) return `[${char}${char.toLowerCase()}]`;
+    if (code >= 97 && code <= 122) return `[${char}${char.toUpperCase()}]`;
+  }
   return escapeRegexChar(char);
 }
-function likeMatch(text2, pattern, escape = null) {
+function likeMatch(text2, pattern, escape = null, caseSensitive = false) {
   if (escape !== null && [...escape].length !== 1) {
     throw new SqliteError("ESCAPE expression must be a single character", "other");
   }
@@ -2168,13 +2195,13 @@ function likeMatch(text2, pattern, escape = null) {
     const char = chars[i];
     if (escape !== null && char === escape) {
       const next = chars[++i];
-      source += next === void 0 ? likeLiteral(char) : likeLiteral(next);
+      source += next === void 0 ? likeLiteral(char, caseSensitive) : likeLiteral(next, caseSensitive);
     } else if (char === "%") {
       source += "[\\s\\S]*";
     } else if (char === "_") {
       source += "[\\s\\S]";
     } else {
-      source += likeLiteral(char);
+      source += likeLiteral(char, caseSensitive);
     }
   }
   return new RegExp(`${source}$`).test(text2);
@@ -2481,11 +2508,11 @@ var scalarFunctions = {
     requireArgs3("load_extension", args, 1, 2);
     throw new SqliteError("not authorized", "misuse");
   },
-  like(args) {
+  like(args, context) {
     requireArgs3("like", args, 2, 3);
     if (args[0] === null || args[1] === null || args[2] === null) return null;
     const escape = args[2] === void 0 ? null : text(args[2]);
-    return likeMatch(text(args[1]), text(args[0]), escape) ? 1 : 0;
+    return likeMatch(text(args[1]), text(args[0]), escape, context.caseSensitiveLike === true) ? 1 : 0;
   },
   glob(args) {
     requireArgs3("glob", args, 2);
@@ -2830,7 +2857,8 @@ function sqlOr(left, right) {
   if (leftTruth === null || rightTruth === null) return null;
   return 0;
 }
-function compareResult(op, left, right, collation) {
+function compareResult(op, left, right, collation, leftAffinity = null, rightAffinity = null) {
+  [left, right] = applyComparisonAffinity(left, right, leftAffinity, rightAffinity);
   if (op === "IS" || op === "IS NOT" || op === "IS DISTINCT FROM" || op === "IS NOT DISTINCT FROM") {
     const equal = left === null || right === null ? left === right : (collation ? compareWithCollation(left, right, collation) : compareSql(left, right)) === 0;
     if (op === "IS" || op === "IS NOT DISTINCT FROM") return booleanValue(equal);
@@ -2883,11 +2911,18 @@ function evalBinary(op, leftExpr, rightExpr, ctx) {
   if (["=", "==", "!=", "<>", "<", "<=", ">", ">=", "IS", "IS NOT", "IS DISTINCT FROM", "IS NOT DISTINCT FROM"].includes(
     op
   )) {
-    return compareResult(op, left, right, resolveComparisonCollation(leftExpr, rightExpr, ctx) ?? void 0);
+    return compareResult(
+      op,
+      left,
+      right,
+      resolveComparisonCollation(leftExpr, rightExpr, ctx) ?? void 0,
+      resolveComparisonAffinity(leftExpr, ctx),
+      resolveComparisonAffinity(rightExpr, ctx)
+    );
   }
   if (op === "LIKE" || op === "NOT LIKE" || op === "GLOB" || op === "NOT GLOB") {
     if (left === null || right === null) return null;
-    const matches = op.includes("LIKE") ? likeMatch(textValue(left), textValue(right)) : globMatch(textValue(left), textValue(right));
+    const matches = op.includes("LIKE") ? likeMatch(textValue(left), textValue(right), null, ctx.functionContext?.caseSensitiveLike === true) : globMatch(textValue(left), textValue(right));
     return booleanValue(op.startsWith("NOT") ? !matches : matches);
   }
   if (left === null || right === null) return null;
@@ -3062,14 +3097,26 @@ function inheritedCollation(expr, ctx) {
       return null;
   }
 }
-function evalIn(left, values, not) {
+function resolveComparisonAffinity(expr, ctx) {
+  switch (expr.type) {
+    case "column":
+      return ctx.resolveAffinity?.(expr.table, expr.name) ?? ctx.parent?.resolveAffinity?.(expr.table, expr.name) ?? null;
+    case "cast":
+      return affinityFromTypeName(expr.typeName);
+    case "collate":
+      return resolveComparisonAffinity(expr.expr, ctx);
+    default:
+      return null;
+  }
+}
+function evalIn(left, values, not, leftAffinity) {
   if (values.length === 0) return booleanValue(not);
   if (left === null) return null;
   let sawNull = false;
   for (const value of values) {
     if (value === null) {
       sawNull = true;
-    } else if (compareSql(left, value) === 0) {
+    } else if (compareSql(...applyComparisonAffinity(left, value, leftAffinity, null)) === 0) {
       return booleanValue(!not);
     }
   }
@@ -3115,8 +3162,9 @@ function evalExpr(expr, ctx) {
     case "between": {
       const value = evalExpr(expr.expr, ctx);
       const collation = resolveComparisonCollation(expr.expr, expr.lower, ctx) ?? resolveComparisonCollation(expr.expr, expr.upper, ctx) ?? void 0;
-      const lower = compareResult(">=", value, evalExpr(expr.lower, ctx), collation);
-      const result = sqlAnd(lower, () => compareResult("<=", value, evalExpr(expr.upper, ctx), collation));
+      const affinity = resolveComparisonAffinity(expr.expr, ctx);
+      const lower = compareResult(">=", value, evalExpr(expr.lower, ctx), collation, affinity);
+      const result = sqlAnd(lower, () => compareResult("<=", value, evalExpr(expr.upper, ctx), collation, affinity));
       if (result === null) return null;
       return expr.not ? booleanValue(result === 0) : result;
     }
@@ -3143,14 +3191,19 @@ function evalExpr(expr, ctx) {
       }
       const left = evalExpr(expr.expr, ctx);
       const values = Array.isArray(expr.values) ? expr.values.map((value) => evalExpr(value, ctx)) : executeSelect(ctx, expr.values).rows.map((row) => row[0] ?? null);
-      return evalIn(left, values, expr.not);
+      return evalIn(left, values, expr.not, resolveComparisonAffinity(expr.expr, ctx));
     }
     case "like": {
       const value = evalExpr(expr.expr, ctx);
       const pattern = evalExpr(expr.pattern, ctx);
       const escape = expr.escape === null ? null : evalExpr(expr.escape, ctx);
       if (value === null || pattern === null || escape === null && expr.escape !== null) return null;
-      const match = expr.op === "LIKE" ? likeMatch(textValue(value), textValue(pattern), escape === null ? null : textValue(escape)) : globMatch(textValue(value), textValue(pattern));
+      const match = expr.op === "LIKE" ? likeMatch(
+        textValue(value),
+        textValue(pattern),
+        escape === null ? null : textValue(escape),
+        ctx.functionContext?.caseSensitiveLike === true
+      ) : globMatch(textValue(value), textValue(pattern));
       return booleanValue(expr.not ? !match : match);
     }
     case "case": {
@@ -3837,10 +3890,12 @@ var PREC = {
   JSON_ARROW: 80
 };
 var Parser = class {
-  constructor(tokens) {
+  constructor(tokens, source = "") {
     this.tokens = tokens;
+    this.source = source;
   }
   tokens;
+  source;
   pos = 0;
   current() {
     return this.tokens[this.pos] ?? this.tokens[this.tokens.length - 1];
@@ -3924,13 +3979,21 @@ var Parser = class {
   }
   // ── Statements ──────────────────────────────────────────────────────────
   parseStatements() {
-    const stmts = [];
+    return this.parseUnits().map((unit) => unit.statement);
+  }
+  /** Parse statements with per-statement source slices for catalog `sql` text. */
+  parseUnits() {
+    const units = [];
     while (!this.at("EOF")) {
       if (this.match("SEMI")) continue;
-      stmts.push(this.parseStatement());
+      const start = this.current().start;
+      const statement = this.parseStatement();
+      const end = this.pos > 0 ? this.tokens[this.pos - 1].end : this.current().end;
       this.match("SEMI");
+      const sql = this.source ? this.source.slice(start, end).trimEnd() : "";
+      units.push({ statement, sql });
     }
-    return stmts;
+    return units;
   }
   parseStatement() {
     if (this.match("EXPLAIN")) {
@@ -3942,13 +4005,20 @@ var Parser = class {
       const stmt = this.parseStatement();
       return { type: "explain", queryPlan, statement: stmt };
     }
-    if (this.check("WITH", "SELECT")) return this.parseSelectStmt();
+    if (this.at("WITH")) {
+      const withClause = this.parseWithClause();
+      if (this.at("SELECT")) return this.parseSelectStmt(withClause);
+      if (this.at("INSERT") || this.at("REPLACE")) return this.parseInsertStmt(withClause);
+      if (this.at("UPDATE")) return this.parseUpdateStmt(withClause);
+      if (this.at("DELETE")) return this.parseDeleteStmt(withClause);
+      this.syntaxError("expected SELECT, INSERT, UPDATE, or DELETE after WITH clause");
+    }
     if (this.at("SELECT")) return this.parseSelectStmt();
-    if (this.check("WITH", "INSERT") || this.at("INSERT") || this.at("REPLACE")) {
+    if (this.at("INSERT") || this.at("REPLACE")) {
       return this.parseInsertStmt();
     }
-    if (this.check("WITH", "UPDATE") || this.at("UPDATE")) return this.parseUpdateStmt();
-    if (this.check("WITH", "DELETE") || this.at("DELETE")) return this.parseDeleteStmt();
+    if (this.at("UPDATE")) return this.parseUpdateStmt();
+    if (this.at("DELETE")) return this.parseDeleteStmt();
     if (this.at("CREATE")) return this.parseCreateStmt();
     if (this.at("DROP")) return this.parseDropStmt();
     if (this.at("ALTER")) return this.parseAlterTableStmt();
@@ -4010,12 +4080,15 @@ var Parser = class {
         this.expect("RPAREN");
       }
       this.expect("AS");
-      if (this.match("NOT")) this.expect("MATERIALIZED", "expected MATERIALIZED after NOT");
-      else this.match("MATERIALIZED");
+      let materialized = null;
+      if (this.match("NOT")) {
+        this.expect("MATERIALIZED", "expected MATERIALIZED after NOT");
+        materialized = "not_materialized";
+      } else if (this.match("MATERIALIZED")) materialized = "materialized";
       this.expect("LPAREN");
-      const select = this.at("VALUES") ? this.parseValuesAsSelect() : this.parseSelectCore();
+      const select = this.at("VALUES") ? this.parseValuesAsSelect() : this.at("WITH") ? this.parseSelectStmt() : this.parseSelectCore();
       this.expect("RPAREN");
-      ctes.push({ name, columns, select });
+      ctes.push({ name, columns, materialized, select });
     } while (this.match("COMMA"));
     return { recursive, ctes };
   }
@@ -4023,8 +4096,7 @@ var Parser = class {
     return this.at("WITH") ? this.parseWithClause() : null;
   }
   // ── SELECT ──────────────────────────────────────────────────────────────
-  parseSelectStmt() {
-    const withClause = this.parseOptionalWith();
+  parseSelectStmt(withClause = this.parseOptionalWith()) {
     const select = this.parseSelectCore();
     select.with = withClause;
     return select;
@@ -4322,8 +4394,7 @@ var Parser = class {
     return { limit: first, offset };
   }
   // ── INSERT / REPLACE ────────────────────────────────────────────────────
-  parseInsertStmt() {
-    const withClause = this.parseOptionalWith();
+  parseInsertStmt(withClause = this.parseOptionalWith()) {
     let mode = "insert";
     if (this.match("REPLACE")) {
       mode = "replace";
@@ -4426,8 +4497,7 @@ var Parser = class {
     return this.parseResultColumns();
   }
   // ── UPDATE ──────────────────────────────────────────────────────────────
-  parseUpdateStmt() {
-    const withClause = this.parseOptionalWith();
+  parseUpdateStmt(withClause = this.parseOptionalWith()) {
     this.expect("UPDATE");
     const or = this.mapUpdateOr(this.parseOrConflict());
     const table = this.parseTableName();
@@ -4442,8 +4512,7 @@ var Parser = class {
     return { type: "update", with: withClause, or, table, alias, set, from, where, returning };
   }
   // ── DELETE ──────────────────────────────────────────────────────────────
-  parseDeleteStmt() {
-    const withClause = this.parseOptionalWith();
+  parseDeleteStmt(withClause = this.parseOptionalWith()) {
     this.expect("DELETE");
     this.expect("FROM");
     const table = this.parseTableName();
@@ -5112,6 +5181,24 @@ var Parser = class {
           left = this.parseLikeRhs(left, true, "GLOB");
           continue;
         }
+        if (n.kind === "REGEXP") {
+          this.advance();
+          this.advance();
+          const pattern = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
+          left = {
+            type: "unary",
+            op: "NOT",
+            expr: {
+              type: "function",
+              name: "REGEXP",
+              distinct: false,
+              args: [pattern, left],
+              orderBy: [],
+              filter: null
+            }
+          };
+          continue;
+        }
         if (n.kind === "BETWEEN") {
           this.advance();
           this.advance();
@@ -5167,6 +5254,12 @@ var Parser = class {
         left = this.parseLikeRhs(left, false, "GLOB");
         continue;
       }
+      if (this.at("REGEXP") && PREC.IS_IN_LIKE >= minPrec) {
+        this.advance();
+        const pattern = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
+        left = { type: "function", name: "REGEXP", distinct: false, args: [pattern, left], orderBy: [], filter: null };
+        continue;
+      }
       if (this.at("MATCH") && PREC.IS_IN_LIKE >= minPrec) {
         this.advance();
         const right2 = this.parseExprPrec(PREC.IS_IN_LIKE + 1);
@@ -5325,7 +5418,7 @@ var Parser = class {
     }
     if (this.at("CURRENT_DATE") || this.at("CURRENT_TIME") || this.at("CURRENT_TIMESTAMP")) {
       const tok = this.advance();
-      return { type: "function", name: tok.value, distinct: false, args: [], filter: null };
+      return { type: "function", name: tok.value, distinct: false, args: [], orderBy: [], filter: null };
     }
     if (this.at("NUMBER")) {
       const tok = this.advance();
@@ -5408,6 +5501,7 @@ var Parser = class {
         } while (this.match("COMMA"));
       }
     }
+    const orderBy = this.parseOrderBy();
     this.expect("RPAREN");
     if (this.match("FILTER")) {
       this.expect("LPAREN");
@@ -5428,13 +5522,13 @@ var Parser = class {
         window = this.parseWindowSpec();
         this.expect("RPAREN");
       }
-      const func = isAgg ? { type: "aggregate", name: upper, distinct, args, filter } : { type: "function", name, distinct, args, filter };
+      const func = isAgg ? { type: "aggregate", name: upper, distinct, args, orderBy, filter } : { type: "function", name, distinct, args, orderBy, filter };
       return { type: "window", func, window };
     }
     if (isAgg) {
-      return { type: "aggregate", name: upper, distinct, args, filter };
+      return { type: "aggregate", name: upper, distinct, args, orderBy, filter };
     }
-    return { type: "function", name, distinct, args, filter };
+    return { type: "function", name, distinct, args, orderBy, filter };
   }
   parseCaseExpr(base) {
     const whens = [];
@@ -5525,14 +5619,16 @@ var Parser = class {
     return { kind: "following", expr };
   }
 };
-function parseTokens(tokens) {
-  return new Parser(tokens).parseStatements();
+function parseTokenUnits(tokens, source) {
+  return new Parser(tokens, source).parseUnits();
 }
 
 // src/parser/index.ts
 function parse(sql) {
-  const tokens = tokenize(sql);
-  return parseTokens(tokens);
+  return parseUnits(sql).map((unit) => unit.statement);
+}
+function parseUnits(sql) {
+  return parseTokenUnits(tokenize(sql), sql);
 }
 
 // src/runtime/clock.ts
@@ -5542,8 +5638,12 @@ function fixedClock(instant = DEFAULT_NOW) {
   if (Number.isNaN(ms)) throw new RangeError("invalid clock instant");
   return () => new Date(ms);
 }
+function systemClock() {
+  return () => /* @__PURE__ */ new Date();
+}
 function resolveClock(now) {
   if (now === void 0) return fixedClock(DEFAULT_NOW);
+  if (now === "system") return systemClock();
   if (typeof now === "function") return () => new Date(now().getTime());
   return fixedClock(now);
 }
@@ -5608,6 +5708,28 @@ var Prng = class _Prng {
     return copy;
   }
 };
+var OsEntropy = class _OsEntropy extends Prng {
+  constructor() {
+    super(1);
+  }
+  nextU64() {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    let value = 0n;
+    for (let i = 0; i < 8; i++) {
+      value |= BigInt(bytes[i]) << BigInt(i * 8);
+    }
+    return BigInt.asUintN(64, value);
+  }
+  getState() {
+    return 0n;
+  }
+  setState(_state) {
+  }
+  clone() {
+    return new _OsEntropy();
+  }
+};
 function deriveSeed(...parts) {
   let hash = 2166136261;
   for (const part of parts) {
@@ -6683,7 +6805,7 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
   insert(values, rowid) {
     const command = this.detectCommand(values);
     if (command !== null) {
-      this.runCommand(command, values);
+      this.runCommand(command, values, rowid);
       return 0;
     }
     const assigned = rowid ?? this.nextRowid++;
@@ -6832,18 +6954,63 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     }
     return parts.join(" ");
   }
-  /** FTS3 matchinfo default format 'pcx' simplified → blob of 32-bit LE ints. */
-  matchinfo(cursor, _format = "pcx") {
+  /** FTS3 matchinfo format encoded as native-style 32-bit little-endian integers. */
+  matchinfo(cursor, format = "pcx") {
     const row = this.rows.get(cursor.rowid);
     const nPhrase = Math.max(1, cursor.phraseTerms.length);
     const nCol = this.columns.length;
-    const values = [nPhrase, nCol];
-    for (let p = 0; p < nPhrase; p++) {
-      for (let c = 0; c < nCol; c++) {
-        const col = this.columns[c];
-        const term = cursor.phraseTerms[p]?.[0] ?? "";
-        const tf = row ? this.termFreq(row, col, term) : 0;
-        values.push(tf);
+    const values = [];
+    for (const request of format) {
+      switch (request) {
+        case "p":
+          values.push(nPhrase);
+          break;
+        case "c":
+          values.push(nCol);
+          break;
+        case "s":
+          for (let c = 0; c < nCol; c++) {
+            let longest = 0;
+            let run = 0;
+            for (let p = 0; p < nPhrase; p++) {
+              const phrase = cursor.phraseTerms[p] ?? [];
+              if (row && this.phraseFreq(row, this.columns[c], phrase) > 0) {
+                run++;
+                longest = Math.max(longest, run);
+              } else {
+                run = 0;
+              }
+            }
+            values.push(longest);
+          }
+          break;
+        case "x":
+          for (let p = 0; p < nPhrase; p++) {
+            const phrase = cursor.phraseTerms[p] ?? [];
+            for (let c = 0; c < nCol; c++) {
+              const column = this.columns[c];
+              const localHits = row ? this.phraseFreq(row, column, phrase) : 0;
+              let globalHits = 0;
+              let matchingRows = 0;
+              for (const candidate of this.rows.values()) {
+                const hits = this.phraseFreq(candidate, column, phrase);
+                globalHits += hits;
+                if (hits > 0) matchingRows++;
+              }
+              values.push(localHits, globalHits, matchingRows);
+            }
+          }
+          break;
+        case "y":
+          for (let p = 0; p < nPhrase; p++) {
+            const phrase = cursor.phraseTerms[p] ?? [];
+            for (let c = 0; c < nCol; c++) {
+              values.push(row ? this.phraseFreq(row, this.columns[c], phrase) : 0);
+            }
+          }
+          break;
+        default:
+          throw new SqliteError(`unrecognized matchinfo request: ${request}`, "other");
       }
     }
     const buf = new Uint8Array(values.length * 4);
@@ -6891,13 +7058,9 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     if (!values.has(key)) return null;
     const v = values.get(key);
     if (typeof v !== "string") return null;
-    const otherContent = [...values.entries()].some(
-      ([k, val]) => k !== key && val !== null && this.columns.some((c) => c.toLowerCase() === k)
-    );
-    if (otherContent) return null;
     return v;
   }
-  runCommand(command, _values) {
+  runCommand(command, _values, rowid) {
     const cmd = command.toLowerCase();
     if (cmd === "optimize") return;
     if (cmd === "rebuild") {
@@ -6912,13 +7075,15 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
           "other"
         );
       }
-      for (const rowid of [...this.rows.keys()]) this.delete(rowid);
+      for (const rowid2 of [...this.rows.keys()]) this.delete(rowid2);
       return;
     }
     if (cmd.startsWith("merge=") || cmd.startsWith("automerge=")) {
       throw new SqliteError("SQL logic error", "other");
     }
     if (cmd === "delete") {
+      if (rowid === void 0) throw new SqliteError("SQL logic error", "other");
+      this.delete(rowid);
       return;
     }
     throw new SqliteError("SQL logic error", "other");
@@ -7151,11 +7316,6 @@ var Fts5VirtualTable = class _Fts5VirtualTable {
     }
     return n;
   }
-  termFreq(row, column, term) {
-    const needle = this.normalizeQueryTerm(term);
-    const tokens = row.tokensByColumn.get(column.toLowerCase()) ?? [];
-    return tokens.filter((t) => t.term === needle || t.term.startsWith(needle)).length;
-  }
   docLength(row) {
     let n = 0;
     for (const col of this.indexedColumns()) n += (row.tokensByColumn.get(col.toLowerCase()) ?? []).length;
@@ -7419,6 +7579,8 @@ var Table = class _Table {
   scanCache = null;
   /** Lazy covering hashes: column nameLower → serializeIndexKey → rowids. */
   equalityHashes = null;
+  /** Cached maximum rowid. `undefined` means recompute after deleting the maximum. */
+  maximumRowid = null;
   frozen = false;
   constructor(name, columns, options = {}) {
     this.name = name;
@@ -7621,7 +7783,12 @@ var Table = class _Table {
     if (alias) values.set(normalizeColumnName(alias.name), targetKey);
     const candidate = { rowid: targetKey, values };
     this.validate(candidate, key);
-    if (targetKey !== key) this.rows.delete(key);
+    if (targetKey !== key) {
+      this.rows.delete(key);
+      if (this.maximumRowid !== null && this.maximumRowid !== void 0 && sameRowid2(key, this.maximumRowid)) {
+        this.maximumRowid = void 0;
+      }
+    }
     this.rows.set(targetKey, candidate);
     this.advanceNextRowid(targetKey);
     this.reindexEquality(existing, candidate);
@@ -7635,6 +7802,9 @@ var Table = class _Table {
     if (this.withoutRowid) this.clusteredRows.delete(this.makeClusterKey(existing.values));
     this.unindexEquality(existing);
     this.invalidateScan();
+    if (this.maximumRowid !== null && this.maximumRowid !== void 0 && sameRowid2(key, this.maximumRowid)) {
+      this.maximumRowid = void 0;
+    }
     return this.rows.delete(key);
   }
   *scan() {
@@ -7656,6 +7826,7 @@ var Table = class _Table {
       strict: this.strict
     });
     copy.nextRowid = this.nextRowid;
+    copy.maximumRowid = this.maximumRowid;
     for (const [rowid, row] of this.rows) copy.rows.set(rowid, cloneRow(row));
     for (const [clusterKey, row] of this.clusteredRows) copy.clusteredRows.set(clusterKey, cloneRow(row));
     return copy;
@@ -7668,6 +7839,7 @@ var Table = class _Table {
   }
   /** Rebuild clustered storage after snapshot decode or bulk load. */
   rebuildClusteredRows() {
+    this.maximumRowid = void 0;
     if (!this.withoutRowid) return;
     this.clusteredRows.clear();
     for (const row of this.rows.values()) {
@@ -7776,11 +7948,23 @@ var Table = class _Table {
     return primary[0];
   }
   allocateRowid() {
+    if (!this.columns.some((column) => column.autoincrement)) {
+      if (this.maximumRowid === void 0) {
+        this.maximumRowid = null;
+        for (const rowid of this.rows.keys()) {
+          if (this.maximumRowid === null || compareRowids(rowid, this.maximumRowid) > 0) this.maximumRowid = rowid;
+        }
+      }
+      return this.maximumRowid === null ? 1 : incrementRowid(this.maximumRowid);
+    }
     let candidate = canonicalRowid(this.nextRowid);
     while (this.rows.has(candidate)) candidate = incrementRowid(candidate);
     return candidate;
   }
   advanceNextRowid(rowid) {
+    if (this.maximumRowid === null || this.maximumRowid !== void 0 && compareRowids(rowid, this.maximumRowid) > 0) {
+      this.maximumRowid = rowid;
+    }
     if (compareRowids(rowid, this.nextRowid) >= 0) this.nextRowid = incrementRowid(rowid);
   }
 };
@@ -7855,6 +8039,8 @@ var DatabaseState = class _DatabaseState {
   changes = 0;
   totalChanges = 0;
   foreignKeysEnabled = false;
+  /** When true, LIKE / like() are case-sensitive (SQLite `PRAGMA case_sensitive_like`). */
+  caseSensitiveLike = false;
   schemaVersion = 0;
   userVersion = 0;
   databaseForSchema(schema, qualifiedForError) {
@@ -8299,6 +8485,7 @@ var DatabaseState = class _DatabaseState {
     copy.changes = this.changes;
     copy.totalChanges = this.totalChanges;
     copy.foreignKeysEnabled = this.foreignKeysEnabled;
+    copy.caseSensitiveLike = this.caseSensitiveLike;
     copy.schemaVersion = this.schemaVersion;
     copy.userVersion = this.userVersion;
     return copy;
@@ -8318,6 +8505,7 @@ var DatabaseState = class _DatabaseState {
     copy.changes = this.changes;
     copy.totalChanges = this.totalChanges;
     copy.foreignKeysEnabled = this.foreignKeysEnabled;
+    copy.caseSensitiveLike = this.caseSensitiveLike;
     copy.schemaVersion = this.schemaVersion;
     copy.userVersion = this.userVersion;
     return copy;
@@ -8379,6 +8567,7 @@ var DatabaseState = class _DatabaseState {
     this.changes = copy.changes;
     this.totalChanges = copy.totalChanges;
     this.foreignKeysEnabled = copy.foreignKeysEnabled;
+    this.caseSensitiveLike = copy.caseSensitiveLike;
     this.schemaVersion = copy.schemaVersion;
     this.userVersion = copy.userVersion;
   }
@@ -8723,6 +8912,7 @@ function jsonReviver(_key, value) {
 export {
   DEFAULT_DATABASE_SEED,
   DEFAULT_NOW,
+  OsEntropy,
   Prng,
   SqlJsonText,
   SqlReal,
@@ -8748,6 +8938,7 @@ export {
   resolveClock,
   sqlValueEquals,
   storageClassOf,
+  systemClock,
   toInteger,
   tokenize,
   typeofSql,