@peerbit/indexer-sqlite3 3.0.6 → 3.0.7

package/dist/index.min.js

@@ -21219,15 +21219,15 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
   }
   return Object.assign(Object.create(table.ctor.prototype), obj);
 };
-var convertDeleteRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("delete", { query: coerceLocalQueries(request.query) }, tables, table);
+var convertDeleteRequestToQuery = (request, tables, table, options) => {
+  const { query, bindable } = convertRequestToQuery("delete", { query: coerceLocalQueries(request.query) }, tables, table, void 0, [], options);
   return {
     sql: `DELETE FROM ${table.name} WHERE ${table.name}.${table.primary} IN (SELECT ${table.primary} from ${table.name} ${query}) returning ${table.primary}`,
     bindable
   };
 };
-var convertSumRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("sum", { query: coerceLocalQueries(request.query), key: request.key }, tables, table);
+var convertSumRequestToQuery = (request, tables, table, options) => {
+  const { query, bindable } = convertRequestToQuery("sum", { query: coerceLocalQueries(request.query), key: request.key }, tables, table, void 0, [], options);
   const inlineName = getInlineTableFieldName(request.key);
   const field2 = table.fields.find((x) => x.name === inlineName);
   if (unwrapNestedType(field2.from.type) === "u64") {
@@ -21404,7 +21404,12 @@ var _buildJoin = (table, options) => {
   if (table.columns.length > 0) {
     const usedColumns = removeDuplicatesOrdered(table.columns);
     const usesImplicitPrimaryKeyIndex = table.type === "root" && table.table.primary !== false && usedColumns.length === 1 && usedColumns[0] === table.table.primary;
-    indexedBy = options?.planner && !usesImplicitPrimaryKeyIndex ? ` INDEXED BY ${options.planner.resolveIndex(table.table.name, usedColumns)} ` : "";
+    if (options?.planner && !usesImplicitPrimaryKeyIndex) {
+      const indexKey = options.planner.resolveIndex(table.table.name, usedColumns);
+      indexedBy = options.planner.forceIndex ? ` INDEXED BY ${indexKey} ` : "";
+    } else {
+      indexedBy = "";
+    }
   }
   if (table.type !== "root") {
     let nonInlinedParent = table.table.parent && getNonInlinedTable(table.table.parent);
@@ -21692,10 +21697,14 @@ var __runInitializers4 = function(thisArg, initializers, value) {
   }
   return useValue ? value : void 0;
 };
-var getSortedNameKey = (tableName, names) => [tableName, ...names.sort()].join(",");
-var createIndexKey = (tableName, fields) => `${tableName}_index_${fields.map((x) => x).join("_")}`;
+var getSortedNameKey = (tableName, names) => [tableName, ...[...names].sort()].join(",");
+var getIndexColumnKey = (field2) => `${field2.name}${field2.collation ? `_collate_${field2.collation.toLowerCase()}` : ""}`;
+var createIndexKey = (tableName, fields) => `${tableName}_index_${fields.map((x) => getIndexColumnKey(x).replace(/[^a-zA-Z0-9_]/g, "_")).join("_")}`;
+var createIndexColumnSQL = (field2) => `${escapeColumnName(field2.name)}${field2.collation ? ` COLLATE ${field2.collation}` : ""}`;
 var HALF_MAX_U32 = 2147483647;
 var HALF_MAX_U64 = 9223372036854775807n;
+var PARENT_TABLE_ID2 = "__parent_id";
+var AMBIGUOUS_CHILD_FORCE_AFTER_USES = 6e3;
 var flattenQuery = function* (props) {
   if (!props) {
     return yield props;
@@ -21850,21 +21859,40 @@ var QueryPlanner = class {
     let indexCreateCommands = void 0;
     let pickedIndexKeys = /* @__PURE__ */ new Map();
     let indexCreationPromiseToAwait = [];
+    let forceIndex = this.props.forceIndexes !== false;
     return {
+      get forceIndex() {
+        return forceIndex;
+      },
       beforePrepare: async () => {
         if (indexCreateCommands != null) {
-          for (const { key, cmd, deferred } of indexCreateCommands) {
+          const commandsToCreate = [];
+          for (const command of indexCreateCommands) {
+            if (this.pendingIndexCreation.has(command.key)) {
+              await this.pendingIndexCreation.get(command.key);
+              continue;
+            }
+            commandsToCreate.push(command);
+          }
+          if (commandsToCreate.length > 0) {
+            const creationPromise = Promise.resolve(this.props.exec([
+              ...commandsToCreate.map((command) => command.cmd),
+              ...this.props.optimizeAfterCreate === false ? [] : ["PRAGMA optimize"]
+            ].join(";")));
+            for (const { key } of commandsToCreate) {
+              this.pendingIndexCreation.set(key, creationPromise);
+            }
             try {
-              if (this.pendingIndexCreation.has(key)) {
-                await this.pendingIndexCreation.get(key);
+              await creationPromise;
+              for (const { key, deferred } of commandsToCreate) {
+                this.pendingIndexCreation.delete(key);
+                deferred.resolve();
               }
-              const promise = this.props.exec(cmd);
-              this.pendingIndexCreation.set(key, promise);
-              await promise;
-              this.pendingIndexCreation.delete(key);
-              deferred.resolve();
             } catch (error2) {
-              deferred.reject(error2);
+              for (const { key, deferred } of commandsToCreate) {
+                this.pendingIndexCreation.delete(key);
+                deferred.reject(error2);
+              }
             }
           }
         }
@@ -21876,6 +21904,7 @@ var QueryPlanner = class {
         await Promise.all(indexCreationPromiseToAwait);
       },
       resolveIndex: (tableName, columns) => {
+        forceIndex = this.props.forceIndexes !== false;
         const sortedNameKey = getSortedNameKey(tableName, columns);
         let indexStats = obj.columnsToIndexes.get(sortedNameKey);
         if (indexStats === void 0) {
@@ -21885,10 +21914,10 @@ var QueryPlanner = class {
           obj.columnsToIndexes.set(sortedNameKey, indexStats);
         }
         if (indexStats.results.length === 0) {
-          const permutations = generatePermutations(columns);
-          for (const columns2 of permutations) {
+          const candidates = generateIndexCandidates(query, columns);
+          for (const columns2 of candidates) {
             const indexKey = createIndexKey(tableName, columns2);
-            const command = `create index if not exists ${indexKey} on ${tableName} (${columns2.map((n) => escapeColumnName(n)).join(", ")})`;
+            const command = `create index if not exists ${indexKey} on ${tableName} (${columns2.map((n) => createIndexColumnSQL(n)).join(", ")})`;
             let deferred = pDefer();
             (indexCreateCommands || (indexCreateCommands = [])).push({
               cmd: command,
@@ -21905,11 +21934,17 @@ var QueryPlanner = class {
               avg: -1,
               // setting -1 will force the first time to be the fastest (i.e. new indices are always tested once)
               indexKey,
+              columns: columns2,
               created: () => created,
               creationPromiseDeferred: deferred
             });
           }
         }
+        const isAmbiguousChildPredicate = query.sort.length === 0 && columns.includes(PARENT_TABLE_ID2) && columns.length > 1;
+        if (isAmbiguousChildPredicate) {
+          const totalUses = indexStats.results.reduce((sum, result) => sum + result.used, 0);
+          forceIndex = this.props.forceIndexes !== false && totalUses >= AMBIGUOUS_CHILD_FORCE_AFTER_USES;
+        }
         let fastestIndex = indexStats.results[0];
         fastestIndex.used++;
         if (!fastestIndex.created()) {
@@ -21944,10 +21979,132 @@ var QueryPlanner = class {
     };
   }
 };
-var generatePermutations = (list) => {
-  if (list.length === 1)
-    return [list];
-  return [list, [...list].reverse()];
+var queryKeyToColumnName = (key) => {
+  if (key.length > 2) {
+    return `${key.slice(0, -1).join("_")}__${key[key.length - 1]}`;
+  }
+  return key.join("__");
+};
+var pushUniqueColumn = (list, column) => {
+  const key = getIndexColumnKey(column);
+  if (!list.some((x) => getIndexColumnKey(x) === key)) {
+    list.push(column);
+  }
+};
+var pushColumns = (target, columns) => {
+  for (const column of columns) {
+    pushUniqueColumn(target, column);
+  }
+};
+var getIndexableQueryColumns = (query, availableColumns) => {
+  const equality = [];
+  const range = [];
+  const visit = (item, path = []) => {
+    if (item instanceof And) {
+      for (const condition of item.and) {
+        visit(condition, path);
+      }
+      return;
+    }
+    if (item instanceof Or) {
+      for (const condition of item.or) {
+        visit(condition, path);
+      }
+      return;
+    }
+    if (item instanceof Not) {
+      return;
+    }
+    if (item instanceof Nested) {
+      for (const condition of item.query) {
+        visit(condition, [...path, ...item.path]);
+      }
+      return;
+    }
+    let key;
+    let target;
+    let collation;
+    if (item instanceof IntegerCompare) {
+      key = item.key;
+      target = item.compare === Compare.Equal ? equality : range;
+    } else if (item instanceof StringMatch) {
+      key = item.key;
+      if (item.method === StringMatchMethod.contains) {
+        return;
+      }
+      target = item.method === StringMatchMethod.exact ? equality : range;
+      collation = item.caseInsensitive ? "NOCASE" : void 0;
+    } else if (item instanceof ByteMatchQuery || item instanceof BoolQuery || item instanceof IsNull) {
+      key = item.key;
+      target = equality;
+    }
+    if (!key || !target) {
+      return;
+    }
+    const columnName = queryKeyToColumnName([...path, ...key]);
+    if (availableColumns.has(columnName)) {
+      pushUniqueColumn(target, { name: columnName, collation });
+    }
+  };
+  for (const item of query) {
+    visit(item);
+  }
+  return { equality, range };
+};
+var getSortableColumns = (sort, availableColumns) => {
+  const out = [];
+  for (const item of sort) {
+    const columnName = queryKeyToColumnName(item.key);
+    if (availableColumns.has(columnName)) {
+      pushUniqueColumn(out, { name: columnName });
+    }
+  }
+  return out;
+};
+var normalizeCandidate = (columns) => {
+  const out = [];
+  pushColumns(out, columns);
+  return out;
+};
+var generateIndexCandidates = (query, columns) => {
+  if (columns.length === 0) {
+    return [];
+  }
+  const availableColumns = new Set(columns);
+  const { equality, range } = getIndexableQueryColumns(query.query, availableColumns);
+  const sort = getSortableColumns(query.sort, availableColumns);
+  const join = availableColumns.has(PARENT_TABLE_ID2) ? [{ name: PARENT_TABLE_ID2 }] : [];
+  const knownColumnNames = new Set([...join, ...equality, ...range, ...sort].map((x) => x.name));
+  const remaining = columns.filter((column) => !knownColumnNames.has(column)).map((name) => ({ name }));
+  const candidates = [];
+  const pushCandidate = (...parts) => {
+    const candidate = normalizeCandidate(parts.flat());
+    if (candidate.length > 0 && !candidates.some((existing) => existing.map(getIndexColumnKey).join(",") === candidate.map(getIndexColumnKey).join(","))) {
+      candidates.push(candidate);
+    }
+  };
+  if (sort.length > 0 && range.length > 0) {
+    pushCandidate(join, equality, sort, range, remaining);
+    pushCandidate(join, equality, range, sort, remaining);
+  } else if (sort.length > 0) {
+    pushCandidate(join, equality, sort, range, remaining);
+  } else {
+    if (join.length > 0 && (equality.length > 0 || range.length > 0)) {
+      pushCandidate(equality, range, join, remaining);
+    }
+    pushCandidate(join, equality, range, remaining);
+  }
+  if (join.length > 0 && (equality.length > 0 || range.length > 0)) {
+    if (sort.length > 0 && range.length > 0) {
+      pushCandidate(equality, sort, range, join, remaining);
+      pushCandidate(equality, range, sort, join, remaining);
+    } else if (sort.length > 0) {
+      pushCandidate(equality, range, sort, join, remaining);
+    }
+  }
+  pushCandidate(columns.map((name) => ({ name })));
+  pushCandidate([...columns].reverse().map((name) => ({ name })));
+  return candidates;
 };
 
 // dist/src/utils.js
@@ -22013,13 +22170,16 @@ var createBatchInsertSQL = (table, rows) => {
     length: rows
   }).map(() => rowPlaceholder).join(", ")};`;
 };
+var createInsertReturningSQL = (table) => `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
+var createInsertKnownIdSQL = (table) => `insert into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
+var createReplaceSQL = (table) => `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
 var canUseWithoutRowId = (table) => {
   if (table.inline || table.primary === false || !table.primaryField) {
     return false;
   }
   return !/^INTEGER\b/i.test(table.primaryField.type);
 };
-var SQLiteIndex = class {
+var SQLiteIndex = class _SQLiteIndex {
   properties;
   // SQLite writes are inherently serialized per connection.
   // We still need an explicit async barrier because our API is async and
@@ -22049,13 +22209,14 @@ var SQLiteIndex = class {
   primaryKeyString;
   planner;
   scopeString;
-  _rootTables;
-  _tables;
-  _cursor;
+  _rootTables = [];
+  _tables = /* @__PURE__ */ new Map();
+  _cursor = /* @__PURE__ */ new Map();
   // TODO choose limit better
   cursorPruner;
   iteratorTimeout;
   closed = true;
+  state = "closed";
   fkMode;
   id;
   constructor(properties, options) {
@@ -22072,21 +22233,74 @@ var SQLiteIndex = class {
   persisted() {
     return this.properties.persisted ?? true;
   }
+  static _emptyTables = /* @__PURE__ */ new Map();
+  static _emptyRootTables = [];
+  static _emptyCursor = /* @__PURE__ */ new Map();
+  static closedIterator() {
+    return {
+      all: async () => [],
+      close: async () => void 0,
+      done: () => true,
+      next: async () => [],
+      pending: async () => 0
+    };
+  }
+  async ifOpen(fallback, fn) {
+    if (this.isClosing()) {
+      return fallback;
+    }
+    this.assertOpen();
+    try {
+      return await fn();
+    } catch (error2) {
+      if (this.isClosing()) {
+        return fallback;
+      }
+      throw error2;
+    }
+  }
+  async withWriteIfOpen(fallback, fn) {
+    if (this.isClosing()) {
+      return fallback;
+    }
+    this.assertOpen();
+    return this.withWriteBarrier(() => this.ifOpen(fallback, fn));
+  }
+  assertOpen() {
+    if (this.state !== "open") {
+      throw new NotStartedError();
+    }
+  }
+  isClosing() {
+    return this.state === "closing";
+  }
+  setClosing() {
+    this.state = "closing";
+    this.closed = true;
+  }
+  setClosed() {
+    this.state = "closed";
+    this.closed = true;
+  }
+  setOpen() {
+    this.state = "open";
+    this.closed = false;
+  }
   get tables() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyTables;
     }
     return this._tables;
   }
   get rootTables() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyRootTables;
     }
     return this._rootTables;
   }
   get cursor() {
     if (this.closed) {
-      throw new NotStartedError();
+      return _SQLiteIndex._emptyCursor;
     }
     return this._cursor;
   }
@@ -22107,9 +22321,12 @@ var SQLiteIndex = class {
     return this;
   }
   async start() {
-    if (this.closed === false) {
+    if (this.state === "open") {
       return;
     }
+    if (this.state === "closing") {
+      throw new NotStartedError();
+    }
     if (this.primaryKeyArr == null || this.primaryKeyArr.length === 0) {
       throw new Error("Not initialized");
     }
@@ -22127,6 +22344,8 @@ var SQLiteIndex = class {
     );
     this._rootTables = tables.filter((x) => x.parent == null);
     const allTables = tables;
+    const startupStatements = [];
+    const startupTableStatements = /* @__PURE__ */ new Map();
     for (const table of allTables) {
       this._tables.set(table.name, table);
       for (const child of table.children) {
@@ -22137,15 +22356,38 @@ var SQLiteIndex = class {
       }
       const tableOptions = canUseWithoutRowId(table) ? " strict, without rowid" : " strict";
       const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")})${tableOptions}`;
-      this.properties.db.exec(sqlCreateTable);
-      let sqlPut = `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
-      let sqlInsertKnownId = `insert into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-      let sqlReplace = `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
-      await this.properties.db.prepare(sqlPut, putStatementKey(table));
-      await this.properties.db.prepare(sqlInsertKnownId, insertKnownIdStatementKey(table));
-      await this.properties.db.prepare(sqlReplace, replaceStatementKey(table));
+      startupTableStatements.set(table.name, sqlCreateTable);
+      startupStatements.push({
+        id: putStatementKey(table),
+        sql: createInsertReturningSQL(table)
+      }, {
+        id: insertKnownIdStatementKey(table),
+        sql: createInsertKnownIdSQL(table)
+      }, {
+        id: replaceStatementKey(table),
+        sql: createReplaceSQL(table)
+      });
       if (table.parent) {
-        await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
+        startupStatements.push({
+          id: resolveChildrenStatement(table),
+          sql: selectChildren(table)
+        });
+      }
+    }
+    if (startupTableStatements.size > 0) {
+      const existingTables = await this.getExistingSQLiteObjects("table", [
+        ...startupTableStatements.keys()
+      ]);
+      const missingTableStatements = [...startupTableStatements.entries()].filter(([tableName]) => !existingTables.has(tableName)).map(([, sql]) => sql);
+      if (missingTableStatements.length > 0) {
+        await this.properties.db.exec(missingTableStatements.join(";"));
+      }
+    }
+    if (this.properties.db.prepareMany) {
+      await this.properties.db.prepareMany(startupStatements);
+    } else {
+      for (const statement of startupStatements) {
+        await this.properties.db.prepare(statement.sql, statement.id);
       }
     }
     this.cursorPruner = setInterval(() => {
@@ -22156,7 +22398,17 @@ var SQLiteIndex = class {
         }
       }
     }, this.iteratorTimeout);
-    this.closed = false;
+    this.setOpen();
+  }
+  async getExistingSQLiteObjects(type, names) {
+    if (names.length === 0) {
+      return /* @__PURE__ */ new Set();
+    }
+    const sql = `select name from sqlite_master where type = ? and name in (${names.map(() => "?").join(", ")})`;
+    const statement = this.properties.db.statements.get(sql) || await this.properties.db.prepare(sql, sql);
+    const rows = await statement.all([type, ...names]);
+    await statement.reset?.();
+    return new Set(rows.map((row) => row.name).filter((name) => typeof name === "string"));
   }
   async clearStatements() {
     if (await this.properties.db.status() === "closed") {
@@ -22164,52 +22416,82 @@ var SQLiteIndex = class {
     }
   }
   async stop() {
-    if (this.closed) {
+    if (this.state === "closed") {
       return;
     }
-    this.closed = true;
-    clearInterval(this.cursorPruner);
-    await this.clearStatements();
-    this._tables.clear();
-    for (const [k, _v] of this._cursor) {
-      await this.clearupIterator(k);
-    }
-    await this.planner.stop();
-  }
-  async drop() {
-    if (!this.closed) {
-      this.closed = true;
+    if (this.state === "closing") {
+      await this._writeBarrier.catch(() => void 0);
+      return;
     }
-    if (this.cursorPruner != null) {
+    this.setClosing();
+    try {
       clearInterval(this.cursorPruner);
-      this.cursorPruner = void 0;
-    }
-    const status = await this.properties.db.status?.();
-    if (status === "closed") {
-      this._tables.clear();
-      return;
+      await this._writeBarrier.catch(() => void 0);
+      await this.clearStatements();
+      this._tables?.clear();
+      if (this._cursor) {
+        for (const [k, _v] of this._cursor) {
+          await this.clearupIterator(k);
+        }
+      }
+      await this.planner.stop();
+    } finally {
+      this.setClosed();
     }
-    await this.clearStatements();
-    for (const table of this._rootTables) {
-      await this.properties.db.exec(`drop table if exists ${table.name}`);
+  }
+  async drop() {
+    const wasOpen = this.state === "open";
+    if (wasOpen) {
+      this.setClosing();
     }
-    this._tables.clear();
-    for (const [k, _v] of this._cursor) {
-      await this.clearupIterator(k);
+    try {
+      if (this.cursorPruner != null) {
+        clearInterval(this.cursorPruner);
+        this.cursorPruner = void 0;
+      }
+      if (wasOpen) {
+        await this._writeBarrier.catch(() => void 0);
+      }
+      const status = await this.properties.db.status?.();
+      if (status === "closed") {
+        this._tables?.clear();
+        return;
+      }
+      await this.clearStatements();
+      if (this._rootTables) {
+        for (const table of this._rootTables) {
+          await this.properties.db.exec(`drop table if exists ${table.name}`);
+        }
+      }
+      this._tables?.clear();
+      if (this._cursor) {
+        for (const [k, _v] of this._cursor) {
+          await this.clearupIterator(k);
+        }
+      }
+      await this.planner.stop();
+    } finally {
+      this.setClosed();
     }
-    await this.planner.stop();
   }
   async resolveDependencies(parentId, table) {
-    const stmt = this.properties.db.statements.get(resolveChildrenStatement(table));
+    const stmt = await this.getOrPrepareStatement(resolveChildrenStatement(table), selectChildren(table));
     const results = await stmt.all([parentId]);
     await stmt.reset?.();
     return results;
   }
+  async getOrPrepareStatement(key, sql) {
+    const existing = this.properties.db.statements.get(key);
+    if (existing) {
+      return existing;
+    }
+    return this.properties.db.prepare(sql, key);
+  }
   async get(id, options) {
-    for (const table of this._rootTables) {
-      const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
-      const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
-      try {
+    return this.ifOpen(void 0, async () => {
+      for (const table of this._rootTables) {
+        const { join: joinMap, selects } = selectAllFieldsFromTable(table, options?.shape);
+        const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${table.name}.${this.primaryKeyString} = ? limit 1`;
         const stmt = await this.properties.db.prepare(sql, sql);
         const rows = await stmt.get([
           table.primaryField?.from?.type ? convertToSQLType(id.key, table.primaryField.from.type) : id.key
@@ -22221,17 +22503,12 @@ var SQLiteIndex = class {
           value: await resolveInstanceFromValue(rows, this.tables, table, this.resolveDependencies.bind(this), true, options?.shape),
           id
         };
-      } catch (error2) {
-        if (this.closed) {
-          throw new NotStartedError();
-        }
-        throw error2;
       }
-    }
-    return void 0;
+      return void 0;
+    });
   }
   async put(value, _id, options) {
-    return this.withWriteBarrier(async () => {
+    return this.withWriteIfOpen(void 0, async () => {
       const classOfValue = value.constructor;
       return insert(async (values, table) => {
         let preId = values[table.primaryIndex];
@@ -22240,7 +22517,7 @@ var SQLiteIndex = class {
           if (preId != null) {
             const shouldReplace = options?.replace ?? true;
             if (!shouldReplace) {
-              statement = this.properties.db.statements.get(insertKnownIdStatementKey(table));
+              statement = await this.getOrPrepareStatement(insertKnownIdStatementKey(table), createInsertKnownIdSQL(table));
               try {
                 this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
               } catch (error2) {
@@ -22248,16 +22525,16 @@ var SQLiteIndex = class {
                   throw error2;
                 }
                 await statement.reset?.();
-                statement = this.properties.db.statements.get(replaceStatementKey(table));
+                statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
                 this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
               }
             } else {
-              statement = this.properties.db.statements.get(replaceStatementKey(table));
+              statement = await this.getOrPrepareStatement(replaceStatementKey(table), createReplaceSQL(table));
               this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
             }
             return preId;
           } else {
-            statement = this.properties.db.statements.get(putStatementKey(table));
+            statement = await this.getOrPrepareStatement(putStatementKey(table), createInsertReturningSQL(table));
             const out = this.fkMode === "race-tolerant" ? await getIgnoreFK(statement, values) : await statement.get(values);
             if (out == null) {
               return void 0;
@@ -22284,6 +22561,10 @@ var SQLiteIndex = class {
     });
   }
   iterate(request, options) {
+    if (this.isClosing()) {
+      return _SQLiteIndex.closedIterator();
+    }
+    this.assertOpen();
     let offset = 0;
     let once = false;
     let requestId = v4_default();
@@ -22298,43 +22579,60 @@ var SQLiteIndex = class {
     });
     let planningScope;
     const fetch2 = async (amount) => {
-      kept = void 0;
-      if (!once) {
-        planningScope = this.planner.scope(normalizedQuery);
-        let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
-          planner: planningScope,
-          shape: options?.shape,
-          fetchAll: amount === "all"
-          // if we are to fetch all, we dont need stable sorting
-        });
-        sqlFetch = sql;
-        bindable = toBind;
-        await planningScope.beforePrepare();
-        stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
-        iterator.expire = Date.now() + this.iteratorTimeout;
-      }
-      once = true;
-      const allResults = await planningScope.perform(async () => {
-        const allResults2 = await stmt.all([
-          ...bindable,
-          ...amount !== "all" ? [amount, offset] : []
-        ]);
-        return allResults2;
-      });
-      let results = await Promise.all(allResults.map(async (row) => {
-        let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] != null);
-        const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
-        return {
-          value,
-          id: toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type))
-        };
-      }));
-      offset += results.length;
-      if (amount === "all" || results.length < amount) {
+      const closeAsDone = () => {
+        once = true;
         hasMore = false;
-        await this.clearupIterator(requestId);
+        kept = 0;
+        return [];
+      };
+      if (this.isClosing()) {
+        return closeAsDone();
+      }
+      this.assertOpen();
+      try {
+        kept = void 0;
+        if (!once) {
+          planningScope = this.planner.scope(normalizedQuery);
+          let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
+            planner: planningScope,
+            shape: options?.shape,
+            fetchAll: amount === "all"
+            // if we are to fetch all, we dont need stable sorting
+          });
+          sqlFetch = sql;
+          bindable = toBind;
+          await planningScope.beforePrepare();
+          stmt = await this.properties.db.prepare(sqlFetch, sqlFetch);
+          iterator.expire = Date.now() + this.iteratorTimeout;
+        }
+        once = true;
+        const allResults = await planningScope.perform(async () => {
+          const allResults2 = await stmt.all([
+            ...bindable,
+            ...amount !== "all" ? [amount, offset] : []
+          ]);
+          return allResults2;
+        });
+        let results = await Promise.all(allResults.map(async (row) => {
+          let selectedTable = this._rootTables.find((table) => row[getTablePrefixedField(table, this.primaryKeyString)] != null);
+          const value = await resolveInstanceFromValue(row, this.tables, selectedTable, this.resolveDependencies.bind(this), true, options?.shape);
+          return {
+            value,
+            id: toId(convertFromSQLType(row[getTablePrefixedField(selectedTable, this.primaryKeyString)], selectedTable.primaryField.from.type))
+          };
+        }));
+        offset += results.length;
+        if (amount === "all" || results.length < amount) {
+          hasMore = false;
+          await this.clearupIterator(requestId);
+        }
+        return results;
+      } catch (error2) {
+        if (this.isClosing()) {
+          return closeAsDone();
+        }
+        throw error2;
       }
-      return results;
     };
     const iterator = {
       fetch: fetch2,
@@ -22356,12 +22654,20 @@ var SQLiteIndex = class {
         return results;
       },
       close: () => {
+        once = true;
         hasMore = false;
         kept = 0;
         this.clearupIterator(requestId);
       },
       next: (amount) => fetch2(amount),
       pending: async () => {
+        if (this.isClosing()) {
+          once = true;
+          hasMore = false;
+          kept = 0;
+          return 0;
+        }
+        this.assertOpen();
         if (!hasMore) {
           return 0;
         }
@@ -22373,7 +22679,12 @@ var SQLiteIndex = class {
         hasMore = kept > 0;
         return kept;
       },
-      done: () => once ? !hasMore : void 0
+      done: () => {
+        if (this.isClosing()) {
+          return true;
+        }
+        return once ? !hasMore : void 0;
+      }
     };
   }
   async clearupIterator(id) {
@@ -22384,21 +22695,29 @@ var SQLiteIndex = class {
     this._cursor.delete(id);
   }
   async getSize() {
-    if (this.tables.size === 0) {
-      return 0;
-    }
-    return this.count();
+    return this.ifOpen(0, async () => {
+      if (this.tables.size === 0) {
+        return 0;
+      }
+      return this.count();
+    });
   }
   async del(query) {
-    return this.withWriteBarrier(async () => {
+    return this.withWriteIfOpen([], async () => {
       let ret = [];
       let once = false;
       let lastError = void 0;
       for (const table of this._rootTables) {
         try {
-          const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
+          const planningScope = this.planner.scope(new PlannableQuery({
+            query: coerceLocalQueries(query.query)
+          }));
+          const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table, {
+            planner: planningScope
+          });
+          await planningScope.beforePrepare();
           const stmt = await this.properties.db.prepare(sql, sql);
-          const results = await stmt.all(bindable);
+          const results = await planningScope.perform(async () => stmt.all(bindable));
           for (const result of results) {
             ret.push(toId(convertFromSQLType(result[table.primary], table.primaryField.from.type)));
           }
@@ -22418,69 +22737,79 @@ var SQLiteIndex = class {
     });
   }
   async sum(query) {
-    let ret = void 0;
-    let once = false;
-    let lastError = void 0;
-    let inlinedName = getInlineTableFieldName(query.key);
-    for (const table of this._rootTables) {
-      try {
-        if (table.fields.find((x) => x.name === inlinedName) == null) {
-          lastError = new MissingFieldError("Missing field: " + (Array.isArray(query.key) ? query.key : [query.key]).join("."));
-          continue;
-        }
-        const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table);
-        const stmt = await this.properties.db.prepare(sql, sql);
-        const result = await stmt.get(bindable);
-        if (result != null) {
-          const value = result.sum;
-          if (ret == null) {
-            ret = value;
-          } else {
-            ret += value;
+    return this.ifOpen(0, async () => {
+      let ret = void 0;
+      let once = false;
+      let lastError = void 0;
+      let inlinedName = getInlineTableFieldName(query.key);
+      for (const table of this._rootTables) {
+        try {
+          if (table.fields.find((x) => x.name === inlinedName) == null) {
+            lastError = new MissingFieldError("Missing field: " + (Array.isArray(query.key) ? query.key : [query.key]).join("."));
+            continue;
           }
-          once = true;
-        }
-      } catch (error2) {
-        if (error2 instanceof MissingFieldError) {
-          lastError = error2;
-          continue;
+          const planningScope = this.planner.scope(new PlannableQuery({
+            query: coerceLocalQueries(query.query)
+          }));
+          const { sql, bindable } = convertSumRequestToQuery(query, this.tables, table, {
+            planner: planningScope
+          });
+          await planningScope.beforePrepare();
+          const stmt = await this.properties.db.prepare(sql, sql);
+          const result = await planningScope.perform(async () => stmt.get(bindable));
+          if (result != null) {
+            const value = result.sum;
+            if (ret == null) {
+              ret = value;
+            } else {
+              ret += value;
+            }
+            once = true;
+          }
+        } catch (error2) {
+          if (error2 instanceof MissingFieldError) {
+            lastError = error2;
+            continue;
+          }
+          throw error2;
         }
-        throw error2;
       }
-    }
-    if (!once) {
-      throw lastError;
-    }
-    return ret != null ? ret : 0;
+      if (!once) {
+        throw lastError;
+      }
+      return ret != null ? ret : 0;
+    });
   }
   async count(request) {
-    let ret = 0;
-    let once = false;
-    let lastError = void 0;
-    for (const table of this._rootTables) {
-      try {
-        const { sql, bindable } = convertCountRequestToQuery(request, this.tables, table);
-        const stmt = await this.properties.db.prepare(sql, sql);
-        const result = await stmt.get(bindable);
-        if (result != null) {
-          ret += Number(result.count);
-          once = true;
-        }
-      } catch (error2) {
-        if (error2 instanceof MissingFieldError) {
-          lastError = error2;
-          continue;
+    return this.ifOpen(0, async () => {
+      let ret = 0;
+      let once = false;
+      let lastError = void 0;
+      for (const table of this._rootTables) {
+        try {
+          const { sql, bindable } = convertCountRequestToQuery(request, this.tables, table);
+          const stmt = await this.properties.db.prepare(sql, sql);
+          const result = await stmt.get(bindable);
+          if (result != null) {
+            ret += Number(result.count);
+            once = true;
+          }
+        } catch (error2) {
+          if (error2 instanceof MissingFieldError) {
+            lastError = error2;
+            continue;
+          }
+          throw error2;
         }
-        throw error2;
       }
-    }
-    if (!once) {
-      throw lastError;
-    }
-    return ret;
+      if (!once) {
+        throw lastError;
+      }
+      return ret;
+    });
   }
   get cursorCount() {
-    return this.cursor.size;
+    return this.closed ? 0 : this._cursor.size;
   }
 };
 var SQLiteIndices = class _SQLiteIndices {
@@ -22539,7 +22868,10 @@ var SQLiteIndices = class _SQLiteIndices {
   async start() {
     this.closed = false;
     if (!this.properties.parent) {
-      await this.properties.db.open();
+      const status = await this.properties.db.status();
+      if (status !== "open") {
+        await this.properties.db.open();
+      }
     }
     for (const scope of this.scopes.values()) {
       await scope.start();
@@ -22830,7 +23162,6 @@ var create = async (directory, options) => {
         directory: poolDirectory
       });
       poolUtil = activePoolUtil;
-      await activePoolUtil.reserveMinimumCapacity(100);
       sqliteDb = new activePoolUtil.OpfsSAHPoolDb(dbFileName);
     } else {
       sqliteDb = new sqlite32.oo1.DB(":memory:");
@@ -23087,6 +23418,27 @@ var ProxyDatabase = class {
     }
     return statement;
   }
+  async prepareMany(statements) {
+    if (statements.length === 0) {
+      return [];
+    }
+    const missing = statements.filter((statement) => !this.statements.get(statement.id));
+    if (missing.length > 0) {
+      const statementIds = await this.send({
+        type: "prepare-many",
+        statements: missing,
+        id: v4_default(),
+        databaseId: this.databaseId
+      });
+      for (const [index, statementId] of statementIds.entries()) {
+        const definition = missing[index];
+        const statement = new ProxyStatement(this.send.bind(this), this.databaseId, statementId, definition.sql, this.options);
+        this.statements.set(statementId, statement);
+        this.statements.set(definition.id, statement);
+      }
+    }
+    return statements.map((statement) => this.statements.get(statement.id));
+  }
   async open() {
     return this.send({ type: "open", id: v4_default(), databaseId: this.databaseId });
   }