@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -340,10 +340,10 @@ function decodeRecord(payload) {
   }
   return values;
 }
-function extractLeafCellPayload(dbBytes, pageSize, cellBytes, payloadSize) {
+function extractLeafCellPayload(dbBytes, pageSize, cellBytes, payloadSize, index = false) {
   const reservedSpace = dbBytes[20] ?? 0;
   const usableSize = Math.max(480, pageSize - reservedSpace);
-  const maxLocal = usableSize - 35;
+  const maxLocal = index ? Math.floor((usableSize - 12) * 64 / 255) - 23 : usableSize - 35;
   const minLocal = Math.floor((usableSize - 12) * 32 / 255) - 23;
   if (payloadSize <= maxLocal) {
     return cellBytes.subarray(0, payloadSize);
@@ -380,7 +380,32 @@ function parseTableBTreeRows(dbBytes, pageSize, pageNumber, visited = /* @__PURE
   const pageType = dbBytes[pageStart + headerOffset] ?? 0;
   const cellCount = readU16BE(dbBytes, pageStart + headerOffset + 3);
   const rows = [];
-  if (pageType === 13) {
+  if (pageType === 10 || pageType === 2) {
+    const interior = pageType === 2;
+    const ptrArrayOffset = pageStart + headerOffset + (interior ? 12 : 8);
+    for (let i = 0; i < cellCount; i++) {
+      let offset = pageStart + readU16BE(dbBytes, ptrArrayOffset + i * 2);
+      if (interior) {
+        rows.push(...parseTableBTreeRows(dbBytes, pageSize, readU32BE(dbBytes, offset), visited));
+        offset += 4;
+      }
+      const size = readVarint(dbBytes, offset);
+      const payload = extractLeafCellPayload(
+        dbBytes,
+        pageSize,
+        dbBytes.subarray(offset + size.length, pageStart + pageSize),
+        size.value,
+        true
+      );
+      rows.push({ rowid: rows.length + 1, values: decodeRecord(payload) });
+    }
+    if (interior) rows.push(...parseTableBTreeRows(
+      dbBytes,
+      pageSize,
+      readU32BE(dbBytes, pageStart + headerOffset + 8),
+      visited
+    ));
+  } else if (pageType === 13) {
     const ptrArrayOffset = pageStart + headerOffset + 8;
     for (let i = 0; i < cellCount; i += 1) {
       const cellOffsetInPage = readU16BE(dbBytes, ptrArrayOffset + i * 2);
@@ -395,7 +420,7 @@ function parseTableBTreeRows(dbBytes, pageSize, pageNumber, visited = /* @__PURE
         pSize.value
       );
       rows.push({
-        rowid: rId.value,
+        rowid: rId.length === 9 ? Number(BigInt.asIntN(64, Array.from(dbBytes.subarray(absOffset + pSize.length, absOffset + pSize.length + 9)).reduce((value, byte, i2) => value << BigInt(i2 === 8 ? 8 : 7) | BigInt(i2 === 8 ? byte : byte & 127), 0n))) : rId.value,
         values: decodeRecord(payload)
       });
     }
@@ -503,7 +528,7 @@ function buildTablePages(rows, startPageNumber, isPageOne) {
     writeU32BE(cell, pSizeVar.byteLength + rIdVar.byteLength + localSize, firstOverflowPageNum);
     return cell;
   };
-  const encodedCells = rows.map((r) => ({
+  const encodedCells = [...rows].sort((a, b) => a.rowid - b.rowid).map((r) => ({
     rowid: r.rowid,
     cell: encodeCellWithOverflow(r.rowid, r.values)
   }));
@@ -595,7 +620,7 @@ function compareSqlValuesForBTree(a, b) {
   }
   return ba.byteLength - bb.byteLength;
 }
-function buildIndexPages(entries, startPageNumber) {
+function buildIndexPages(entries, startPageNumber, presorted = false) {
   const pageSize = DEFAULT_PAGE_SIZE;
   const pages = [];
   const rootPageNum = startPageNumber;
@@ -605,7 +630,7 @@ function buildIndexPages(entries, startPageNumber) {
     pages.push(buf);
     return { pageNum: startPageNumber + pages.length - 1, buf };
   };
-  const sorted = [...entries].sort((r1, r2) => {
+  const sorted = presorted ? entries : [...entries].sort((r1, r2) => {
     const len = Math.min(r1.length, r2.length);
     for (let i = 0; i < len; i += 1) {
       const c = compareSqlValuesForBTree(r1[i] ?? null, r2[i] ?? null);
@@ -650,40 +675,51 @@ function buildIndexPages(entries, startPageNumber) {
     return cell;
   };
   const encodedCells = sorted.map((vals) => encodeIndexCell(vals));
-  const maxRootSpace = pageSize - 8;
-  const totalRootBytes = encodedCells.reduce((sum, c) => sum + c.byteLength + 2, 0);
-  if (totalRootBytes <= maxRootSpace) {
-    const rootBuf2 = pages[0];
-    rootBuf2[0] = 10;
-    writeU16BE(rootBuf2, 1, 0);
-    writeU16BE(rootBuf2, 3, encodedCells.length);
-    let contentOffset2 = pageSize;
-    for (let i = 0; i < encodedCells.length; i += 1) {
-      const c = encodedCells[i];
-      contentOffset2 -= c.byteLength;
-      rootBuf2.set(c, contentOffset2);
-      writeU16BE(rootBuf2, 8 + i * 2, contentOffset2);
-    }
-    writeU16BE(rootBuf2, 5, contentOffset2 === pageSize ? 0 : contentOffset2);
-    return { rootPage: rootPageNum, pages };
-  }
-  const rootBuf = pages[0];
-  rootBuf[0] = 10;
-  writeU16BE(rootBuf, 1, 0);
-  let contentOffset = pageSize;
-  let count = 0;
-  for (let i = 0; i < encodedCells.length; i += 1) {
-    const c = encodedCells[i];
-    if (contentOffset - (c.byteLength + 2) < 8 + (count + 1) * 2) {
+  const writeNode = (buf, cells2, children2) => {
+    const interior = children2.length > 0;
+    const header = interior ? 12 : 8;
+    buf[0] = interior ? 2 : 10;
+    writeU16BE(buf, 3, cells2.length);
+    if (interior) writeU32BE(buf, 8, children2[children2.length - 1]);
+    let offset = pageSize;
+    for (let i = 0; i < cells2.length; i++) {
+      const cell = cells2[i];
+      offset -= cell.length + (interior ? 4 : 0);
+      if (interior) writeU32BE(buf, offset, children2[i]);
+      buf.set(cell, offset + (interior ? 4 : 0));
+      writeU16BE(buf, header + i * 2, offset);
+    }
+    writeU16BE(buf, 5, offset);
+  };
+  let cells = encodedCells;
+  let children = [];
+  while (true) {
+    const overhead = children.length ? 6 : 2;
+    const header = children.length ? 12 : 8;
+    if (cells.reduce((size, cell) => size + cell.length + overhead, header) <= pageSize) {
+      writeNode(pages[0], cells, children);
       break;
     }
-    contentOffset -= c.byteLength;
-    rootBuf.set(c, contentOffset);
-    writeU16BE(rootBuf, 8 + count * 2, contentOffset);
-    count += 1;
+    const separators = [];
+    const nextChildren = [];
+    let start = 0;
+    while (start <= cells.length) {
+      let end = start;
+      let size = header;
+      while (end < cells.length && size + cells[end].length + overhead <= pageSize) {
+        size += cells[end].length + overhead;
+        end++;
+      }
+      const { pageNum, buf } = allocatePage();
+      writeNode(buf, cells.slice(start, end), children.length ? children.slice(start, end + 1) : []);
+      nextChildren.push(pageNum);
+      if (end === cells.length) break;
+      separators.push(cells[end]);
+      start = end + 1;
+    }
+    cells = separators;
+    children = nextChildren;
   }
-  writeU16BE(rootBuf, 3, count);
-  writeU16BE(rootBuf, 5, contentOffset === pageSize ? 0 : contentOffset);
   return { rootPage: rootPageNum, pages };
 }
 function writeSqliteDatabaseBytes(image) {
@@ -694,7 +730,7 @@ function writeSqliteDatabaseBytes(image) {
   for (const item of image.master) {
     if (item.type === "table") {
       const rows = image.tableRows.get(item.name) ?? [];
-      const built = buildTablePages(rows, nextPageNumber, false);
+      const built = item.withoutRowId ? buildIndexPages(rows.map((row) => row.values), nextPageNumber, true) : buildTablePages(rows, nextPageNumber, false);
       extraPageChunks.push(...built.pages);
       nextPageNumber += built.pages.length;
       masterEntries.push({
@@ -735,7 +771,7 @@ function writeSqliteDatabaseBytes(image) {
     for (const item of image.master) {
       if (item.type === "table") {
         const rows = image.tableRows.get(item.name) ?? [];
-        const built = buildTablePages(rows, pNum, false);
+        const built = item.withoutRowId ? buildIndexPages(rows.map((row) => row.values), pNum, true) : buildTablePages(rows, pNum, false);
         reExtraChunks.push(...built.pages);
         pNum += built.pages.length;
         reMasterEntries.push({ ...item, rootpage: built.rootPage });
@@ -803,8 +839,18 @@ function serializeSqlJson(value, preserveRealType = true) {
 }
 var JsonText = class extends String {
 };
+function tableStorageColumns(table) {
+  if (!table.withoutRowId) return table.columns;
+  const keys = table.primaryKeyCols.map((name) => name.toLowerCase());
+  return [
+    ...keys.map((name) => table.columns.find((column) => column.name.toLowerCase() === name)),
+    ...table.columns.filter((column) => !keys.includes(column.name.toLowerCase()))
+  ];
+}
 var textEncoder2 = new TextEncoder();
 var textDecoder2 = new TextDecoder("utf-8", { fatal: false });
+var SqliteConstraintError = class extends Error {
+};
 function cloneSqlValue(v) {
   if (v instanceof Uint8Array) {
     return new Uint8Array(v);
@@ -831,6 +877,7 @@ function cloneTableDef(t) {
     withoutRowId: t.withoutRowId,
     strict: t.strict,
     primaryKeyCols: [...t.primaryKeyCols],
+    primaryKeyOrder: t.primaryKeyOrder?.map((key) => ({ ...key })),
     uniqueColSets: t.uniqueColSets.map((u) => [...u])
   };
 }
@@ -1073,6 +1120,37 @@ function tokenizeSql(sql) {
   }
   return tokens;
 }
+function isAggregateFunction(expr) {
+  if (expr.kind !== "func" || expr.over) return false;
+  const name = expr.name.toUpperCase();
+  return ["COUNT", "SUM", "TOTAL", "AVG", "MIN", "MAX", "GROUP_CONCAT", "STRING_AGG", "JSON_GROUP_ARRAY", "JSON_GROUP_OBJECT"].includes(name) && !((name === "MIN" || name === "MAX") && expr.args.length > 1);
+}
+function expressionChildren(expr) {
+  switch (expr.kind) {
+    case "unary":
+    case "collate":
+    case "is_null":
+    case "cast":
+    case "in_subquery":
+      return [expr.expr];
+    case "binary":
+      return [expr.left, expr.right];
+    case "between":
+      return [expr.expr, expr.low, expr.high];
+    case "in_list":
+      return [expr.expr, ...expr.list];
+    case "func":
+      return expr.args;
+    case "case":
+      return [
+        ...expr.base ? [expr.base] : [],
+        ...expr.branches.flatMap((branch) => [branch.when, branch.then]),
+        ...expr.elseExpr ? [expr.elseExpr] : []
+      ];
+    default:
+      return [];
+  }
+}
 function reconstructTokensSql(tokens) {
   let out = "";
   for (let i = 0; i < tokens.length; i += 1) {
@@ -2209,11 +2287,12 @@ var SqliteDatabase = class {
       }
       tbl.rows = [];
       let maxRowid = 0;
+      const storageColumns = tableStorageColumns(tbl);
       for (const r of rawRows) {
         yield;
         const data = {};
         let valIdx = 0;
-        for (const col of tbl.columns) {
+        for (const col of storageColumns) {
           yield;
           if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1) {
             const cellVal = r.values[valIdx];
@@ -2282,7 +2361,8 @@ var SqliteDatabase = class {
         name: tbl.name,
         tbl_name: tbl.name,
         rootpage: rootPageCounter++,
-        sql: tbl.sql
+        sql: tbl.sql,
+        withoutRowId: tbl.withoutRowId
       });
       if (tbl.columns.some((c) => {
         return c.autoIncrement;
@@ -2299,11 +2379,26 @@ var SqliteDatabase = class {
           });
         }
       }
-      const rows = yield* stepMap(tbl.rows, function* (r) {
+      const storageColumns = tableStorageColumns(tbl);
+      const orderedRows = tbl.withoutRowId ? yield* stepSort([...tbl.rows], function* (left, right) {
+        for (let i = 0; i < tbl.primaryKeyCols.length; i++) {
+          yield;
+          const column = storageColumns[i];
+          const order = tbl.primaryKeyOrder?.[i];
+          const comparison = compareSqlValues(
+            left.data[column.name] ?? null,
+            right.data[column.name] ?? null,
+            order?.collation ?? column.collate ?? "BINARY"
+          );
+          if (comparison) return order?.desc ? -comparison : comparison;
+        }
+        return 0;
+      }, this) : tbl.rows;
+      const rows = yield* stepMap(orderedRows, function* (r) {
         yield;
         return {
           rowid: r.rowid,
-          values: tbl.columns.map((c) => {
+          values: storageColumns.map((c) => {
             const isRowidAlias = c.primaryKey && c.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId && tbl.primaryKeyCols.length === 1;
             return isRowidAlias ? null : r.data[c.name] ?? null;
           })
@@ -2774,6 +2869,7 @@ var SqliteDatabase = class {
       const strict = trailingTokens.includes("STRICT");
       const columns = [];
       const primaryKeyCols = [];
+      const primaryKeyOrder = [];
       const uniqueColSets = [];
       for (const part of bodyParts) {
         yield;
@@ -2791,11 +2887,19 @@ var SqliteDatabase = class {
             pIdx += 1;
             while (pIdx < part.length && part[pIdx]?.value !== ")") {
               yield;
-              const colName = part[pIdx].value;
-              if (colName !== "," && colName.toUpperCase() !== "ASC" && colName.toUpperCase() !== "DESC") {
-                primaryKeyCols.push(colName);
+              if (part[pIdx].value === ",") {
+                pIdx++;
+                continue;
               }
-              pIdx += 1;
+              primaryKeyCols.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();
+              primaryKeyOrder.push({ desc: direction === "DESC", collation });
+              if (direction === "ASC" || direction === "DESC") pIdx++;
             }
           }
           continue;
@@ -2826,6 +2930,8 @@ var SqliteDatabase = class {
         columns.push(colDef);
         if (colDef.primaryKey && !primaryKeyCols.includes(colDef.name)) {
           primaryKeyCols.push(colDef.name);
+          const primaryIndex = part.findIndex((token) => token.type === "word" && token.value.toUpperCase() === "PRIMARY");
+          primaryKeyOrder.push({ desc: part[primaryIndex + 2]?.value.toUpperCase() === "DESC", collation: colDef.collate });
         }
         if (colDef.unique) {
           uniqueColSets.push([colDef.name]);
@@ -2849,6 +2955,7 @@ var SqliteDatabase = class {
         withoutRowId,
         strict,
         primaryKeyCols,
+        primaryKeyOrder,
         uniqueColSets
       });
       return;
@@ -2864,32 +2971,55 @@ var SqliteDatabase = class {
         return i >= idx && t.value.toUpperCase() === "ON";
       });
       const tableName = tokens[onIdx + 1]?.value ?? "";
+      const tbl = this.findTable(tableName);
+      if (!tbl) throw new Error(`no such table: ${tableName}`);
       const cols = [];
+      const collations = [];
       let p = onIdx + 2;
-      if (tokens[p]?.value === "(") {
-        p += 1;
-        while (p < tokens.length && tokens[p]?.value !== ")") {
-          yield;
-          const v = tokens[p].value;
-          if (v !== "," && v.toUpperCase() !== "ASC" && v.toUpperCase() !== "DESC" && v.toUpperCase() !== "COLLATE") {
-            cols.push(v);
-          }
-          p += 1;
-        }
+      if (tokens[p++]?.value !== "(") throw new Error("expected index columns");
+      while (p < tokens.length && tokens[p]?.value !== ")") {
+        yield;
+        const name = tokens[p++].value;
+        const column = tbl.columns.find((col) => col.name.toLowerCase() === name.toLowerCase());
+        if (!column) throw new Error(`no such column: ${name}`);
+        cols.push(column.name);
+        let collation = column.collate ?? "BINARY";
+        if (tokens[p]?.value.toUpperCase() === "COLLATE") {
+          p++;
+          collation = tokens[p++]?.value.toUpperCase() ?? "";
+          if (!["BINARY", "NOCASE", "RTRIM"].includes(collation)) throw new Error(`no such collation sequence: ${collation}`);
+        }
+        collations.push(collation);
+        if (["ASC", "DESC"].includes(tokens[p]?.value.toUpperCase() ?? "")) p++;
+        if (tokens[p]?.value === ",") p++;
+        else if (tokens[p]?.value !== ")") throw new Error("expected index column separator");
       }
-      this.indexes.set(objName, {
-        name: objName,
-        tableName,
-        unique,
-        columns: cols,
-        sql
-      });
       if (unique) {
-        const tbl = this.findTable(tableName);
-        if (tbl && cols.length > 0) {
-          tbl.uniqueColSets.push(cols);
+        const keys = [];
+        for (const row of tbl.rows) {
+          const key = [];
+          for (const col of cols) {
+            yield;
+            const value = row.data[col] ?? null;
+            if (value === null) break;
+            key.push(value);
+          }
+          if (key.length === cols.length) keys.push(key);
+        }
+        function* compareKeys(left, right) {
+          for (let c = 0; c < cols.length; c++) {
+            yield;
+            const order = compareSqlValues(left[c], right[c], collations[c]);
+            if (order !== 0) return order;
+          }
+          return 0;
+        }
+        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}`);
         }
       }
+      this.indexes.set(objName, { name: objName, tableName: tbl.name, unique, columns: cols, collations, sql });
       return;
     }
     if (kind === "VIEW") {
@@ -3358,21 +3488,25 @@ var SqliteDatabase = class {
     }
     return `X'${hex}'`;
   }
-  *checkConstraintsAndConflicts(tbl, candidate, excludeRowid) {
+  *checkConstraintsAndConflicts(tbl, candidate, excludeRowid, replaceNotNull = false) {
     for (const col of tbl.columns) {
       yield;
-      const val = candidate.data[col.name] ?? null;
+      let val = candidate.data[col.name] ?? null;
+      if (replaceNotNull && col.notNull && val === null && col.defaultExpr) {
+        val = applyColumnAffinity(yield* this.evalScalarSql(col.defaultExpr, {}, []), col.type);
+        candidate.data[col.name] = val;
+      }
       if (col.notNull && val === null) {
         if (col.primaryKey && col.type.toUpperCase() === "INTEGER" && !tbl.withoutRowId) {
           candidate.data[col.name] = candidate.rowid;
         } else {
-          throw new Error(`NOT NULL constraint failed: ${tbl.name}.${col.name}`);
+          throw new SqliteConstraintError(`NOT NULL constraint failed: ${tbl.name}.${col.name}`);
         }
       }
       if (col.checkExpr && val !== null) {
         const ok = yield* this.evalExprSteps(parseExprSql(col.checkExpr), candidate.data, []);
         if (ok !== null && !isTruthy(ok)) {
-          throw new Error(`CHECK constraint failed: ${col.checkExpr}`);
+          throw new SqliteConstraintError(`CHECK constraint failed: ${col.checkExpr}`);
         }
       }
     }
@@ -3384,9 +3518,6 @@ var SqliteDatabase = class {
       yield;
       keySets.push(u);
     }
-    if (keySets.length === 0 && candidate.rowid >= tbl.nextRowId) {
-      return null;
-    }
     const resolvedKeySets = yield* stepMap(keySets, function* (kSet) {
       yield;
       return kSet.map((colName) => {
@@ -3396,6 +3527,12 @@ var SqliteDatabase = class {
         return { cKey: realCol ? realCol.name : colName, collate: realCol?.collate ?? "BINARY" };
       });
     }, this);
+    for (const index of this.indexes.values()) {
+      yield;
+      if (index.unique && index.tableName.toLowerCase() === tbl.name.toLowerCase()) {
+        resolvedKeySets.push(index.columns.map((cKey, i) => ({ cKey, collate: index.collations?.[i] ?? tbl.columns.find((col) => col.name === cKey)?.collate ?? "BINARY" })));
+      }
+    }
     for (const existing of tbl.rows) {
       yield;
       if (excludeRowid !== void 0 && existing.rowid === excludeRowid) {
@@ -3423,6 +3560,23 @@ var SqliteDatabase = class {
     }
     return null;
   }
+  synchronizeRowid(tbl, candidate, assigned) {
+    if (tbl.withoutRowId) return;
+    const primary = tbl.columns.find((col) => col.primaryKey && col.type.toUpperCase() === "INTEGER" && tbl.primaryKeyCols.length === 1);
+    for (const name of assigned) {
+      const column = tbl.columns.find((col) => col.name.toLowerCase() === name.toLowerCase());
+      if (column ? column !== primary : !["rowid", "_rowid_", "oid"].includes(name.toLowerCase())) continue;
+      const key = column?.name ?? name;
+      const value = candidate.data[key];
+      if (value !== null && value !== void 0) {
+        const number = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+        if (typeof number !== "number" || !Number.isSafeInteger(number)) throw new Error("datatype mismatch");
+        candidate.rowid = number;
+      }
+      if (!column) delete candidate.data[key];
+    }
+    if (primary) candidate.data[primary.name] = candidate.rowid;
+  }
   *executeInsert(_sql, tokens, positionalParams, cteScope) {
     let idx = 0;
     let conflictAction = "ABORT";
@@ -3647,6 +3801,8 @@ var SqliteDatabase = class {
         }
       }
       const candidate = { rowid, data };
+      this.synchronizeRowid(tbl, candidate, targetCols);
+      rowid = candidate.rowid;
       yield* this.fireTriggers(tbl.name, "BEFORE", "INSERT", void 0, candidate.data);
       const conflictRow = yield* this.checkConstraintsAndConflicts(tbl, candidate);
       if (conflictRow) {
@@ -3808,7 +3964,9 @@ var SqliteDatabase = class {
   }
   *executeUpdate(tokens, positionalParams, _cteScope) {
     let idx = 1;
+    let conflictAction = "ABORT";
     if (tokens[idx]?.value.toUpperCase() === "OR") {
+      conflictAction = tokens[idx + 1]?.value.toUpperCase() ?? "ABORT";
       idx += 2;
     }
     if (tokens[idx + 1]?.value === ".") {
@@ -3898,8 +4056,10 @@ var SqliteDatabase = class {
       }
       return [];
     }, this);
+    const replacedRows = /* @__PURE__ */ new Set();
     for (const { row, ctx } of matches) {
       yield;
+      if (replacedRows.has(row)) continue;
       const oldData = { ...row.data };
       const newData = { ...row.data };
       for (const assign of assignments) {
@@ -3924,11 +4084,25 @@ var SqliteDatabase = class {
       }
       yield* this.fireTriggers(tbl.name, "BEFORE", "UPDATE", oldData, newData);
       const candidate = { rowid: row.rowid, data: newData };
-      const conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
-      if (conflict) {
-        throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
+      this.synchronizeRowid(tbl, candidate, assignments.map((assignment) => assignment.col));
+      let conflict;
+      try {
+        conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid, conflictAction === "REPLACE");
+      } catch (error) {
+        if (conflictAction === "IGNORE" && error instanceof SqliteConstraintError) continue;
+        throw error;
+      }
+      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);
+        conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
       }
       row.data = newData;
+      row.rowid = candidate.rowid;
+      tbl.nextRowId = Math.max(tbl.nextRowId, row.rowid + 1);
+      tbl.maxAutoInc = Math.max(tbl.maxAutoInc, row.rowid);
       updated += 1;
       affectedRows.push(row);
       yield* this.fireTriggers(tbl.name, "AFTER", "UPDATE", oldData, newData);
@@ -4481,8 +4655,9 @@ var SqliteDatabase = class {
             yield;
             for (const col of src.columns) {
               yield;
+              if (src.hidden?.has(col.toLowerCase())) continue;
               selectTargets.push({
-                expr: { kind: "column", table: src.tableAlias || void 0, name: col },
+                expr: { kind: "column", table: src.shared?.has(col.toLowerCase()) ? void 0 : src.tableAlias || void 0, name: col },
                 alias: col
               });
             }
@@ -4623,17 +4798,11 @@ var SqliteDatabase = class {
           for (const st of selectTargets) {
             yield;
             if (!(st.alias in repCtx)) {
-              repCtx[st.alias] = yield* this.evalExprWithAgg(
-                st.expr,
-                g.representative,
-                g.group,
-                positionalParams,
-                cteScope
-              );
+              repCtx[st.alias] = yield* this.evalExprSteps(st.expr, g.representative, positionalParams, cteScope, { group: g.group });
             }
           }
           return isTruthy(
-            yield* this.evalExprWithAgg(havingExpr, repCtx, g.group, positionalParams, cteScope)
+            yield* this.evalExprSteps(havingExpr, repCtx, positionalParams, cteScope, { group: g.group })
           );
         }, this);
       }
@@ -4654,17 +4823,15 @@ var SqliteDatabase = class {
         windowResults
       );
     }
-    const projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
+    let projected = yield* stepMap(groupedRows, function* (g, rowIdx) {
       const repCtx = { ...g.representative };
       const values = yield* stepMap(selectTargets, function* (st) {
-        const val = yield* this.evalExprWithAggAndWindow(
+        const val = yield* this.evalExprSteps(
           st.expr,
           repCtx,
-          g.group,
-          rowIdx,
-          windowResults,
           positionalParams,
-          cteScope
+          cteScope,
+          { group: g.group, window: { rowIdx, results: windowResults } }
         );
         if (!(st.alias in repCtx)) {
           repCtx[st.alias] = val;
@@ -4673,6 +4840,33 @@ var SqliteDatabase = class {
       }, this);
       return { values, ctx: repCtx, group: g.group };
     }, this);
+    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.orderBy
+      ];
+      if (sortSpecs.length > 0) {
+        const keyed = yield* stepMap(projected, function* (row) {
+          const keys = yield* stepMap(sortSpecs, function* (spec) {
+            return yield* this.evalExprSteps(spec.expr, row.ctx, positionalParams, cteScope, { group: row.group });
+          }, this);
+          return { row, keys };
+        }, this);
+        yield* stepSort(keyed, function* (a, b) {
+          for (let i = 0; i < sortSpecs.length; i++) {
+            yield;
+            const cmp = compareSqlValues(a.keys[i], b.keys[i]);
+            if (cmp !== 0) return sortSpecs[i].desc ? -cmp : cmp;
+          }
+          return 0;
+        }, this);
+        projected = yield* stepMap(keyed, function* (entry) {
+          yield;
+          return entry.row;
+        }, this);
+      }
+    }
     let finalProjected = projected;
     if (distinct) {
       const seen = /* @__PURE__ */ new Set();
@@ -4720,20 +4914,8 @@ var SqliteDatabase = class {
             vA = a.values[colIdx] ?? null;
             vB = b.values[colIdx] ?? null;
           } else {
-            vA = yield* this.evalExprWithAgg(
-              spec.expr,
-              a.ctx,
-              a.group,
-              positionalParams,
-              cteScope
-            );
-            vB = yield* this.evalExprWithAgg(
-              spec.expr,
-              b.ctx,
-              b.group,
-              positionalParams,
-              cteScope
-            );
+            vA = yield* this.evalExprSteps(spec.expr, a.ctx, positionalParams, cteScope, { group: a.group });
+            vB = yield* this.evalExprSteps(spec.expr, b.ctx, positionalParams, cteScope, { group: b.group });
           }
           if (vA === null && vB === null) {
             continue;
@@ -4996,6 +5178,13 @@ var SqliteDatabase = class {
         yield;
         return prevCols.has(c.toLowerCase());
       }, this) : item.usingCols;
+      if (usingList) {
+        const shared = new Set(usingList.map((column) => column.toLowerCase()));
+        schema[schema.length - 1].hidden = shared;
+        for (const source of schema) {
+          source.shared = /* @__PURE__ */ new Set([...source.shared ?? [], ...shared]);
+        }
+      }
       const rightMatched = /* @__PURE__ */ new Set();
       for (const leftRow of currentRows) {
         yield;
@@ -5509,85 +5698,17 @@ var SqliteDatabase = class {
     return { expr, alias };
   }
   containsAggregate(expr) {
-    if (expr.kind === "func") {
-      if (expr.over) {
-        return false;
-      }
-      const u = expr.name.toUpperCase();
-      if ([
-        "COUNT",
-        "SUM",
-        "TOTAL",
-        "AVG",
-        "MIN",
-        "MAX",
-        "GROUP_CONCAT",
-        "STRING_AGG",
-        "JSON_GROUP_ARRAY",
-        "JSON_GROUP_OBJECT"
-      ].includes(u)) {
-        if ((u === "MIN" || u === "MAX") && expr.args.length > 1) {
-          return expr.args.some((a) => this.containsAggregate(a));
-        }
-        return true;
-      }
-      return expr.args.some((a) => this.containsAggregate(a));
-    }
-    if (expr.kind === "unary") {
-      return this.containsAggregate(expr.expr);
-    }
-    if (expr.kind === "binary") {
-      return this.containsAggregate(expr.left) || this.containsAggregate(expr.right);
-    }
-    if (expr.kind === "case") {
-      return (expr.base ? this.containsAggregate(expr.base) : false) || expr.branches.some((b) => this.containsAggregate(b.when) || this.containsAggregate(b.then)) || (expr.elseExpr ? this.containsAggregate(expr.elseExpr) : false);
-    }
-    if (expr.kind === "cast") {
-      return this.containsAggregate(expr.expr);
-    }
-    return false;
+    if (expr.kind === "func" && expr.over) return false;
+    return isAggregateFunction(expr) || expressionChildren(expr).some((child) => this.containsAggregate(child));
   }
   *collectWindowExprs(expr, groupedRows, positionalParams, cteScope, out) {
     if (expr.kind === "func" && expr.over) {
-      const values = yield* this.evaluateWindowFunc(
-        expr,
-        groupedRows,
-        positionalParams,
-        cteScope
-      );
-      out.set(expr, values);
+      out.set(expr, yield* this.evaluateWindowFunc(expr, groupedRows, positionalParams, cteScope));
       return;
     }
-    if (expr.kind === "unary") {
-      yield* this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
-    } else if (expr.kind === "binary") {
-      yield* this.collectWindowExprs(expr.left, groupedRows, positionalParams, cteScope, out);
-      yield* this.collectWindowExprs(expr.right, groupedRows, positionalParams, cteScope, out);
-    } else if (expr.kind === "func") {
-      for (const a of expr.args) {
-        yield;
-        yield* this.collectWindowExprs(a, groupedRows, positionalParams, cteScope, out);
-      }
-    } else if (expr.kind === "case") {
-      if (expr.base) {
-        yield* this.collectWindowExprs(expr.base, groupedRows, positionalParams, cteScope, out);
-      }
-      for (const b of expr.branches) {
-        yield;
-        yield* this.collectWindowExprs(b.when, groupedRows, positionalParams, cteScope, out);
-        yield* this.collectWindowExprs(b.then, groupedRows, positionalParams, cteScope, out);
-      }
-      if (expr.elseExpr) {
-        yield* this.collectWindowExprs(
-          expr.elseExpr,
-          groupedRows,
-          positionalParams,
-          cteScope,
-          out
-        );
-      }
-    } else if (expr.kind === "cast") {
-      yield* this.collectWindowExprs(expr.expr, groupedRows, positionalParams, cteScope, out);
+    for (const child of expressionChildren(expr)) {
+      yield;
+      yield* this.collectWindowExprs(child, groupedRows, positionalParams, cteScope, out);
     }
   }
   *evaluateWindowFunc(fnExpr, groupedRows, positionalParams, cteScope) {
@@ -5599,13 +5720,7 @@ var SqliteDatabase = class {
       const g = groupedRows[i];
       const pKey = serializeSqlJson(
         yield* stepMap(over.partitionBy, function* (pe) {
-          return yield* this.evalExprWithAgg(
-            pe,
-            g.representative,
-            g.group,
-            positionalParams,
-            cteScope
-          );
+          return yield* this.evalExprSteps(pe, g.representative, positionalParams, cteScope, { group: g.group });
         }, this),
         false
       );
@@ -5625,20 +5740,8 @@ var SqliteDatabase = class {
           const gB = groupedRows[iB];
           for (const ob of over.orderBy) {
             yield;
-            const vA = yield* this.evalExprWithAgg(
-              ob.expr,
-              gA.representative,
-              gA.group,
-              positionalParams,
-              cteScope
-            );
-            const vB = yield* this.evalExprWithAgg(
-              ob.expr,
-              gB.representative,
-              gB.group,
-              positionalParams,
-              cteScope
-            );
+            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 });
             const cmp = compareSqlValues(vA, vB);
             if (cmp !== 0) {
               return ob.desc ? -cmp : cmp;
@@ -5651,13 +5754,7 @@ var SqliteDatabase = class {
         const g = groupedRows[idx];
         return serializeSqlJson(
           yield* stepMap(over.orderBy, function* (ob) {
-            return yield* this.evalExprWithAgg(
-              ob.expr,
-              g.representative,
-              g.group,
-              positionalParams,
-              cteScope
-            );
+            return yield* this.evalExprSteps(ob.expr, g.representative, positionalParams, cteScope, { group: g.group });
           }, this),
           false
         );
@@ -5683,13 +5780,7 @@ var SqliteDatabase = class {
             1,
             Math.trunc(
               toSqlNumber(
-                yield* this.evalExprWithAgg(
-                  fnExpr.args[0],
-                  g.representative,
-                  g.group,
-                  positionalParams,
-                  cteScope
-                )
+                yield* this.evalExprSteps(fnExpr.args[0], g.representative, positionalParams, cteScope, { group: g.group })
               )
             )
           );
@@ -5706,44 +5797,20 @@ var SqliteDatabase = class {
         } else if (fnUpper === "LAG" || fnUpper === "LEAD") {
           const offset = fnExpr.args[1] ? Math.trunc(
             toSqlNumber(
-              yield* this.evalExprWithAgg(
-                fnExpr.args[1],
-                g.representative,
-                g.group,
-                positionalParams,
-                cteScope
-              )
+              yield* this.evalExprSteps(fnExpr.args[1], g.representative, positionalParams, cteScope, { group: g.group })
             )
           ) : 1;
-          const defVal = fnExpr.args[2] ? yield* this.evalExprWithAgg(
-            fnExpr.args[2],
-            g.representative,
-            g.group,
-            positionalParams,
-            cteScope
-          ) : null;
+          const defVal = fnExpr.args[2] ? yield* this.evalExprSteps(fnExpr.args[2], g.representative, positionalParams, cteScope, { group: g.group }) : null;
           const targetPos = fnUpper === "LAG" ? pPos - offset : pPos + offset;
           if (targetPos < 0 || targetPos >= indices.length) {
             result[rowIdx] = defVal;
           } else {
             const targetG = groupedRows[indices[targetPos]];
-            result[rowIdx] = yield* this.evalExprWithAgg(
-              fnExpr.args[0],
-              targetG.representative,
-              targetG.group,
-              positionalParams,
-              cteScope
-            );
+            result[rowIdx] = yield* this.evalExprSteps(fnExpr.args[0], targetG.representative, positionalParams, cteScope, { group: targetG.group });
           }
         } else if (fnUpper === "FIRST_VALUE") {
           const firstG = groupedRows[indices[0]];
-          result[rowIdx] = yield* this.evalExprWithAgg(
-            fnExpr.args[0],
-            firstG.representative,
-            firstG.group,
-            positionalParams,
-            cteScope
-          );
+          result[rowIdx] = yield* this.evalExprSteps(fnExpr.args[0], firstG.representative, positionalParams, cteScope, { group: firstG.group });
         } else if (fnUpper === "LAST_VALUE") {
           let peerEnd = over.orderBy.length > 0 ? pPos : indices.length - 1;
           while (over.orderBy.length > 0 && peerEnd + 1 < indices.length && orderPeerKeys[peerEnd + 1] === orderPeerKeys[pPos]) {
@@ -5751,34 +5818,16 @@ var SqliteDatabase = class {
             peerEnd += 1;
           }
           const lastG = groupedRows[indices[peerEnd]];
-          result[rowIdx] = yield* this.evalExprWithAgg(
-            fnExpr.args[0],
-            lastG.representative,
-            lastG.group,
-            positionalParams,
-            cteScope
-          );
+          result[rowIdx] = yield* this.evalExprSteps(fnExpr.args[0], lastG.representative, positionalParams, cteScope, { group: lastG.group });
         } else if (fnUpper === "NTH_VALUE") {
           const n = Math.trunc(
             toSqlNumber(
-              yield* this.evalExprWithAgg(
-                fnExpr.args[1],
-                g.representative,
-                g.group,
-                positionalParams,
-                cteScope
-              )
+              yield* this.evalExprSteps(fnExpr.args[1], g.representative, positionalParams, cteScope, { group: g.group })
             )
           );
           if (n >= 1 && n <= indices.length) {
             const nthG = groupedRows[indices[n - 1]];
-            result[rowIdx] = yield* this.evalExprWithAgg(
-              fnExpr.args[0],
-              nthG.representative,
-              nthG.group,
-              positionalParams,
-              cteScope
-            );
+            result[rowIdx] = yield* this.evalExprSteps(fnExpr.args[0], nthG.representative, positionalParams, cteScope, { group: nthG.group });
           } else {
             result[rowIdx] = null;
           }
@@ -5804,150 +5853,6 @@ var SqliteDatabase = class {
     }
     return result;
   }
-  *evalExprWithAggAndWindow(expr, rep, group, rowIdx, windowResults, positionalParams, cteScope) {
-    if (windowResults.has(expr)) {
-      return windowResults.get(expr)[rowIdx] ?? null;
-    }
-    if (expr.kind === "unary") {
-      const v = yield* this.evalExprWithAggAndWindow(
-        expr.expr,
-        rep,
-        group,
-        rowIdx,
-        windowResults,
-        positionalParams,
-        cteScope
-      );
-      return this.applyUnary(expr.op, v);
-    }
-    if (expr.kind === "binary") {
-      const l = yield* this.evalExprWithAggAndWindow(
-        expr.left,
-        rep,
-        group,
-        rowIdx,
-        windowResults,
-        positionalParams,
-        cteScope
-      );
-      const r = yield* this.evalExprWithAggAndWindow(
-        expr.right,
-        rep,
-        group,
-        rowIdx,
-        windowResults,
-        positionalParams,
-        cteScope
-      );
-      return this.applyBinary(expr.op, l, r);
-    }
-    if (expr.kind === "func" && !this.containsAggregate(expr) && !expr.over) {
-      const args = yield* stepMap(expr.args, function* (a) {
-        return yield* this.evalExprWithAggAndWindow(
-          a,
-          rep,
-          group,
-          rowIdx,
-          windowResults,
-          positionalParams,
-          cteScope
-        );
-      }, this);
-      return yield* this.evalScalarFunction(expr.name, args);
-    }
-    return yield* this.evalExprWithAgg(expr, rep, group, positionalParams, cteScope);
-  }
-  *evalExprWithAgg(expr, rep, group, positionalParams, cteScope) {
-    if (expr.kind === "func") {
-      const u = expr.name.toUpperCase();
-      if ([
-        "COUNT",
-        "SUM",
-        "TOTAL",
-        "AVG",
-        "MIN",
-        "MAX",
-        "GROUP_CONCAT",
-        "STRING_AGG",
-        "JSON_GROUP_ARRAY",
-        "JSON_GROUP_OBJECT"
-      ].includes(u) && !((u === "MIN" || u === "MAX") && expr.args.length > 1)) {
-        return yield* this.evalAggregateFunction(expr, group, positionalParams, cteScope);
-      }
-      if (u === "COALESCE" || u === "IFNULL") {
-        for (const a of expr.args) {
-          yield;
-          const v = yield* this.evalExprWithAgg(a, rep, group, positionalParams, cteScope);
-          if (v !== null && v !== void 0) {
-            return v;
-          }
-        }
-        return null;
-      }
-      if (u === "IIF") {
-        const cond = yield* this.evalExprWithAgg(
-          expr.args[0],
-          rep,
-          group,
-          positionalParams,
-          cteScope
-        );
-        return isTruthy(cond) ? yield* this.evalExprWithAgg(expr.args[1], rep, group, positionalParams, cteScope) : expr.args[2] ? yield* this.evalExprWithAgg(expr.args[2], rep, group, positionalParams, cteScope) : null;
-      }
-      const args = yield* stepMap(expr.args, function* (a) {
-        return yield* this.evalExprWithAgg(a, rep, group, positionalParams, cteScope);
-      }, this);
-      return yield* this.evalScalarFunction(expr.name, args);
-    }
-    if (expr.kind === "unary") {
-      return this.applyUnary(
-        expr.op,
-        yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope)
-      );
-    }
-    if (expr.kind === "binary") {
-      const l = yield* this.evalExprWithAgg(expr.left, rep, group, positionalParams, cteScope);
-      const r = yield* this.evalExprWithAgg(expr.right, rep, group, positionalParams, cteScope);
-      return this.applyBinary(expr.op, l, r);
-    }
-    if (expr.kind === "is_null") {
-      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
-      return (expr.not ? v !== null : v === null) ? 1 : 0;
-    }
-    if (expr.kind === "between") {
-      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
-      const lo = yield* this.evalExprWithAgg(expr.low, rep, group, positionalParams, cteScope);
-      const hi = yield* this.evalExprWithAgg(expr.high, rep, group, positionalParams, cteScope);
-      if (v === null || lo === null || hi === null) {
-        return null;
-      }
-      const inside = compareSqlValues(v, lo) >= 0 && compareSqlValues(v, hi) <= 0;
-      return (expr.not ? !inside : inside) ? 1 : 0;
-    }
-    if (expr.kind === "case") {
-      const baseVal = expr.base ? yield* this.evalExprWithAgg(expr.base, rep, group, positionalParams, cteScope) : void 0;
-      for (const b of expr.branches) {
-        yield;
-        const wVal = yield* this.evalExprWithAgg(
-          b.when,
-          rep,
-          group,
-          positionalParams,
-          cteScope
-        );
-        const matched = expr.base ? sqlEquals(baseVal ?? null, wVal) === true : isTruthy(wVal);
-        if (matched) {
-          return yield* this.evalExprWithAgg(b.then, rep, group, positionalParams, cteScope);
-        }
-      }
-      return expr.elseExpr ? yield* this.evalExprWithAgg(expr.elseExpr, rep, group, positionalParams, cteScope) : null;
-    }
-    if (expr.kind === "cast") {
-      const v = yield* this.evalExprWithAgg(expr.expr, rep, group, positionalParams, cteScope);
-      return this.applyCast(v, expr.targetType);
-    }
-    return yield* this.evalExprSteps(expr, rep, positionalParams, cteScope);
-  }
   *evalAggregateFunction(expr, group, positionalParams, cteScope) {
     const u = expr.name.toUpperCase();
     let filteredGroup = group;
@@ -6188,7 +6093,10 @@ var SqliteDatabase = class {
   evalExpr(expr, row, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
     return runSynchronously(this.evalExprSteps(expr, row, positionalParams, cteScope));
   }
-  *evalExprSteps(expr, row, positionalParams, cteScope = /* @__PURE__ */ new Map()) {
+  *evalExprSteps(expr, row, positionalParams, cteScope = /* @__PURE__ */ new Map(), evaluation) {
+    if (evaluation?.window?.results.has(expr)) {
+      return evaluation.window.results.get(expr)[evaluation.window.rowIdx] ?? null;
+    }
     switch (expr.kind) {
       case "literal":
         return expr.value;
@@ -6207,19 +6115,19 @@ var SqliteDatabase = class {
         return this.parameters.get(expr.name) ?? this.parameters.get(expr.name.slice(1)) ?? positionalParams[expr.index - 1] ?? null;
       }
       case "collate":
-        return yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        return yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
       case "unary":
         return this.applyUnary(
           expr.op,
-          yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope)
+          yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation)
         );
       case "binary": {
         if (expr.op === "AND") {
-          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope);
+          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
           if (l2 !== null && !isTruthy(l2)) {
             return 0;
           }
-          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
+          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
           if (r2 !== null && !isTruthy(r2)) {
             return 0;
           }
@@ -6229,11 +6137,11 @@ var SqliteDatabase = class {
           return 1;
         }
         if (expr.op === "OR") {
-          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope);
+          const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
           if (l2 !== null && isTruthy(l2)) {
             return 1;
           }
-          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
+          const r2 = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
           if (r2 !== null && isTruthy(r2)) {
             return 1;
           }
@@ -6243,47 +6151,48 @@ 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);
+        const l = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
         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],
             row,
             positionalParams,
-            cteScope
+            cteScope,
+            evaluation
           );
           const esc = yield* this.evalExprSteps(
             expr.right.args[1],
             row,
             positionalParams,
-            cteScope
+            cteScope,
+            evaluation
           );
           if (l === null || pat === null || esc === null) {
             return null;
           }
           return matchLike(toSqlString(l), toSqlString(pat), expr.op === "LIKE", toSqlString(esc)) ? 1 : 0;
         }
-        const r = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope);
+        const r = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
         return this.applyBinary(expr.op, l, r, collation);
       }
       case "between": {
-        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
-        const lo = yield* this.evalExprSteps(expr.low, row, positionalParams, cteScope);
-        const hi = yield* this.evalExprSteps(expr.high, row, positionalParams, cteScope);
-        if (v === null || lo === null || hi === null) {
-          return null;
-        }
-        const inside = compareSqlValues(v, lo) >= 0 && compareSqlValues(v, hi) <= 0;
-        return (expr.not ? !inside : inside) ? 1 : 0;
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
+        const lo = yield* this.evalExprSteps(expr.low, row, positionalParams, cteScope, evaluation);
+        const hi = yield* this.evalExprSteps(expr.high, row, positionalParams, cteScope, evaluation);
+        const lower = v === null || lo === null ? null : compareSqlValues(v, lo) >= 0;
+        const upper = v === null || hi === null ? null : compareSqlValues(v, hi) <= 0;
+        const inside = lower === false || upper === false ? false : lower === null || upper === null ? null : true;
+        return inside === null ? null : (expr.not ? !inside : inside) ? 1 : 0;
       }
       case "in_list": {
-        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
         if (v === null) {
           return expr.list.length === 0 ? expr.not ? 1 : 0 : null;
         }
         let sawNull = false;
         for (const item of expr.list) {
           yield;
-          const iv = yield* this.evalExprSteps(item, row, positionalParams, cteScope);
+          const iv = yield* this.evalExprSteps(item, row, positionalParams, cteScope, evaluation);
           if (iv === null) {
             sawNull = true;
           } else if (sqlEquals(v, iv) === true) {
@@ -6296,7 +6205,7 @@ var SqliteDatabase = class {
         return expr.not ? 1 : 0;
       }
       case "in_subquery": {
-        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
         this.outerRows.push(row);
         let res;
         try {
@@ -6329,23 +6238,23 @@ var SqliteDatabase = class {
         return expr.not ? 1 : 0;
       }
       case "is_null": {
-        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
         return (expr.not ? v !== null : v === null) ? 1 : 0;
       }
       case "case": {
-        const baseVal = expr.base ? yield* this.evalExprSteps(expr.base, row, positionalParams, cteScope) : void 0;
+        const baseVal = expr.base ? yield* this.evalExprSteps(expr.base, row, positionalParams, cteScope, evaluation) : void 0;
         for (const b of expr.branches) {
           yield;
-          const wVal = yield* this.evalExprSteps(b.when, row, positionalParams, cteScope);
+          const wVal = yield* this.evalExprSteps(b.when, row, positionalParams, cteScope, evaluation);
           const matched = expr.base ? sqlEquals(baseVal ?? null, wVal) === true : isTruthy(wVal);
           if (matched) {
-            return yield* this.evalExprSteps(b.then, row, positionalParams, cteScope);
+            return yield* this.evalExprSteps(b.then, row, positionalParams, cteScope, evaluation);
           }
         }
-        return expr.elseExpr ? yield* this.evalExprSteps(expr.elseExpr, row, positionalParams, cteScope) : null;
+        return expr.elseExpr ? yield* this.evalExprSteps(expr.elseExpr, row, positionalParams, cteScope, evaluation) : null;
       }
       case "cast": {
-        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope);
+        const v = yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation);
         return this.applyCast(v, expr.targetType);
       }
       case "subquery": {
@@ -6368,11 +6277,14 @@ var SqliteDatabase = class {
         return res.rows[0]?.[0] ?? null;
       }
       case "func": {
+        if (evaluation && isAggregateFunction(expr)) {
+          return yield* this.evalAggregateFunction(expr, evaluation.group, positionalParams, cteScope);
+        }
         const u = expr.name.toUpperCase();
         if (u === "COALESCE" || u === "IFNULL") {
           for (const a of expr.args) {
             yield;
-            const v = yield* this.evalExprSteps(a, row, positionalParams, cteScope);
+            const v = yield* this.evalExprSteps(a, row, positionalParams, cteScope, evaluation);
             if (v !== null && v !== void 0) {
               return v;
             }
@@ -6384,12 +6296,13 @@ var SqliteDatabase = class {
             expr.args[0],
             row,
             positionalParams,
-            cteScope
+            cteScope,
+            evaluation
           );
-          return isTruthy(cond) ? yield* this.evalExprSteps(expr.args[1], row, positionalParams, cteScope) : expr.args[2] ? yield* this.evalExprSteps(expr.args[2], row, positionalParams, cteScope) : null;
+          return isTruthy(cond) ? yield* this.evalExprSteps(expr.args[1], row, positionalParams, cteScope, evaluation) : expr.args[2] ? yield* this.evalExprSteps(expr.args[2], row, positionalParams, cteScope, evaluation) : null;
         }
         const args = yield* stepMap(expr.args, function* (a) {
-          return yield* this.evalExprSteps(a, row, positionalParams, cteScope);
+          return yield* this.evalExprSteps(a, row, positionalParams, cteScope, evaluation);
         }, this);
         return yield* this.evalScalarFunction(expr.name, args);
       }
@@ -6541,18 +6454,6 @@ var SqliteDatabase = class {
     switch (u) {
       case "NULLIF":
         return sqlEquals(a0, a1) === true ? null : a0;
-      case "COALESCE":
-      case "IFNULL": {
-        for (const a of args) {
-          yield;
-          if (a !== null && a !== void 0) {
-            return a;
-          }
-        }
-        return null;
-      }
-      case "IIF":
-        return isTruthy(a0) ? a1 ?? null : args[2] ?? null;
       case "TYPEOF":
         if (a0 === null || a0 === void 0) {
           return "null";
@@ -6623,7 +6524,7 @@ var SqliteDatabase = class {
         const s = toSqlString(a0);
         const chars = Array.from(s);
         const pos = Math.trunc(toSqlNumber(a1));
-        const len = args[2] !== void 0 && args[2] !== null ? Math.trunc(toSqlNumber(args[2])) : chars.length;
+        let len = args[2] !== void 0 && args[2] !== null ? Math.trunc(toSqlNumber(args[2])) : chars.length;
         let startIdx;
         if (pos > 0) {
           startIdx = pos - 1;
@@ -6631,6 +6532,7 @@ var SqliteDatabase = class {
           startIdx = chars.length + pos;
         } else {
           startIdx = 0;
+          if (args[2] !== void 0 && args[2] !== null && len > 0) len -= 1;
         }
         if (len < 0) {
           const endIdx = Math.max(0, startIdx);
@@ -7059,6 +6961,45 @@ var SqliteDatabase = class {
 };
 
 // packages/safe-bash-command-sqlite3/src/index.ts
+function setOutputMode(state, mode, argument) {
+  if (!["list", "csv", "column", "line", "json", "tabs", "html", "markdown", "box", "table", "quote", "ascii", "insert"].includes(mode)) {
+    return;
+  }
+  state.mode = mode;
+  switch (mode) {
+    case "list":
+      state.colSeparator = "|";
+      state.rowSeparator = "\n";
+      break;
+    case "csv":
+      state.colSeparator = ",";
+      state.rowSeparator = "\r\n";
+      break;
+    case "tabs":
+      state.colSeparator = "	";
+      break;
+    case "ascii":
+      state.colSeparator = "";
+      state.rowSeparator = "";
+      break;
+    case "quote":
+      state.colSeparator = ",";
+      state.rowSeparator = "\n";
+      break;
+    case "line":
+    case "column":
+      state.rowSeparator = "\n";
+      break;
+    case "insert":
+      if (argument) state.insertTable = argument;
+      break;
+    case "table":
+    case "box":
+    case "markdown":
+      if (argument === void 0) state.showHeaders = true;
+      break;
+  }
+}
 var textEncoder3 = new TextEncoder();
 var textDecoder3 = new TextDecoder("utf-8", { fatal: false });
 async function vfsExists(fs, path) {
@@ -7223,6 +7164,8 @@ function formatQueryResult(res, state) {
     return "";
   }
   switch (state.mode) {
+    case "tabs":
+    case "ascii":
     case "list": {
       if (!state.showHeaders && rows.length === 0) {
         return "";
@@ -7236,40 +7179,11 @@ function formatQueryResult(res, state) {
       }
       return lines.map((l) => `${l}${state.rowSeparator}`).join("");
     }
-    case "tabs": {
-      if (!state.showHeaders && rows.length === 0) {
-        return "";
-      }
-      const lines = [];
-      if (state.showHeaders) {
-        lines.push(columns.join("	"));
-      }
-      for (const r of rows) {
-        lines.push(r.map((v) => formatCellValue(v, state.nullValue)).join("	"));
-      }
-      return `${lines.join("\n")}
-`;
-    }
-    case "ascii": {
-      if (!state.showHeaders && rows.length === 0) {
-        return "";
-      }
-      const cSep = "";
-      const rSep = "";
-      let out = "";
-      if (state.showHeaders) {
-        out += columns.join(cSep) + rSep;
-      }
-      for (const r of rows) {
-        out += r.map((v) => formatCellValue(v, state.nullValue)).join(cSep) + rSep;
-      }
-      return out;
-    }
     case "csv": {
       if (!state.showHeaders && rows.length === 0) {
         return "";
       }
-      const sep = state.colSeparator === "|" ? "," : state.colSeparator;
+      const sep = state.colSeparator;
       const lines = [];
       if (state.showHeaders) {
         lines.push(columns.map((c) => formatCsvCell(c, sep)).join(sep));
@@ -7518,6 +7432,26 @@ function splitDotCommandArgs(line) {
   }
   return args;
 }
+function isMutatingStatement(sql) {
+  const tokens = tokenizeSql(sql);
+  let depth = 0;
+  for (const token of tokens) {
+    if (token.type === "punct" && token.value === "(") {
+      depth++;
+      continue;
+    }
+    if (token.type === "punct" && token.value === ")") {
+      depth--;
+      continue;
+    }
+    if (depth !== 0 || token.type !== "word") continue;
+    const word = token.value.toUpperCase();
+    if (["CREATE", "DROP", "ALTER", "INSERT", "REPLACE", "UPDATE", "DELETE", "VACUUM", "REINDEX", "ANALYZE"].includes(word)) return true;
+    if (word === "PRAGMA") return tokens.some((item) => item.value === "=" || item.value === "(");
+    if (["SELECT", "VALUES", "EXPLAIN"].includes(word)) return false;
+  }
+  return false;
+}
 var settings = {
   commandName: "sqlite3",
   limits: {
@@ -7662,10 +7596,13 @@ Options:
             state.mode = "quote";
           } else if (arg === "-tabs" || arg === "--tabs") {
             state.mode = "tabs";
+            state.colSeparator = "	";
           } else if (arg === "-html" || arg === "--html") {
             state.mode = "html";
           } else if (arg === "-ascii" || arg === "--ascii") {
             state.mode = "ascii";
+            state.colSeparator = "";
+            state.rowSeparator = "";
           } else if (arg === "-header" || arg === "--header") {
             state.showHeaders = true;
           } else if (arg === "-noheader" || arg === "--noheader") {
@@ -7691,7 +7628,7 @@ Options:
           } else if (arg === "-init" || arg === "--init") {
             initFile = args[i + 1] ?? null;
             i += 1;
-          } else if (arg.startsWith("-")) {
+          } else if (arg.startsWith("-") && positional.length === 0) {
             await writeText(context.stderr, `sqlite3: Error: unknown option: ${arg}
 `);
             return { exitCode: 1 };
@@ -7864,37 +7801,7 @@ Options:
             return;
           }
           if (cmd === ".mode") {
-            const newMode = (parts[1] ?? "list").toLowerCase();
-            if ([
-              "list",
-              "csv",
-              "column",
-              "line",
-              "json",
-              "tabs",
-              "html",
-              "markdown",
-              "box",
-              "table",
-              "quote",
-              "ascii",
-              "insert"
-            ].includes(newMode)) {
-              state.mode = newMode;
-              if (newMode === "list") {
-                state.colSeparator = "|";
-                state.rowSeparator = "\n";
-              } else if (newMode === "csv") {
-                state.colSeparator = ",";
-                state.rowSeparator = "\r\n";
-              } else if (newMode === "tabs") {
-                state.colSeparator = "	";
-              } else if (newMode === "insert" && parts[2]) {
-                state.insertTable = parts[2];
-              } else if (["table", "box", "markdown"].includes(newMode) && parts[2] === void 0) {
-                state.showHeaders = true;
-              }
-            }
+            setOutputMode(state, (parts[1] ?? "list").toLowerCase(), parts[2]);
             return;
           }
           if (cmd === ".headers" || cmd === ".header") {
@@ -7975,9 +7882,7 @@ Options:
               const res = await execSingleStmt("SELECT name FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' ORDER BY name;");
               names = (res?.rows ?? []).map((r) => String(r[0] ?? ""));
             }
-            const filtered = pattern ? names.filter(
-              (n) => pattern.includes("%") || pattern.includes("_") ? new RegExp(`^${pattern.replace(/%/g, ".*").replace(/_/g, ".")}$`, "i").test(n) : matchGlob(n.toLowerCase(), pattern.toLowerCase()) || n.toLowerCase().includes(pattern.toLowerCase())
-            ) : names;
+            const filtered = pattern ? names.filter((n) => matchLike(n, pattern, true)) : names;
             if (filtered.length > 0) {
               const maxLen = Math.max(...filtered.map((s) => s.length));
               const nCol = Math.max(1, Math.floor(79 / (maxLen + 2)));
@@ -8123,6 +8028,7 @@ Options:
             return;
           }
           if (cmd === ".import") {
+            if (state.readonly) throw new Error("attempt to write a readonly database");
             let pIdx = 1;
             let csvOverride = false;
             let skipRows = 0;
@@ -8142,7 +8048,7 @@ Options:
             const tableArg = parts[pIdx + 1] ?? "";
             const filePath = resolveVfsPath(context.cwd, fileArg);
             const content = textDecoder3.decode(await readInputFile(filePath));
-            const sep = csvOverride || state.mode === "csv" ? state.colSeparator === "|" ? "," : state.colSeparator : state.colSeparator;
+            const sep = csvOverride ? "," : state.colSeparator;
             const parsedRows = parseCsvContent(content, sep).slice(skipRows);
             if (parsedRows.length === 0) {
               return;
@@ -8219,6 +8125,7 @@ Options:
             return;
           }
           if (cmd === ".restore") {
+            if (state.readonly) throw new Error("attempt to write a readonly database");
             const srcArg = parts.length >= 3 ? parts[2] : parts[1];
             const srcPath = resolveVfsPath(context.cwd, srcArg);
             db.tables?.clear();
@@ -8266,8 +8173,7 @@ Options:
             await emitOutput(`${stmt}
 `);
           }
-          const upper = stmt.trim().toUpperCase();
-          const isMutating = upper.startsWith("CREATE") || upper.startsWith("DROP") || upper.startsWith("ALTER") || upper.startsWith("INSERT") || upper.startsWith("REPLACE") || upper.startsWith("UPDATE") || upper.startsWith("DELETE") || upper.startsWith("VACUUM") || upper.startsWith("PRAGMA") && stmt.includes("=");
+          const isMutating = isMutatingStatement(stmt);
           if (state.readonly && isMutating) {
             throw new Error("attempt to write a readonly database");
           }
@@ -8512,10 +8418,13 @@ Options:
         state.mode = "quote";
       } else if (arg === "-tabs" || arg === "--tabs") {
         state.mode = "tabs";
+        state.colSeparator = "	";
       } else if (arg === "-html" || arg === "--html") {
         state.mode = "html";
       } else if (arg === "-ascii" || arg === "--ascii") {
         state.mode = "ascii";
+        state.colSeparator = "";
+        state.rowSeparator = "";
       } else if (arg === "-header" || arg === "--header") {
         state.showHeaders = true;
       } else if (arg === "-noheader" || arg === "--noheader") {
@@ -8541,7 +8450,7 @@ Options:
       } else if (arg === "-init" || arg === "--init") {
         initFile = opArgs[i + 1] ?? null;
         i += 1;
-      } else if (arg.startsWith("-")) {
+      } else if (arg.startsWith("-") && positional.length === 0) {
         return void 0;
       } else {
         positional.push(arg);
@@ -8582,15 +8491,7 @@ Options:
         return state.exitCode === 0;
       }
       if (cmd === ".mode") {
-        const newMode = (parts[1] ?? "list").toLowerCase();
-        if (["list", "csv", "column", "line", "json", "tabs", "html", "markdown", "box", "table", "quote", "ascii", "insert"].includes(newMode)) {
-          state.mode = newMode;
-          if (newMode === "list") state.colSeparator = "|";
-          else if (newMode === "csv") state.colSeparator = ",";
-          else if (newMode === "tabs") state.colSeparator = "	";
-          else if (newMode === "insert" && parts[2]) state.insertTable = parts[2];
-          else if (["table", "box", "markdown"].includes(newMode) && parts[2] === void 0) state.showHeaders = true;
-        }
+        setOutputMode(state, (parts[1] ?? "list").toLowerCase(), parts[2]);
         return true;
       }
       if (cmd === ".headers" || cmd === ".header") {
@@ -8648,9 +8549,7 @@ Options:
       if (cmd === ".tables") {
         const pattern = parts[1];
         const names = [...db.tables.keys(), ...db.views.keys()].filter((n) => !n.toLowerCase().startsWith("sqlite_")).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-        const filtered = pattern ? names.filter(
-          (n) => pattern.includes("%") || pattern.includes("_") ? new RegExp(`^${pattern.replace(/%/g, ".*").replace(/_/g, ".")}$`, "i").test(n) : matchGlob(n.toLowerCase(), pattern.toLowerCase()) || n.toLowerCase().includes(pattern.toLowerCase())
-        ) : names;
+        const filtered = pattern ? names.filter((n) => matchLike(n, pattern, true)) : names;
         if (filtered.length > 0) {
           const maxLen = Math.max(...filtered.map((s) => s.length));
           const nCol = Math.max(1, Math.floor(79 / (maxLen + 2)));
@@ -8767,7 +8666,7 @@ Options:
         const fileBytes = readFileSync(fileArg);
         if (!fileBytes || fileBytes.byteLength > 65536) return false;
         const content = textDecoder3.decode(fileBytes);
-        const sep = csvOverride || state.mode === "csv" ? state.colSeparator === "|" ? "," : state.colSeparator : state.colSeparator;
+        const sep = csvOverride ? "," : state.colSeparator;
         const parsedRows = parseCsvContent(content, sep).slice(skipRows);
         if (parsedRows.length === 0) return true;
         let tbl = db.findTable(tableArg);
@@ -8794,7 +8693,7 @@ Options:
     const runSqlStatementSync = (stmt) => {
       const trimmed = stmt.trim();
       if (!trimmed) return true;
-      const isMutating = !/^\s*(SELECT|PRAGMA|EXPLAIN|VALUES|WITH\s+[\s\S]*?\bSELECT)\b/i.test(trimmed);
+      const isMutating = isMutatingStatement(trimmed);
       if (isMutating) {
         if (state.readonly || state.dbPath !== ":memory:" && !writeFileSync) return false;
       }