@poe-platform/safe-bash 0.1.839 → 0.1.840

package/dist/safe-bash-command-sqlite3/index.js

@@ -3,6 +3,75 @@ import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 // packages/safe-bash-command-sqlite3/src/engine.ts
 import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
 
+// packages/safe-bash-command-sqlite3/src/real-output.ts
+function formatReal(value, precision) {
+  if (!Number.isFinite(value)) return Number.isNaN(value) ? "NaN" : value < 0 ? "-Inf" : "Inf";
+  if (value === 0) return "0.0";
+  let high = Math.abs(value), low = 0, exponent = 0;
+  const bits = new DataView(new ArrayBuffer(8));
+  function upper(x) {
+    bits.setFloat64(0, x);
+    bits.setUint32(4, bits.getUint32(4) & 4227858432);
+    return bits.getFloat64(0);
+  }
+  function multiply(y, error) {
+    const hx = upper(high), hy = upper(y), tx = high - hx, ty = y - hy;
+    const p = hx * hy, q = hx * ty + tx * hy, c = p + q;
+    let cc = p - c + q + tx * ty;
+    cc = high * error + low * y + cc;
+    high = c + cc;
+    low = c - high + cc;
+  }
+  if (high > 9223372036854775e3) {
+    while (high > 9223372036854774e103) {
+      exponent += 100;
+      multiply(1e-100, -19991899802602883e-133);
+    }
+    while (high > 9223372036854774e13) {
+      exponent += 10;
+      multiply(1e-10, -3643219731549774e-42);
+    }
+    while (high > 9223372036854775e3) {
+      exponent++;
+      multiply(0.1, -5551115123125783e-33);
+    }
+  } else {
+    while (high < 9223372036854775e-98) {
+      exponent -= 100;
+      multiply(1e100, -15902891109759918e67);
+    }
+    while (high < 9223372036854775e-8) {
+      exponent -= 10;
+      multiply(1e10, 0);
+    }
+    while (high < 922337203685477500) {
+      exponent--;
+      multiply(10, 0);
+    }
+  }
+  let digits = (BigInt(Math.trunc(high)) + BigInt(Math.trunc(low))).toString();
+  if (precision === 20 && Number(`${digits}e${exponent}`) !== Math.abs(value)) {
+    const [mantissa, power] = Math.abs(value).toExponential(19).split("e");
+    digits = mantissa.replace(".", "");
+    exponent = Number(power) - digits.length + 1;
+  }
+  let point = digits.length + exponent;
+  if (digits.length > precision) {
+    const roundUp = digits[precision] >= "5";
+    digits = (BigInt(digits.slice(0, precision)) + (roundUp ? 1n : 0n)).toString();
+    if (digits.length > precision) point++;
+  }
+  while (digits.endsWith("0")) digits = digits.slice(0, -1);
+  const sign = value < 0 ? "-" : "";
+  exponent = point - 1;
+  if (exponent < -4 || exponent >= precision) {
+    return `${sign}${digits[0]}.${digits.slice(1) || "0"}e${exponent < 0 ? "-" : "+"}${String(Math.abs(exponent)).padStart(2, "0")}`;
+  }
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (point >= digits.length) return `${sign}${digits}${"0".repeat(point - digits.length)}.0`;
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+
 // packages/safe-bash-command-sqlite3/src/execution.ts
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
 function runSynchronously(steps) {
@@ -725,7 +794,7 @@ function writeSqliteDatabaseBytes(image) {
       });
     } else if (item.type === "index") {
       const idxRows = image.indexRows?.get(item.name) ?? [];
-      const built = buildIndexPages(idxRows, nextPageNumber);
+      const built = buildIndexPages(idxRows, nextPageNumber, item.indexPresorted);
       extraPageChunks.push(...built.pages);
       nextPageNumber += built.pages.length;
       masterEntries.push({
@@ -763,7 +832,7 @@ function writeSqliteDatabaseBytes(image) {
         reMasterEntries.push({ ...item, rootpage: built.rootPage });
       } else if (item.type === "index") {
         const idxRows = image.indexRows?.get(item.name) ?? [];
-        const built = buildIndexPages(idxRows, pNum);
+        const built = buildIndexPages(idxRows, pNum, item.indexPresorted);
         reExtraChunks.push(...built.pages);
         pNum += built.pages.length;
         reMasterEntries.push({ ...item, rootpage: built.rootPage });
@@ -857,6 +926,7 @@ function tableStorageColumns(table) {
 var textEncoder2 = new TextEncoder();
 var textDecoder2 = new TextDecoder("utf-8", { fatal: false });
 var SqliteConstraintError = class extends Error {
+  code = 19;
 };
 function cloneSqlValue(v) {
   if (v instanceof Uint8Array) {
@@ -887,6 +957,7 @@ function cloneTableDef(t) {
     strict: t.strict,
     primaryKeyCols: [...t.primaryKeyCols],
     primaryKeyOrder: t.primaryKeyOrder?.map((key) => ({ ...key })),
+    implicitIndexes: t.implicitIndexes?.map((index) => ({ ...index, columns: [...index.columns], order: index.order.map((key) => ({ ...key })) })),
     uniqueColSets: t.uniqueColSets.map((u) => [...u])
   };
 }
@@ -1173,6 +1244,13 @@ function reconstructTokensSql(tokens) {
   }
   return out;
 }
+function isFromClause(tokens, index) {
+  const isWord = (offset, word) => {
+    const token = tokens[index + offset];
+    return token?.type === "word" && token.value.toUpperCase() === word;
+  };
+  return isWord(0, "FROM") && !(isWord(-1, "DISTINCT") && (isWord(-2, "IS") || isWord(-2, "NOT") && isWord(-3, "IS")));
+}
 var ExprParser = class {
   constructor(tokens) {
     this.tokens = tokens;
@@ -1496,11 +1574,11 @@ var ExprParser = class {
       }
       if (upper === "TRUE") {
         this.pos += 1;
-        return { kind: "literal", value: 1 };
+        return { kind: "literal", value: 1, booleanLiteral: true };
       }
       if (upper === "FALSE") {
         this.pos += 1;
-        return { kind: "literal", value: 0 };
+        return { kind: "literal", value: 0, booleanLiteral: true };
       }
       if (upper === "CURRENT_TIMESTAMP") {
         this.pos += 1;
@@ -1771,17 +1849,25 @@ function arithmeticNumber(value) {
   }
   return real ? new Number(Number(text.slice(0, end))) : integerResult(BigInt(text.slice(0, end)));
 }
+function columnAffinity(declaredType) {
+  const type = declaredType.toUpperCase();
+  if (type.includes("INT")) return "INTEGER";
+  if (["CHAR", "CLOB", "TEXT"].some((part) => type.includes(part))) return "TEXT";
+  if (type === "" || type.includes("BLOB")) return "BLOB";
+  if (["REAL", "FLOA", "DOUB"].some((part) => type.includes(part))) return "REAL";
+  return "NUMERIC";
+}
 function applyColumnAffinity(storedValue, declaredType, strict) {
   let value = storedValue instanceof String ? storedValue.valueOf() : storedValue;
   if (value === null || value instanceof Uint8Array) return value;
   const type = declaredType.toUpperCase();
   if (strict && type === "ANY") return value;
-  const integer = type.includes("INT");
-  if (!integer && ["CHAR", "CLOB", "TEXT"].some((part) => type.includes(part))) {
+  const affinity = columnAffinity(type);
+  if (affinity === "TEXT") {
     return toSqlString(value);
   }
-  if (!integer && (type === "" || type.includes("BLOB"))) return value;
-  const real = !integer && ["REAL", "FLOA", "DOUB"].some((part) => type.includes(part));
+  if (affinity === "BLOB") return value;
+  const real = affinity === "REAL";
   if (typeof value === "string") {
     const text = value.trim();
     if (!text || ![...text].every((char) => "0123456789.+-eE".includes(char)) || Number.isNaN(Number(text))) return value;
@@ -1812,11 +1898,10 @@ function toSqlString(v) {
     return v.toString();
   }
   if (v instanceof Number) {
-    const n = v.valueOf();
-    return Number.isFinite(n) && Number.isInteger(n) ? `${n}.0` : String(Number(n.toPrecision(15)));
+    return formatReal(v.valueOf(), 15);
   }
   if (typeof v === "number") {
-    return Number.isInteger(v) ? String(v) : String(Number(v.toPrecision(15)));
+    return Number.isInteger(v) ? String(v) : formatReal(v, 15);
   }
   const nulIdx = v.indexOf(0);
   const sub = nulIdx === -1 ? v : v.subarray(0, nulIdx);
@@ -1861,22 +1946,24 @@ function sqlEquals(a, b, collation = "BINARY") {
 function matchLike(str, pattern, caseInsensitive, escapeChar = "") {
   let regexStr = "^";
   for (let i = 0; i < pattern.length; i += 1) {
-    const c = pattern[i];
-    if (escapeChar && c === escapeChar && i + 1 < pattern.length) {
-      regexStr += pattern[i + 1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    let c = pattern[i];
+    const escaped = escapeChar && c === escapeChar && i + 1 < pattern.length;
+    if (escaped) {
       i += 1;
-      continue;
+      c = pattern[i];
     }
-    if (c === "%") {
+    if (!escaped && c === "%") {
       regexStr += "[\\s\\S]*";
-    } else if (c === "_") {
+    } else if (!escaped && c === "_") {
       regexStr += "[\\s\\S]";
+    } else if (caseInsensitive && (c >= "a" && c <= "z" || c >= "A" && c <= "Z")) {
+      regexStr += `[${c.toUpperCase()}${c.toLowerCase()}]`;
     } else {
       regexStr += c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
   }
   regexStr += "$";
-  return new RegExp(regexStr, caseInsensitive ? "i" : "").test(str);
+  return new RegExp(regexStr).test(str);
 }
 function matchGlob(str, pattern) {
   let regexStr = "^";
@@ -2231,6 +2318,7 @@ var SqliteDatabase = class {
   async executeStatementAsync(sql, signal) {
     return runCooperatively(this.executeStatementSteps(sql), signal);
   }
+  rowTables = /* @__PURE__ */ new WeakMap();
   tables = /* @__PURE__ */ new Map();
   indexes = /* @__PURE__ */ new Map();
   views = /* @__PURE__ */ new Map();
@@ -2246,7 +2334,9 @@ var SqliteDatabase = class {
   lastInsertRowid = 0;
   lastChanges = 0;
   totalChanges = 0;
-  inTransaction = false;
+  get inTransaction() {
+    return this.txSnapshot !== null || this.savepoints.size > 0;
+  }
   foreignKeyDepth = 0;
   outerRows = [];
   preparing = false;
@@ -2448,6 +2538,41 @@ var SqliteDatabase = class {
         };
       }, this);
       tableRows.set(tbl.name, rows);
+      const indexes = [];
+      for (const index of tbl.implicitIndexes ?? []) {
+        yield;
+        const columns = index.columns.map((name2) => tbl.columns.find((column) => column.name.toLowerCase() === name2.toLowerCase()));
+        if (index.primary && !tbl.withoutRowId && columns.length === 1 && columns[0].type.toUpperCase() === "INTEGER") continue;
+        if (indexes.some((existing) => existing.columns.length === index.columns.length && existing.columns.every((name2, i) => name2.toLowerCase() === index.columns[i].toLowerCase() && (existing.order[i]?.collation ?? columns[i].collate ?? "BINARY").toUpperCase() === (index.order[i]?.collation ?? columns[i].collate ?? "BINARY").toUpperCase()))) continue;
+        indexes.push(index);
+        if (index.primary && tbl.withoutRowId) continue;
+        const name = `sqlite_autoindex_${tbl.name}_${indexes.length}`;
+        const keyColumns = [...columns];
+        const order = [...index.order];
+        if (tbl.withoutRowId) {
+          for (let i = 0; i < tbl.primaryKeyCols.length; i++) {
+            const column = tbl.columns.find((column2) => column2.name.toLowerCase() === tbl.primaryKeyCols[i].toLowerCase());
+            if (keyColumns.includes(column)) continue;
+            keyColumns.push(column);
+            order.push(tbl.primaryKeyOrder?.[i] ?? { desc: false, collation: column.collate });
+          }
+        }
+        const entries = yield* stepMap(tbl.rows, function* (row) {
+          yield;
+          const values = keyColumns.map((column) => row.data[column.name] ?? null);
+          if (!tbl.withoutRowId) values.push(row.rowid);
+          return values;
+        }, this);
+        indexRows.set(name, yield* stepSort(entries, function* (left, right) {
+          for (let i = 0; i < left.length; i++) {
+            yield;
+            const comparison = compareSqlValues(left[i], right[i], order[i]?.collation ?? keyColumns[i]?.collate ?? "BINARY");
+            if (comparison) return order[i]?.desc ? -comparison : comparison;
+          }
+          return 0;
+        }, this));
+        master.push({ type: "index", name, tbl_name: tbl.name, rootpage: rootPageCounter++, sql: null, indexPresorted: true });
+      }
     }
     if ((hasAutoIncTable || seqRows.length > 0) && !this.findTable("sqlite_sequence")) {
       master.push({
@@ -2545,7 +2670,7 @@ var SqliteDatabase = class {
         const candidate = { rowid, data };
         const conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate);
         if (conflict) {
-          throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+          throw new SqliteConstraintError(`UNIQUE constraint failed: ${conflict.columns.map((column) => `${tbl.name}.${column}`).join(", ")}`);
         }
         this.checkRowCount(tbl.rows.length + 1);
         tbl.rows.push(candidate);
@@ -2636,12 +2761,10 @@ var SqliteDatabase = class {
     if (first === "BEGIN") {
       if (!this.inTransaction) {
         this.txSnapshot = yield* this.captureSnapshot();
-        this.inTransaction = true;
       }
       return null;
     }
     if (first === "COMMIT" || first === "END") {
-      this.inTransaction = false;
       this.txSnapshot = null;
       this.savepoints.clear();
       return null;
@@ -2663,10 +2786,10 @@ var SqliteDatabase = class {
         yield* this.restoreSnapshot(snap);
         return null;
       }
-      if (this.txSnapshot) {
-        yield* this.restoreSnapshot(this.txSnapshot);
+      const snapshot = this.txSnapshot ?? this.savepoints.values().next().value;
+      if (snapshot) {
+        yield* this.restoreSnapshot(snapshot);
       }
-      this.inTransaction = false;
       this.txSnapshot = null;
       this.savepoints.clear();
       return null;
@@ -2679,7 +2802,11 @@ var SqliteDatabase = class {
     if (first === "RELEASE") {
       const spIdx = tokens[1]?.value.toUpperCase() === "SAVEPOINT" ? 2 : 1;
       const spName = (tokens[spIdx]?.value ?? "").toLowerCase();
-      this.savepoints.delete(spName);
+      let releasing = false;
+      for (const name of this.savepoints.keys()) {
+        if (name === spName) releasing = true;
+        if (releasing) this.savepoints.delete(name);
+      }
       return null;
     }
     if (first === "VACUUM" || first === "ANALYZE" || first === "REINDEX" || first === "ATTACH" || first === "DETACH") {
@@ -2704,9 +2831,12 @@ var SqliteDatabase = class {
       return null;
     }
     if (["INSERT", "REPLACE", "UPDATE", "DELETE"].includes(first)) {
-      const snapshot = this.foreignKeys && this.foreignKeyDepth === 0 ? yield* this.captureSnapshot() : null;
+      const rollbackOnConflict = first === "INSERT" && tokens[1]?.value.toUpperCase() === "OR" && tokens[2]?.value.toUpperCase() === "ROLLBACK";
+      const rollbackSnapshot = rollbackOnConflict ? this.txSnapshot ?? this.savepoints.values().next().value ?? (yield* this.captureSnapshot()) : null;
+      const failOnConflict = tokens[1]?.value.toUpperCase() === "OR" && tokens[2]?.value.toUpperCase() === "FAIL";
+      const snapshot = this.foreignKeyDepth === 0 ? yield* this.captureSnapshot() : null;
       const existingRows = /* @__PURE__ */ new Set();
-      if (snapshot) {
+      if (this.foreignKeys && snapshot) {
         for (const table of this.tables.values()) {
           for (const row of table.rows) {
             yield;
@@ -2721,10 +2851,22 @@ var SqliteDatabase = class {
         if (first === "UPDATE") result = yield* this.executeUpdate(tokens, positionalParams, cteScope);
         else if (first === "DELETE") result = yield* this.executeDelete(tokens, positionalParams, cteScope);
         else result = yield* this.executeInsert(sql, tokens, positionalParams, cteScope);
-        if (snapshot) yield* this.validateForeignKeys(snapshot, existingRows);
+        if (this.foreignKeys && snapshot) yield* this.validateForeignKeys(snapshot, existingRows);
         return result;
-      } catch (error) {
-        if (snapshot) {
+      } catch (caughtError) {
+        let error = caughtError;
+        if (this.foreignKeys && snapshot && failOnConflict && error instanceof SqliteConstraintError && error.message !== "FOREIGN KEY constraint failed") {
+          try {
+            yield* this.validateForeignKeys(snapshot, existingRows);
+          } catch (foreignKeyError) {
+            error = foreignKeyError;
+          }
+        }
+        if (rollbackSnapshot && error instanceof SqliteConstraintError && error.message !== "FOREIGN KEY constraint failed") {
+          yield* this.restoreSnapshot(rollbackSnapshot);
+          this.txSnapshot = null;
+          this.savepoints.clear();
+        } else if (snapshot && !(failOnConflict && error instanceof SqliteConstraintError && error.message !== "FOREIGN KEY constraint failed")) {
           yield* this.restoreSnapshot(snapshot);
           [this.lastChanges, this.totalChanges, this.lastInsertRowid] = counters;
         }
@@ -3046,6 +3188,7 @@ var SqliteDatabase = class {
       const primaryKeyCols = [];
       const primaryKeyOrder = [];
       const uniqueColSets = [];
+      const implicitIndexes = [];
       const foreignKeys = [];
       for (const part of bodyParts) {
         yield;
@@ -3111,24 +3254,35 @@ var SqliteDatabase = class {
               if (direction === "ASC" || direction === "DESC") pIdx++;
             }
           }
+          implicitIndexes.push({ columns: primaryKeyCols, order: primaryKeyOrder, primary: true });
           continue;
         }
         if (firstWord === "UNIQUE") {
           pIdx += 1;
           const uCols = [];
+          const order = [];
           if (part[pIdx]?.value === "(") {
-            pIdx += 1;
+            pIdx++;
             while (pIdx < part.length && part[pIdx]?.value !== ")") {
               yield;
-              const colName = part[pIdx].value;
-              if (colName !== "," && colName.toUpperCase() !== "ASC" && colName.toUpperCase() !== "DESC") {
-                uCols.push(colName);
+              if (part[pIdx].value === ",") {
+                pIdx++;
+                continue;
               }
-              pIdx += 1;
+              uCols.push(part[pIdx++].value);
+              let collation;
+              if (part[pIdx]?.value.toUpperCase() === "COLLATE") {
+                collation = part[pIdx + 1]?.value;
+                pIdx += 2;
+              }
+              const direction = part[pIdx]?.value.toUpperCase();
+              order.push({ desc: direction === "DESC", collation });
+              if (direction === "ASC" || direction === "DESC") pIdx++;
             }
           }
           if (uCols.length > 0) {
             uniqueColSets.push(uCols);
+            implicitIndexes.push({ columns: uCols, order, primary: false });
           }
           continue;
         }
@@ -3145,6 +3299,17 @@ var SqliteDatabase = class {
         if (colDef.unique) {
           uniqueColSets.push([colDef.name]);
         }
+        for (let i = 1; i < part.length; i++) {
+          if (part[i]?.type !== "word") continue;
+          const keyword = part[i].value.toUpperCase();
+          if (keyword === "UNIQUE" || keyword === "PRIMARY" && part[i + 1]?.value.toUpperCase() === "KEY") {
+            implicitIndexes.push({
+              columns: [colDef.name],
+              primary: keyword === "PRIMARY",
+              order: [{ desc: keyword === "PRIMARY" && part[i + 2]?.value.toUpperCase() === "DESC", collation: colDef.collate }]
+            });
+          }
+        }
       }
       if (primaryKeyCols.length === 1) {
         const pkCol = columns.find((c) => {
@@ -3166,6 +3331,7 @@ var SqliteDatabase = class {
         primaryKeyCols,
         primaryKeyOrder,
         uniqueColSets,
+        implicitIndexes,
         foreignKeys
       });
       return;
@@ -3226,7 +3392,7 @@ var SqliteDatabase = class {
         }
         yield* stepSort(keys, compareKeys, this);
         for (let i = 1; i < keys.length; i++) {
-          if ((yield* compareKeys(keys[i - 1], keys[i])) === 0) throw new SqliteConstraintError(`UNIQUE constraint failed: ${tbl.name}`);
+          if ((yield* compareKeys(keys[i - 1], keys[i])) === 0) throw new SqliteConstraintError(`UNIQUE constraint failed: ${cols.map((column) => `${tbl.name}.${column}`).join(", ")}`);
         }
       }
       this.indexes.set(objName, { name: objName, tableName: tbl.name, unique, columns: cols, collations, sql });
@@ -3812,7 +3978,7 @@ var SqliteDatabase = class {
               }
               if (!previouslyValid) continue;
             }
-            throw new Error("FOREIGN KEY constraint failed");
+            throw new SqliteConstraintError("FOREIGN KEY constraint failed");
           }
         }
       }
@@ -3835,7 +4001,7 @@ var SqliteDatabase = class {
           yield;
           if (this.foreignKeyMatches(child, row, key, columns, oldData)) matches.push(row);
         }
-        if (action === "RESTRICT" && matches.length) throw new Error("FOREIGN KEY constraint failed");
+        if (action === "RESTRICT" && matches.length) throw new SqliteConstraintError("FOREIGN KEY constraint failed");
         for (const row of matches) {
           yield;
           const where = child.withoutRowId ? child.primaryKeyCols.map((name) => `${quote(name)} IS ${this.toSqlLiteral(row.data[name] ?? null)}`).join(" AND ") : `rowid = ${row.rowid}`;
@@ -3945,12 +4111,12 @@ var SqliteDatabase = class {
         fastIdx.lastRow = added;
       }
       const byId = fastIdx.byRowid.get(candidate.rowid);
-      if (byId) return byId;
+      if (byId) return { row: byId, columns: [tbl.columns.find((col) => col.primaryKey && col.type.toUpperCase() === "INTEGER")?.name ?? "rowid"] };
       for (let i = 0; i < resolvedKeySets.length; i += 1) {
         const k = encodeKey(candidate, resolvedKeySets[i]);
         if (k !== null) {
           const hit = fastIdx.byKeySets[i].get(k);
-          if (hit) return hit;
+          if (hit) return { row: hit, columns: resolvedKeySets[i].map((key) => key.cKey) };
         }
       }
       return null;
@@ -3961,7 +4127,7 @@ var SqliteDatabase = class {
         continue;
       }
       if (existing.rowid === candidate.rowid) {
-        return existing;
+        return { row: existing, columns: [tbl.columns.find((col) => col.primaryKey && col.type.toUpperCase() === "INTEGER")?.name ?? "rowid"] };
       }
       for (const kSet of resolvedKeySets) {
         yield;
@@ -3976,7 +4142,7 @@ var SqliteDatabase = class {
           }
         }
         if (allEqual) {
-          return existing;
+          return { row: existing, columns: kSet.map((key) => key.cKey) };
         }
       }
     }
@@ -4229,8 +4395,9 @@ var SqliteDatabase = class {
       if (!(yield* this.fireTriggers(tbl.name, "BEFORE", "INSERT", void 0, candidate.data))) {
         continue;
       }
-      const conflictRow = yield* this.checkConstraintsAndConflicts(tbl, candidate);
-      if (conflictRow) {
+      const conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate);
+      if (conflict) {
+        const conflictRow = conflict.row;
         if (upsertDoNothing || conflictAction === "IGNORE") {
           continue;
         }
@@ -4282,7 +4449,7 @@ var SqliteDatabase = class {
             yield* this.applyForeignKeyActions(tbl, conflictRow.data);
           }
         } else {
-          throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+          throw new SqliteConstraintError(`UNIQUE constraint failed: ${conflict.columns.map((column) => `${tbl.name}.${column}`).join(", ")}`);
         }
       }
       tbl.rows.push(candidate);
@@ -4315,7 +4482,7 @@ var SqliteDatabase = class {
     let i = 0;
     let whereExpr;
     while (i < tokens.length) {
-      if (tokens[i].value.toUpperCase() === "WHERE" || tokens[i].value.toUpperCase() === "FROM") {
+      if (tokens[i].value.toUpperCase() === "WHERE" || isFromClause(tokens, i)) {
         if (tokens[i].value.toUpperCase() === "WHERE") {
           whereExpr = new ExprParser(tokens.slice(i + 1)).parseExpression();
         }
@@ -4374,7 +4541,7 @@ var SqliteDatabase = class {
           d += 1;
         } else if (t.value === ")") {
           d -= 1;
-        } else if (d === 0 && (t.value === "," || t.value.toUpperCase() === "WHERE" || t.value.toUpperCase() === "FROM")) {
+        } else if (d === 0 && (t.value === "," || t.value.toUpperCase() === "WHERE" || isFromClause(tokens, i))) {
           break;
         }
         exprToks.push(t);
@@ -4395,6 +4562,7 @@ var SqliteDatabase = class {
       bindings[`${tbl.name}.${column}`] = value;
       if (alias) bindings[`${alias}.${column}`] = value;
     }
+    this.rowTables.set(bindings, tbl);
     return bindings;
   }
   *executeUpdate(tokens, positionalParams, _cteScope) {
@@ -4440,7 +4608,7 @@ var SqliteDatabase = class {
       const token = tokens[i].value.toUpperCase();
       if (token === "(") depth += 1;
       else if (token === ")") depth -= 1;
-      else if (depth === 0 && token === "FROM") fromIdx = i;
+      else if (depth === 0 && isFromClause(tokens, i)) fromIdx = i;
       else if (depth === 0 && token === "WHERE") whereIdx = i;
     }
     const setTokens = fromIdx === -1 ? tokens.slice(idx, sliceEnd) : [...tokens.slice(idx, fromIdx), ...tokens.slice(whereIdx, sliceEnd)];
@@ -4486,6 +4654,7 @@ var SqliteDatabase = class {
       for (const other of source.rows) {
         yield;
         const ctx = { ...other, ...target };
+        this.rowTables.set(ctx, tbl);
         if (!whereExpr || isTruthy(yield* this.evalExprSteps(whereExpr, ctx, positionalParams, _cteScope)))
           return [{ row, ctx }];
       }
@@ -4533,10 +4702,10 @@ var SqliteDatabase = class {
       }
       if (conflict && conflictAction === "IGNORE") continue;
       while (conflict) {
-        if (conflictAction !== "REPLACE") throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
-        replacedRows.add(conflict);
-        tbl.rows.splice(tbl.rows.indexOf(conflict), 1);
-        yield* this.applyForeignKeyActions(tbl, conflict.data);
+        if (conflictAction !== "REPLACE") throw new SqliteConstraintError(`UNIQUE constraint failed: ${conflict.columns.map((column) => `${tbl.name}.${column}`).join(", ")}`);
+        replacedRows.add(conflict.row);
+        tbl.rows.splice(tbl.rows.indexOf(conflict.row), 1);
+        yield* this.applyForeignKeyActions(tbl, conflict.row.data);
         conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
       }
       row.data = newData;
@@ -5024,7 +5193,7 @@ var SqliteDatabase = class {
           d -= 1;
         } else if (d === 0 && t.type === "word") {
           const u = t.value.toUpperCase();
-          if (u === "FROM" || u === "WHERE" || u === "HAVING" || u === "WINDOW" || u === "LIMIT") {
+          if (isFromClause(tokens, i) || u === "WHERE" || u === "HAVING" || u === "WINDOW" || u === "LIMIT") {
             clausePositions.push({ name: u, pos: i });
           } else if (u === "GROUP" && tokens[i + 1]?.value.toUpperCase() === "BY") {
             clausePositions.push({ name: "GROUP BY", pos: i });
@@ -5308,7 +5477,7 @@ var SqliteDatabase = class {
     const firstWindow = windowResults.keys().next().value;
     if (!orderByTokens?.length && firstWindow?.kind === "func" && firstWindow.over) {
       const sortSpecs = [
-        ...firstWindow.over.partitionBy.map((expr) => ({ expr, desc: false })),
+        ...firstWindow.over.partitionBy.map((expr) => ({ expr, desc: false, nulls: void 0 })),
         ...firstWindow.over.orderBy
       ];
       if (sortSpecs.length > 0) {
@@ -5321,7 +5490,13 @@ var SqliteDatabase = class {
         yield* stepSort(keyed, function* (a, b) {
           for (let i = 0; i < sortSpecs.length; i++) {
             yield;
-            const cmp = compareSqlValues(a.keys[i], b.keys[i]);
+            const vA = a.keys[i];
+            const vB = b.keys[i];
+            const nulls = sortSpecs[i].nulls;
+            if (nulls && vA === null !== (vB === null)) {
+              return vA === null === (nulls === "FIRST") ? -1 : 1;
+            }
+            const cmp = compareSqlValues(vA, vB);
             if (cmp !== 0) return sortSpecs[i].desc ? -cmp : cmp;
           }
           return 0;
@@ -6194,6 +6369,7 @@ var SqliteDatabase = class {
     const sameAliasAndName = alias.toLowerCase() === name.toLowerCase();
     const rows = yield* stepMap(this.preparing ? [] : tbl.rows, function* (r) {
       yield;
+      this.rowTables.set(r.data, tbl);
       const tablesMap = sameAliasAndName ? { [alias]: r.data } : { [alias]: r.data, [name]: r.data };
       const rowidsMap = sameAliasAndName ? { [alias]: r.rowid } : { [alias]: r.rowid, [name]: r.rowid };
       return {
@@ -6398,6 +6574,9 @@ var SqliteDatabase = class {
             yield;
             const vA = yield* this.evalExprSteps(ob.expr, gA.representative, positionalParams, cteScope, { group: gA.group });
             const vB = yield* this.evalExprSteps(ob.expr, gB.representative, positionalParams, cteScope, { group: gB.group });
+            if (ob.nulls && vA === null !== (vB === null)) {
+              return vA === null === (ob.nulls === "FIRST") ? -1 : 1;
+            }
             const cmp = compareSqlValues(vA, vB);
             if (cmp !== 0) {
               return ob.desc ? -cmp : cmp;
@@ -6994,7 +7173,16 @@ var SqliteDatabase = class {
           return 0;
         }
         const collation = expr.left.kind === "collate" ? expr.left.collation : expr.right.kind === "collate" ? expr.right.collation : "BINARY";
-        const l = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
+        let l = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
+        if (expr.op === "IS" || expr.op === "IS NOT") {
+          let right = expr.right;
+          while (right.kind === "collate") right = right.expr;
+          if (right.kind === "literal" && right.booleanLiteral) {
+            const truth = isTruthy(l instanceof Uint8Array ? toSqlString(l) : l);
+            const matches = l !== null && truth === (right.value === 1);
+            return matches !== (expr.op === "IS NOT") ? 1 : 0;
+          }
+        }
         if ((expr.op === "LIKE" || expr.op === "GLOB") && expr.right.kind === "func" && expr.right.name === "__like_escape__") {
           const pat = yield* this.evalExprSteps(
             expr.right.args[0],
@@ -7015,7 +7203,15 @@ var SqliteDatabase = class {
           }
           return matchLike(toSqlString(l), toSqlString(pat), expr.op === "LIKE", toSqlString(esc)) ? 1 : 0;
         }
-        const r = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
+        let r = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
+        if (["=", "==", "!=", "<>", "<", "<=", ">", ">=", "IS", "IS NOT"].includes(expr.op)) {
+          const leftAffinity = this.expressionAffinity(expr.left, row);
+          const rightAffinity = this.expressionAffinity(expr.right, row);
+          if (leftAffinity === "NUMERIC" && rightAffinity !== "NUMERIC") r = applyColumnAffinity(r, "NUMERIC", false);
+          else if (rightAffinity === "NUMERIC" && leftAffinity !== "NUMERIC") l = applyColumnAffinity(l, "NUMERIC", false);
+          else if (leftAffinity === "TEXT" && rightAffinity === void 0) r = applyColumnAffinity(r, "TEXT", false);
+          else if (rightAffinity === "TEXT" && leftAffinity === void 0) l = applyColumnAffinity(l, "TEXT", false);
+        }
         return this.applyBinary(expr.op, l, r, collation);
       }
       case "between": {
@@ -7138,10 +7334,10 @@ var SqliteDatabase = class {
             yield* this.evalExprSteps(expr.args[1], row, positionalParams, cteScope, evaluation)
           ) : mode;
           if (mode === "ROLLBACK" && this.inTransaction) {
-            if (this.txSnapshot) {
-              yield* this.restoreSnapshot(this.txSnapshot);
+            const snapshot = this.txSnapshot ?? this.savepoints.values().next().value;
+            if (snapshot) {
+              yield* this.restoreSnapshot(snapshot);
             }
-            this.inTransaction = false;
             this.txSnapshot = null;
             this.savepoints.clear();
           }
@@ -7174,6 +7370,31 @@ var SqliteDatabase = class {
       }
     }
   }
+  expressionAffinity(expr, row) {
+    if (expr.kind === "collate") return this.expressionAffinity(expr.expr, row);
+    let type;
+    if (expr.kind === "cast") {
+      type = expr.targetType;
+    } else if (expr.kind === "column") {
+      for (const scope of [row, ...this.outerRows.slice().reverse()]) {
+        const tables = scope.__tables;
+        const sources = expr.table ? Object.entries(tables ?? {}).filter(([name]) => name.toLowerCase() === expr.table.toLowerCase()).map(([, data]) => data) : scope.__sources ?? [];
+        for (const source of this.rowTables.has(scope) || sources.length === 0 ? [scope, ...sources] : sources) {
+          const key = expr.table && source === scope ? `${expr.table}.${expr.name}` : expr.name;
+          if (!Object.keys(source).some((name) => name.toLowerCase() === key.toLowerCase())) continue;
+          const table = this.rowTables.get(source);
+          const column = table?.columns.find((column2) => column2.name.toLowerCase() === expr.name.toLowerCase());
+          type = column?.type;
+          if (!column && table && ["rowid", "_rowid_", "oid"].includes(expr.name.toLowerCase())) type = "INTEGER";
+          break;
+        }
+        if (type !== void 0) break;
+      }
+    }
+    if (type === void 0) return void 0;
+    const affinity = columnAffinity(type);
+    return affinity === "BLOB" ? void 0 : affinity === "TEXT" ? "TEXT" : "NUMERIC";
+  }
   applyUnary(op, v) {
     if (op === "NOT") {
       if (v === null) {
@@ -7260,10 +7481,10 @@ var SqliteDatabase = class {
         return integerResult(BigInt.asIntN(64, integerPrefix(l) | integerPrefix(r)));
       case "=":
       case "==":
-        return sqlEquals(l, r, collation) ? 1 : 0;
+        return compareSqlValues(l, r, collation) === 0 ? 1 : 0;
       case "!=":
       case "<>":
-        return sqlEquals(l, r, collation) ? 0 : 1;
+        return compareSqlValues(l, r, collation) !== 0 ? 1 : 0;
       case "<":
         return compareSqlValues(l, r, collation) < 0 ? 1 : 0;
       case "<=":
@@ -8024,8 +8245,10 @@ function* jsonString(parts) {
 function* jsonValue(value) {
   if (value instanceof JsonText) yield* textParts(value.valueOf());
   else if (typeof value === "string" || value instanceof String || value instanceof Uint8Array) yield* jsonString(cellParts(value, ""));
-  else if (value instanceof Number) yield Number.isFinite(value.valueOf()) ? toSqlString(value) : "null";
-  else if (typeof value === "bigint") yield value.toString();
+  else if (value instanceof Number || typeof value === "number" && !Number.isInteger(value)) {
+    const number = value.valueOf();
+    yield Number.isFinite(number) ? formatReal(number, 20) : "null";
+  } else if (typeof value === "bigint") yield value.toString();
   else yield JSON.stringify(value ?? null);
 }
 function* formatQueryParts({ columns, rows }, state) {
@@ -9341,13 +9564,14 @@ Options:
               } catch (err) {
                 context.signal.throwIfAborted();
                 const msg = err instanceof Error ? err.message : String(err);
-                await writeText(context.stderr, `Error: ${msg}
+                const constraint = err instanceof SqliteConstraintError;
+                await writeText(context.stderr, constraint ? `Error: stepping, ${msg} (${err.code})
+` : `Error: ${msg}
 `);
+                state.exitCode = constraint ? err.code : 1;
                 if (state.bail || positional.length >= 2) {
-                  state.exitCode = 1;
                   return false;
                 }
-                state.exitCode = 1;
               }
               if (state.exitRequested) {
                 return false;
@@ -9415,6 +9639,7 @@ Options:
           }
         }
         if (!limitExceeded && state.dirty && state.dbPath !== ":memory:" && !state.readonly) {
+          if (db.inTransaction) await execSingleStmt("ROLLBACK");
           await saveDbToDisk(state.dbPath);
         }
         return { exitCode: limitExceeded ? 1 : state.exitCode };
@@ -9922,6 +10147,7 @@ Options:
       if (!writeFileSync || !writeFileSync(save.file, save.bytes)) return void 0;
     }
     if (state.dirty && state.dbPath !== ":memory:") {
+      if (db.inTransaction) db.executeStatement("ROLLBACK");
       if (!writeFileSync || !writeFileSync(state.dbPath, db.serializeToBytes())) return void 0;
     }
     return out;