@peerbit/indexer-sqlite3 1.1.3 → 1.1.4-5cf61cb

package/dist/peerbit/sqlite3.min.js

@@ -7234,6 +7234,7 @@ function hashBlocks(w, v2, p, pos, len) {
 
 // ../../crypto/dist/src/utils.js
 var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
+var fromHexString = (hexString) => import_libsodium_wrappers.default.from_hex(hexString);
 var toHexString = (bytes) => import_libsodium_wrappers.default.to_hex(bytes);
 var toBase64 = (arr) => {
   return import_libsodium_wrappers.default.to_base64(arr, import_libsodium_wrappers.default.base64_variants.ORIGINAL);
@@ -7243,6 +7244,7 @@ var toBase58 = (arr) => {
 };
 
 // ../../crypto/dist/src/hash.browser.js
+var sha256Base64Sync = (bytes) => toBase64(new SHA256().update(bytes).digest());
 var sha256Sync = (bytes) => new SHA256().update(bytes).digest();
 
 // ../../../../node_modules/uint8-varint/dist/src/index.js
@@ -7409,7 +7411,7 @@ var UnsignedIntegerValue = class UnsignedIntegerValue2 extends IntegerValue {
   constructor(number) {
     super();
     if (!Number.isInteger(number) || number > 4294967295 || number < 0) {
-      throw new Error("Number is not u32");
+      throw new Error("Number is not u32: " + number);
     }
     this.number = number;
   }
@@ -7870,7 +7872,7 @@ var Nested = class Nested2 extends Query {
   query;
   constructor(props) {
     super();
-    this.path = props.path;
+    this.path = Array.isArray(props.path) ? props.path : [props.path];
     this.id = props.id ?? v4_default();
     this.query = toQuery(props.query);
   }
@@ -7880,8 +7882,8 @@ __decorate2([
   __metadata2("design:type", String)
 ], Nested.prototype, "id", void 0);
 __decorate2([
-  field({ type: "string" }),
-  __metadata2("design:type", String)
+  field({ type: vec("string") }),
+  __metadata2("design:type", Array)
 ], Nested.prototype, "path", void 0);
 __decorate2([
   field({ type: vec(Query) }),
@@ -7952,6 +7954,35 @@ var getIdProperty = (clazz) => {
   return [property];
 };
 
+// ../interface/dist/src/errors.js
+var NotStartedError = class extends Error {
+  constructor() {
+    super("Not started");
+  }
+};
+
+// ../../time/dist/src/hrtime.browser.js
+var hrtime = (previousTimestamp) => {
+  const baseNow = Math.floor((Date.now() - performance.now()) * 1e-3);
+  const clocktime = performance.now() * 1e-3;
+  let seconds = Math.floor(clocktime) + baseNow;
+  let nanoseconds = Math.floor(clocktime % 1 * 1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += 1e9;
+    }
+  }
+  return [seconds, nanoseconds];
+};
+var NS_PER_SEC = 1e9;
+hrtime.bigint = (time) => {
+  const diff = hrtime(time);
+  return BigInt(diff[0] * NS_PER_SEC + diff[1]);
+};
+
 // dist/src/schema.js
 var __decorate3 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -7979,6 +8010,8 @@ var SQLConversionMap = {
   Date: "TEXT"
 };
 var WRAPPED_SIMPLE_VALUE_VARIANT = "wrapped";
+var JSON_GROUP_ARRAY = "json_group_array";
+var JSON_OBJECT = "distinct json_object";
 var u64ToI64 = (u64) => {
   return (typeof u64 === "number" ? BigInt(u64) : u64) - 9223372036854775808n;
 };
@@ -7995,7 +8028,7 @@ var convertToSQLType = (value, type) => {
   return value;
 };
 var nullAsUndefined = (value) => value === null ? void 0 : value;
-var escapeColumnName = (name) => `"${name}"`;
+var escapeColumnName = (name, char = '"') => `${char}${name}${char}`;
 var MissingFieldError = class extends Error {
   constructor(message) {
     super(message);
@@ -8066,7 +8099,8 @@ var getSQLTable = (ctor, path, primary, inline, addJoinField, fromOptionalField
       parent: void 0,
       referencedInArray: false,
       isSimpleValue: false,
-      inline
+      inline,
+      indices: /* @__PURE__ */ new Set()
     };
     ret.push(table);
     for (const dep of dependencies) {
@@ -8092,8 +8126,18 @@ var getNameOfClass = (ctor) => {
   return name;
 };
 var getTableName = (path = [], clazz) => {
+  let pathKey = path.length > 0 ? path.join("__") + "__" : "";
+  if (typeof clazz !== "string") {
+    const tableName = clazz["__table_" + pathKey];
+    if (tableName) {
+      return tableName;
+    }
+  }
   let name = typeof clazz === "string" ? clazz : getNameOfClass(clazz);
-  const ret = (path.length > 0 ? path.join("__") + "__" : "") + name.replace(/[^a-zA-Z0-9_]/g, "_");
+  const ret = pathKey + name.replace(/[^a-zA-Z0-9_]/g, "_");
+  if (typeof clazz !== "string") {
+    clazz["__table_" + pathKey] = ret;
+  }
   return ret;
 };
 var CHILD_TABLE_ID = "__id";
@@ -8113,9 +8157,9 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
   const sqlConstraints = [];
   let foundPrimary = false;
   const addJoinFields = primary === false ? addJoinFieldFromParent : (fields2, contstraints) => {
-    const primaryField = primary != null ? sqlFields.find((field2) => field2.name === primary) : void 0;
-    const parentPrimaryFieldName = primaryField?.key || CHILD_TABLE_ID;
-    const parentPrimaryFieldType = primaryField ? primaryField.type : "INTEGER";
+    const parentPrimaryField = primary != null ? sqlFields.find((field2) => field2.name === primary) : void 0;
+    const parentPrimaryFieldName = parentPrimaryField?.key || CHILD_TABLE_ID;
+    const parentPrimaryFieldType = parentPrimaryField ? parentPrimaryField.type : "INTEGER";
     fields2.unshift(
       {
         name: CHILD_TABLE_ID,
@@ -8124,6 +8168,7 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
         type: "INTEGER",
         isPrimary: true,
         from: void 0,
+        unwrappedType: void 0,
         path: [CHILD_TABLE_ID]
       },
       // foreign key parent document
@@ -8132,8 +8177,9 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
         key: PARENT_TABLE_ID,
         definition: `${PARENT_TABLE_ID} ${parentPrimaryFieldType}`,
         type: parentPrimaryFieldType,
+        from: parentPrimaryField?.from,
+        unwrappedType: parentPrimaryField?.unwrappedType,
         isPrimary: false,
-        from: void 0,
         path: [PARENT_TABLE_ID]
       }
     );
@@ -8191,6 +8237,7 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
               type: "INTEGER",
               isPrimary: false,
               from: void 0,
+              unwrappedType: void 0,
               path: [ARRAY_INDEX_COLUMN]
             },
             ...table.fields.slice(2)
@@ -8213,6 +8260,7 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
       type: fieldType,
       isPrimary,
       from: field2,
+      unwrappedType: unwrapNestedType(field2.type),
       path: [...path.slice(1), key]
     });
   };
@@ -8274,6 +8322,7 @@ var getSQLFields = (tableName, path, ctor, primary, addJoinFieldFromParent, tabl
         type: "bool",
         isPrimary: false,
         from: void 0,
+        unwrappedType: void 0,
         path: [...path.slice(1), key],
         describesExistenceOfAnother: path[path.length - 1]
       });
@@ -8358,7 +8407,7 @@ var getTableFromValue = (parentTable, tables, field2, value) => {
         continue;
       }
       if (ctor) {
-        clazzName = getNameOfClass(ctor);
+        clazzName = ctor;
         break;
       }
     }
@@ -8437,14 +8486,14 @@ var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback,
           for (const _field of subTable.fields) {
             bindableValues.push(null);
           }
-          bindableValues[bindableValues.length - 1] = false;
+          bindableValues[bindableValues.length - 1] = 0;
           continue;
         }
         await insert((values, table2) => {
           if (table2.inline) {
             bindableValues.push(...values);
             if (field2.type instanceof OptionKind) {
-              bindableValues.push(true);
+              bindableValues.push(1);
             }
             return void 0;
           } else {
@@ -8513,13 +8562,13 @@ var matchFieldInShape = (shape, path, field2) => {
 };
 var selectChildren = (childrenTable) => "select * from " + childrenTable.name + " where " + PARENT_TABLE_ID + " = ?";
 var generateSelectQuery = (table, selects) => {
-  return `SELECT ${selects.map((x) => `${x.from} as ${x.as}`).join(", ")} FROM ${table.name}`;
+  return `select ${selects.map((x) => `${x.from} as ${x.as}`).join(", ")} FROM ${table.name}`;
 };
 var selectAllFieldsFromTables = (tables, shape) => {
   const selectsPerTable = [];
   for (const table of tables) {
-    const { selects, join: joinFromSelect } = selectAllFieldsFromTable(table, shape);
-    selectsPerTable.push({ selects, joins: joinFromSelect });
+    const { selects, join: joinFromSelect, groupBy } = selectAllFieldsFromTable(table, shape);
+    selectsPerTable.push({ selects, joins: joinFromSelect, groupBy });
   }
   let newSelects = [];
   for (const [i, selects] of selectsPerTable.entries()) {
@@ -8544,8 +8593,50 @@ var selectAllFieldsFromTable = (table, shape) => {
   let stack = [{ table, shape }];
   let join = /* @__PURE__ */ new Map();
   const fieldResolvers = [];
+  let groupByParentId = false;
   for (const tableAndShape of stack) {
-    if (!tableAndShape.table.inline) {
+    if (tableAndShape.table.referencedInArray) {
+      let selectBuilder = `${JSON_GROUP_ARRAY}(${JSON_OBJECT}(`;
+      groupByParentId = true;
+      let first = false;
+      const as = createReconstructReferenceName(tableAndShape.table);
+      for (const field2 of tableAndShape.table.fields) {
+        if ((field2.isPrimary || !tableAndShape.shape || matchFieldInShape(tableAndShape.shape, [], field2) || // also always include the index field
+        field2.name === ARRAY_INDEX_COLUMN) && field2.name !== PARENT_TABLE_ID) {
+          let resolveField = `${as}.${escapeColumnName(field2.name)}`;
+          if (field2.unwrappedType === "u64") {
+            resolveField = `CAST(${resolveField} AS TEXT)`;
+          }
+          if (field2.type === "BLOB") {
+            resolveField = `HEX(${resolveField})`;
+          }
+          if (first) {
+            selectBuilder += `, `;
+          }
+          first = true;
+          selectBuilder += `${escapeColumnName(field2.name, "'")}, ${resolveField}`;
+        }
+      }
+      selectBuilder += `))  `;
+      fieldResolvers.push({
+        from: selectBuilder,
+        as
+      });
+      join.set(createReconstructReferenceName(tableAndShape.table), {
+        as,
+        table: tableAndShape.table,
+        type: "left",
+        columns: []
+      });
+    } else if (!tableAndShape.table.inline) {
+      if (tableAndShape.table.parent != null) {
+        join.set(createReconstructReferenceName(tableAndShape.table), {
+          as: tableAndShape.table.name,
+          table: tableAndShape.table,
+          type: "left",
+          columns: []
+        });
+      }
       for (const field2 of tableAndShape.table.fields) {
         if (field2.isPrimary || !tableAndShape.shape || matchFieldInShape(tableAndShape.shape, [], field2)) {
           fieldResolvers.push({
@@ -8556,9 +8647,6 @@ var selectAllFieldsFromTable = (table, shape) => {
       }
     }
     for (const child of tableAndShape.table.children) {
-      if (child.referencedInArray) {
-        continue;
-      }
       let childShape = void 0;
       if (tableAndShape.shape) {
         const parentPath = child.parentPath?.slice(1);
@@ -8569,15 +8657,13 @@ var selectAllFieldsFromTable = (table, shape) => {
         childShape = maybeShape === true ? void 0 : Array.isArray(maybeShape) ? maybeShape[0] : maybeShape;
       }
       stack.push({ table: child, shape: childShape });
-      if (!child.inline) {
-        join.set(child.name, { as: child.name, table: child });
-      }
     }
   }
   if (fieldResolvers.length === 0) {
     throw new Error("No fields to resolve");
   }
   return {
+    groupBy: groupByParentId ? `${table.name}.${escapeColumnName(table.primary)}` || void 0 : void 0,
     selects: fieldResolvers,
     //  `SELECT ${fieldResolvers.join(", ")} FROM ${table.name}`,
     join
@@ -8605,13 +8691,37 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
     }
     let subshape = maybeShape === true ? void 0 : subshapeIsArray ? maybeShape[0] : maybeShape;
     if (isArray) {
-      let once = false;
       let resolvedArr = [];
       for (const subtable of subTables) {
-        let rootTable = getNonInlinedTable(table);
-        const arr = await resolveChildren(fromTablePrefixedValues[getTablePrefixedField(rootTable, rootTable.primary, !tablePrefixed)], subtable);
-        if (arr) {
-          once = true;
+        let arr = void 0;
+        const tableName = createReconstructReferenceName(subtable);
+        if (fromTablePrefixedValues[tableName]) {
+          arr = JSON.parse(fromTablePrefixedValues[tableName]);
+          arr = arr.filter((x) => x[subtable.primary] != null);
+          for (const field3 of subtable.fields) {
+            if (field3.name === PARENT_TABLE_ID) {
+              continue;
+            }
+            if (field3.unwrappedType === "u64") {
+              for (const item of arr) {
+                item[field3.name] = BigInt(item[field3.name]);
+              }
+            } else if (field3.type === "BLOB") {
+              for (const item of arr) {
+                item[field3.name] = fromHexString(item[field3.name]);
+              }
+            }
+          }
+        } else {
+          if (subtable.children) {
+            let rootTable = getNonInlinedTable(table);
+            const parentId = fromTablePrefixedValues[getTablePrefixedField(rootTable, rootTable.primary, !tablePrefixed)];
+            arr = await resolveChildren(parentId, subtable);
+          } else {
+            arr = [];
+          }
+        }
+        if (arr && arr.length > 0) {
           for (const element of arr) {
             const resolved = await resolveInstanceFromValue(
               element,
@@ -8626,11 +8736,7 @@ var resolveInstanceFromValue = async (fromTablePrefixedValues, tables, table, re
           }
         }
       }
-      if (!once) {
-        obj[field2.key] = void 0;
-      } else {
-        obj[field2.key] = resolvedArr;
-      }
+      obj[field2.key] = resolvedArr;
     } else {
       let subTable = void 0;
       if (subTables.length > 1) {
@@ -8688,14 +8794,14 @@ 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", request, tables, table);
+  const { query, bindable } = convertRequestToQuery("delete", { query: toQuery(request.query) }, tables, table);
   return {
     sql: `DELETE FROM ${table.name} WHERE ${table.primary} IN (SELECT ${table.primary} from ${table.name} ${query}) returning ${table.primary}`,
     bindable
   };
 };
 var convertSumRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("sum", request, tables, table);
+  const { query, bindable } = convertRequestToQuery("sum", { query: toQuery(request.query), key: request.key }, tables, table);
   const inlineName = getInlineTableFieldName(request.key);
   const field2 = table.fields.find((x) => x.name === inlineName);
   if (unwrapNestedType(field2.from.type) === "u64") {
@@ -8708,12 +8814,41 @@ var convertSumRequestToQuery = (request, tables, table) => {
   };
 };
 var convertCountRequestToQuery = (request, tables, table) => {
-  const { query, bindable } = convertRequestToQuery("count", request, tables, table);
+  const { query, bindable } = convertRequestToQuery("count", { query: request?.query ? toQuery(request.query) : void 0 }, tables, table);
   return {
     sql: `SELECT count(*) as count FROM ${table.name} ${query}`,
     bindable
   };
 };
+var buildOrderBy = (sort, tables, table, joinBuilder, resolverBuilder, path = [], options) => {
+  let orderByBuilder = void 0;
+  if ((!sort || Array.isArray(sort) && sort.length === 0) && !options?.fetchAll) {
+    sort = table.primary && path.length === 0 ? [{ key: [table.primary], direction: SortDirection.ASC }] : void 0;
+  }
+  if (sort) {
+    let sortArr = Array.isArray(sort) ? sort : [sort];
+    if (sortArr.length > 0) {
+      orderByBuilder = "";
+      let once = false;
+      for (const sort2 of sortArr) {
+        const { foreignTables, queryKey } = resolveTableToQuery(table, tables, joinBuilder, [...path, ...sort2.key], void 0, true);
+        for (const foreignTable of foreignTables) {
+          if (once) {
+            orderByBuilder += ", ";
+          }
+          once = true;
+          foreignTable.columns.push(queryKey);
+          orderByBuilder += `"${foreignTable.as}#${queryKey}" ${sort2.direction === SortDirection.ASC ? "ASC" : "DESC"}`;
+          resolverBuilder.push({
+            from: `${table.name}.${escapeColumnName(queryKey)}`,
+            as: `'${foreignTable.as}#${queryKey}'`
+          });
+        }
+      }
+    }
+  }
+  return { orderByBuilder };
+};
 var convertSearchRequestToQuery = (request, tables, rootTables, options) => {
   let unionBuilder = "";
   let orderByClause = "";
@@ -8722,16 +8857,12 @@ var convertSearchRequestToQuery = (request, tables, rootTables, options) => {
   const selectsPerTable = selectAllFieldsFromTables(rootTables, options?.shape);
   let bindableBuilder = [];
   for (const [i, table] of rootTables.entries()) {
-    const { selects, joins: joinFromSelect } = selectsPerTable[i];
-    const selectQuery = generateSelectQuery(table, selects);
+    const { selects, joins, groupBy } = selectsPerTable[i];
     try {
-      const { orderBy, query, bindable } = convertRequestToQuery("iterate", request, tables, table, joinFromSelect, [], {
-        stable: options?.stable
-      });
-      unionBuilder += `${unionBuilder.length > 0 ? " UNION ALL " : ""} ${selectQuery} ${query}`;
-      orderByClause = orderBy?.length > 0 ? orderByClause.length > 0 ? orderByClause + ", " + orderBy : orderBy : orderByClause;
-      matchedOnce = true;
-      bindableBuilder.push(...bindable);
+      const { orderByBuilder } = buildOrderBy(request?.sort, tables, table, joins, selects, [], options);
+      if (!orderByClause && orderByBuilder) {
+        orderByClause = orderByBuilder.length > 0 ? orderByClause.length > 0 ? orderByClause + ", " + orderByBuilder : orderByBuilder : orderByClause;
+      }
     } catch (error2) {
       if (error2 instanceof MissingFieldError) {
         lastError = error2;
@@ -8739,122 +8870,159 @@ var convertSearchRequestToQuery = (request, tables, rootTables, options) => {
       }
       throw error2;
     }
+    const selectQuery = generateSelectQuery(table, selects);
+    for (const flattenRequest of flattenQuery(request)) {
+      try {
+        const { query, bindable } = convertRequestToQuery(
+          "iterate",
+          flattenRequest,
+          tables,
+          table,
+          new Map(joins),
+          // copy the map, else we might might do unececessary joins
+          [],
+          options
+        );
+        unionBuilder += `${unionBuilder.length > 0 ? " UNION " : ""} ${selectQuery} ${query} ${groupBy ? "GROUP BY " + groupBy : ""}`;
+        matchedOnce = true;
+        bindableBuilder.push(...bindable);
+      } catch (error2) {
+        if (error2 instanceof MissingFieldError) {
+          lastError = error2;
+          orderByClause = "";
+          continue;
+        }
+        throw error2;
+      }
+    }
   }
   if (!matchedOnce) {
     throw lastError;
   }
   return {
-    sql: `${unionBuilder} ${orderByClause ? "ORDER BY " + orderByClause : ""} limit ? offset ?`,
+    sql: `${unionBuilder} ${orderByClause ? "ORDER BY " + orderByClause : ""} ${options?.fetchAll ? "" : "limit ? offset ?"}`,
     bindable: bindableBuilder
   };
 };
-function isIterateRequest(request, type) {
-  return type === "iterate";
-}
+var getOrSetRootTable = (joinBuilder, table) => {
+  const refName = createQueryTableReferenceName(table);
+  let ref = joinBuilder.get(refName);
+  if (ref) {
+    return ref;
+  }
+  const join = {
+    // add the root as a join even though it is not, just so we can collect the columns it will be queried
+    table,
+    type: "root",
+    as: table.name,
+    columns: []
+  };
+  joinBuilder.set(refName, join);
+  return join;
+};
 var convertRequestToQuery = (type, request, tables, table, extraJoin, path = [], options) => {
   let whereBuilder = "";
   let bindableBuilder = [];
-  let orderByBuilder = void 0;
   let joinBuilder = extraJoin || /* @__PURE__ */ new Map();
+  getOrSetRootTable(joinBuilder, table);
   const coercedQuery = toQuery(request?.query);
   if (coercedQuery.length === 1) {
-    const { where: where2, bindable } = convertQueryToSQLQuery(coercedQuery[0], tables, table, joinBuilder, path);
+    const { where: where2, bindable } = convertQueryToSQLQuery(coercedQuery[0], tables, table, joinBuilder, path, void 0, 0);
     whereBuilder += where2;
     bindableBuilder.push(...bindable);
   } else if (coercedQuery.length > 1) {
-    const { where: where2, bindable } = convertQueryToSQLQuery(new And(coercedQuery), tables, table, joinBuilder, path);
+    const { where: where2, bindable } = convertQueryToSQLQuery(new And(coercedQuery), tables, table, joinBuilder, path, void 0, 0);
     whereBuilder += where2;
     bindableBuilder.push(...bindable);
   }
-  if (isIterateRequest(request, type)) {
-    let sort = request?.sort;
-    if (!sort && options?.stable) {
-      sort = table.primary && path.length === 0 ? [{ key: [table.primary], direction: SortDirection.ASC }] : void 0;
-    }
-    if (sort) {
-      let sortArr = Array.isArray(sort) ? sort : [sort];
-      if (sortArr.length > 0) {
-        orderByBuilder = "";
-        let once = false;
-        for (const sort2 of sortArr) {
-          const { foreignTables, queryKey } = resolveTableToQuery(table, tables, joinBuilder, [...path, ...sort2.key], void 0, true);
-          for (const table2 of foreignTables) {
-            if (once) {
-              orderByBuilder += ", ";
-            }
-            once = true;
-            orderByBuilder += `${table2.as}.${queryKey} ${sort2.direction === SortDirection.ASC ? "ASC" : "DESC"}`;
-          }
-        }
-      }
-    }
-  }
   const where = whereBuilder.length > 0 ? "where " + whereBuilder : void 0;
   if (extraJoin && extraJoin.size > 0) {
     insertMapIntoMap(joinBuilder, extraJoin);
   }
-  let join = buildJoin(joinBuilder, type === "iterate" ? true : false);
+  let { join } = buildJoin(joinBuilder, options);
   const query = `${join ? join : ""} ${where ? where : ""}`;
   return {
     query,
-    orderBy: orderByBuilder,
+    /* orderBy: orderByBuilder, */
     bindable: bindableBuilder
   };
 };
-var buildJoin = (joinBuilder, resolveAllColumns) => {
-  let joinTypeDefault = resolveAllColumns ? (
-    /* "FULL OUTER JOIN" */
-    "LEFT OUTER JOIN"
-  ) : "JOIN";
+var buildJoin = (joinBuilder, options) => {
   let join = "";
   for (const [_key, table] of joinBuilder) {
+    if (table.type !== "root") {
+      continue;
+    }
+    const out = _buildJoin(table, options);
+    join += out.join;
+  }
+  for (const [_key, table] of joinBuilder) {
+    if (table.type === "root") {
+      continue;
+    }
+    const out = _buildJoin(table, options);
+    join += out.join;
+  }
+  return { join };
+};
+var _buildJoin = (table, options) => {
+  let join = "";
+  let indexedBy = void 0;
+  if (table.type !== "root") {
+    table.columns.push(PARENT_TABLE_ID);
+  }
+  if (table.columns.length > 0) {
+    const usedColumns = removeDuplicatesOrdered(table.columns);
+    indexedBy = options?.planner ? ` INDEXED BY ${options.planner.resolveIndex(table.table.name, usedColumns)} ` : "";
+  }
+  if (table.type !== "root") {
     let nonInlinedParent = table.table.parent && getNonInlinedTable(table.table.parent);
     if (!nonInlinedParent) {
       throw new Error("Unexpected: missing parent");
     }
-    let joinType = table.table.referencedInArray ? (
-      /* "FULL OUTER JOIN" */
-      "LEFT OUTER JOIN"
-    ) : joinTypeDefault;
-    join += `${joinType} ${table.table.name} AS ${table.as} ON ${nonInlinedParent.name}.${nonInlinedParent.primary} = ${table.as}.${PARENT_TABLE_ID} `;
+    let joinType = table.type === "cross" ? "LEFT JOIN" : "LEFT JOIN";
+    join += ` ${joinType} ${table.table.name} AS ${table.as} ${indexedBy} ON ${nonInlinedParent.name}.${nonInlinedParent.primary} = ${table.as}.${PARENT_TABLE_ID} `;
+  } else if (indexedBy) {
+    join += indexedBy;
   }
-  return join;
+  return { join };
 };
 var insertMapIntoMap = (map, insert2) => {
   for (const [key, value] of insert2) {
     map.set(key, value);
   }
 };
-var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path = [], tableAlias = void 0) => {
+var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path, tableAlias, skipKeys) => {
   let whereBuilder = "";
   let bindableBuilder = [];
-  const handleAnd = (queries, path2, tableAlias2) => {
+  const handleAnd = (queries, path2, tableAlias2, keysOffset) => {
     for (const query2 of queries) {
-      const { where, bindable } = convertQueryToSQLQuery(query2, tables, table, joinBuilder, path2, tableAlias2);
+      const { where, bindable } = convertQueryToSQLQuery(query2, tables, table, joinBuilder, path2, tableAlias2, keysOffset);
       whereBuilder = whereBuilder.length > 0 ? `(${whereBuilder}) AND (${where})` : where;
       bindableBuilder.push(...bindable);
     }
   };
   if (query instanceof StateFieldQuery) {
-    const { where, bindable } = convertStateFieldQuery(query, tables, table, joinBuilder, path, tableAlias);
+    const { where, bindable } = convertStateFieldQuery(query, tables, table, joinBuilder, path, tableAlias, skipKeys);
     whereBuilder += where;
     bindableBuilder.push(...bindable);
   } else if (query instanceof Nested) {
     let joinPrefix = "__" + String(tables.size);
-    path = [...path, query.path];
-    handleAnd(query.query, path, joinPrefix);
+    path = [...path, ...query.path];
+    let newSkipKeys = skipKeys + query.path.length;
+    handleAnd(query.query, path, joinPrefix, newSkipKeys);
   } else if (query instanceof LogicalQuery) {
     if (query instanceof And) {
-      handleAnd(query.and, path, tableAlias);
+      handleAnd(query.and, path, tableAlias, skipKeys);
     } else if (query instanceof Or) {
       for (const subquery of query.or) {
-        const { where, bindable } = convertQueryToSQLQuery(subquery, tables, table, joinBuilder, path, tableAlias);
-        whereBuilder = whereBuilder.length > 0 ? `(${whereBuilder}) OR (${where})` : where;
+        const { where, bindable } = convertQueryToSQLQuery(subquery, tables, table, joinBuilder, path, tableAlias, skipKeys);
+        whereBuilder = whereBuilder.length > 0 ? `(${whereBuilder}) OR(${where})` : where;
         bindableBuilder.push(...bindable);
       }
     } else if (query instanceof Not) {
-      const { where, bindable } = convertQueryToSQLQuery(query.not, tables, table, joinBuilder, path, tableAlias);
-      whereBuilder = `NOT (${where})`;
+      const { where, bindable } = convertQueryToSQLQuery(query.not, tables, table, joinBuilder, path, tableAlias, skipKeys);
+      whereBuilder = `NOT(${where})`;
       bindableBuilder.push(...bindable);
     } else {
       throw new Error("Unsupported query type: " + query.constructor.name);
@@ -8870,13 +9038,11 @@ var convertQueryToSQLQuery = (query, tables, table, joinBuilder, path = [], tabl
 var cloneQuery = (query) => {
   return deserialize(serialize(query), StateFieldQuery);
 };
-var createTableReferenceName = (table, alias, fieldType, joinSize) => {
-  if (!alias && (fieldType instanceof VecKind || fieldType instanceof OptionKind && fieldType.elementType instanceof VecKind)) {
-    let aliasSuffix = "_" + String(joinSize);
-    alias = aliasSuffix;
-  }
-  const tableNameAs = alias ? alias + "_" + table.name : table.name;
-  return tableNameAs;
+var createQueryTableReferenceName = (table) => {
+  return table.parent == null ? table.name : "_query_" + table.name;
+};
+var createReconstructReferenceName = (table) => {
+  return table.name;
 };
 var resolveTableToQuery = (table, tables, join, path, alias, searchSelf) => {
   if (searchSelf) {
@@ -8885,11 +9051,18 @@ var resolveTableToQuery = (table, tables, join, path, alias, searchSelf) => {
     if (field2) {
       return {
         queryKey: field2.name,
-        foreignTables: [{ table, as: table.name }]
+        foreignTables: [getOrSetRootTable(join, table)]
       };
     }
   }
-  let currentTables = [{ table, as: alias || table.name }];
+  let currentTables = [
+    {
+      table,
+      as: alias || table.name,
+      type: "cross",
+      columns: []
+    }
+  ];
   let prevTables = void 0;
   for (const [_i, key] of path.entries()) {
     let newTables = [];
@@ -8897,13 +9070,18 @@ var resolveTableToQuery = (table, tables, join, path, alias, searchSelf) => {
       const schema = getSchema(currentTable.ctor);
       const field2 = schema.fields.find((x) => x.key === key);
       if (!field2 && currentTable.children.length > 0) {
-        throw new MissingFieldError(`Property with key "${key}" is not found in the schema ${JSON.stringify(schema.fields.map((x) => x.key))}`);
+        throw new MissingFieldError(`Property with key "${key}" is not found in the schema ${JSON.stringify(schema.fields.map((x) => x.key))} `);
       }
       for (const child of currentTable.children) {
-        const tableNameAs = createTableReferenceName(child, alias, field2.type, join.size);
+        const tableNameAs = createQueryTableReferenceName(child);
         let isMatching = child.parentPath[child.parentPath.length - 1] === key;
         if (isMatching) {
-          const tableWithAlias = { table: child, as: tableNameAs };
+          const tableWithAlias = {
+            columns: [],
+            table: child,
+            as: tableNameAs,
+            type: currentTable.children.length > 1 ? "left" : "cross"
+          };
           if (child.isSimpleValue) {
             if (!child.inline) {
               join.set(tableNameAs, tableWithAlias);
@@ -8943,12 +9121,16 @@ var resolveTableToQuery = (table, tables, join, path, alias, searchSelf) => {
   let queryKey = queryKeyPath.length > 0 ? getInlineTableFieldName(queryKeyPath) : FOREIGN_VALUE_PROPERTY;
   return { queryKey, foreignTables };
 };
-var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = void 0) => {
+var convertStateFieldQuery = (query, tables, table, join, path, tableAlias, skipKeys) => {
   const inlinedName = getInlineTableFieldName(query.key);
   const tableField = table.fields.find((x) => x.name === inlinedName);
   const isForeign = !tableField;
   if (isForeign) {
-    const { queryKey, foreignTables } = resolveTableToQuery(table, tables, join, [...path, ...query.key], tableAlias, false);
+    const tablePath = [...path];
+    for (let i = skipKeys; i < query.key.length; i++) {
+      tablePath.push(query.key[i]);
+    }
+    const { queryKey, foreignTables } = resolveTableToQuery(table, tables, join, tablePath, tableAlias, false);
     query = cloneQuery(query);
     query.key = [queryKey];
     let whereBuilder = [];
@@ -8957,7 +9139,7 @@ var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = voi
       if (ftable.table === table) {
         throw new Error("Unexpected");
       }
-      const { where: where2, bindable: bindable2 } = convertQueryToSQLQuery(query, tables, ftable.table, join, path, ftable.as);
+      const { where: where2, bindable: bindable2 } = convertQueryToSQLQuery(query, tables, ftable.table, join, path, ftable.as, skipKeys);
       whereBuilder.push(where2);
       bindableBuilder.push(bindable2);
     }
@@ -8966,16 +9148,21 @@ var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = voi
       bindable: bindableBuilder.flat()
     };
   }
+  const columnAggregator = join.get(createQueryTableReferenceName(table));
+  if (!columnAggregator) {
+    throw new Error("Unexpected");
+  }
+  columnAggregator.columns.push(inlinedName);
   let bindable = [];
   const keyWithTable = (tableAlias || table.name) + "." + escapeColumnName(inlinedName);
   let where;
   if (query instanceof StringMatch) {
     let statement = "";
     if (query.method === StringMatchMethod.contains) {
-      statement = `${keyWithTable} LIKE ?`;
+      statement = `${keyWithTable} LIKE ? `;
       bindable.push(`%${query.value}%`);
     } else if (query.method === StringMatchMethod.prefix) {
-      statement = `${keyWithTable} LIKE ?`;
+      statement = `${keyWithTable} LIKE ? `;
       bindable.push(`${query.value}%`);
     } else if (query.method === StringMatchMethod.exact) {
       statement = `${keyWithTable} = ?`;
@@ -8991,21 +9178,21 @@ var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = voi
     where = statement;
   } else if (query instanceof IntegerCompare) {
     if (tableField.type === "BLOB") {
-      where = `hex(${keyWithTable}) LIKE ?`;
+      where = `hex(${keyWithTable}) LIKE ? `;
       bindable.push(`%${toHexString(new Uint8Array([Number(query.value.value)]))}%`);
     } else {
       if (query.compare === Compare.Equal) {
         where = `${keyWithTable} = ?`;
       } else if (query.compare === Compare.Greater) {
-        where = `${keyWithTable} > ?`;
+        where = `${keyWithTable} > ? `;
       } else if (query.compare === Compare.Less) {
-        where = `${keyWithTable} < ?`;
+        where = `${keyWithTable} <?`;
       } else if (query.compare === Compare.GreaterOrEqual) {
-        where = `${keyWithTable} >= ?`;
+        where = `${keyWithTable} >= ? `;
       } else if (query.compare === Compare.LessOrEqual) {
-        where = `${keyWithTable} <= ?`;
+        where = `${keyWithTable} <= ? `;
       } else {
-        throw new Error(`Unsupported compare type: ${query.compare}`);
+        throw new Error(`Unsupported compare type: ${query.compare} `);
       }
       if (unwrapNestedType(tableField.from.type) === "u64") {
         bindable.push(u64ToI64(query.value.value));
@@ -9023,6 +9210,253 @@ var convertStateFieldQuery = (query, tables, table, join, path, tableAlias = voi
   }
   return { where, bindable };
 };
+var removeDuplicatesOrdered = (arr) => {
+  let seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    if (seen.has(item)) {
+      return false;
+    }
+    seen.add(item);
+    return true;
+  });
+};
+
+// dist/src/query-planner.js
+var __decorate4 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata4 = function(k, v2) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v2);
+};
+var getSortedNameKey = (tableName, names) => [tableName, ...names.sort()].join(",");
+var createIndexKey = (tableName, fields) => `${tableName}_index_${fields.map((x) => x).join("_")}`;
+var HALF_MAX_U32 = 2147483647;
+var HALF_MAX_U64 = 9223372036854775807n;
+var flattenQuery = function* (props) {
+  if (!props) {
+    return yield props;
+  }
+  let ors = [];
+  let ands = [];
+  let stack = [...props.query];
+  let foundOr = false;
+  for (const q of stack) {
+    if (q instanceof Or) {
+      if (foundOr) {
+        yield props;
+        return;
+      }
+      ors = q.or;
+      foundOr = true;
+    } else if (q instanceof And) {
+      for (const a of q.and) {
+        stack.push(a);
+      }
+    } else {
+      ands.push(q);
+    }
+  }
+  let maxFlatten = 4;
+  if (ors.length === 0 || ors.length >= maxFlatten) {
+    yield {
+      query: ands,
+      sort: props.sort
+    };
+    return;
+  }
+  for (const or2 of ors) {
+    yield {
+      query: [...ands, ...Array.isArray(or2) ? or2 : [or2]],
+      sort: props.sort
+    };
+  }
+};
+var reduceResolution = (value) => {
+  if (value instanceof UnsignedIntegerValue) {
+    return value.number > HALF_MAX_U32 ? new UnsignedIntegerValue(HALF_MAX_U32) : new UnsignedIntegerValue(0);
+  }
+  if (value instanceof BigUnsignedIntegerValue) {
+    return value.value > HALF_MAX_U64 ? new BigUnsignedIntegerValue(HALF_MAX_U64) : new BigUnsignedIntegerValue(0n);
+  }
+  throw new Error("Unknown integer value type: " + value?.constructor.name);
+};
+var nullifyQuery = (query) => {
+  if (query instanceof IntegerCompare) {
+    return new IntegerCompare({
+      compare: Compare.Equal,
+      value: reduceResolution(query.value),
+      key: query.key
+    });
+  } else if (query instanceof StringMatch) {
+    return new StringMatch({
+      key: query.key,
+      value: "",
+      method: query.method
+    });
+  } else if (query instanceof ByteMatchQuery) {
+    return new ByteMatchQuery({
+      key: query.key,
+      value: new Uint8Array()
+    });
+  } else if (query instanceof BoolQuery) {
+    return new BoolQuery({
+      key: query.key,
+      value: false
+    });
+  } else if (query instanceof And) {
+    let and = [];
+    for (const condition of query.and) {
+      and.push(nullifyQuery(condition));
+    }
+    return new And(and);
+  } else if (query instanceof Or) {
+    let or2 = [];
+    for (const condition of query.or) {
+      or2.push(nullifyQuery(condition));
+    }
+    return new Or(or2);
+  } else if (query instanceof Not) {
+    return new Not(nullifyQuery(query.not));
+  } else if (query instanceof IsNull) {
+    return query;
+  } else if (query instanceof Nested) {
+    throw new Error("Unsupported query type, deprecated");
+  }
+  throw new Error("Unknown query type: " + query?.constructor.name);
+};
+var PlannableQuery = class _PlannableQuery {
+  query;
+  sort;
+  constructor(props) {
+    this.query = props.query;
+    this.sort = Array.isArray(props.sort) ? props.sort : props.sort ? [props.sort] : [];
+  }
+  get key() {
+    let query = this.query.map((x) => nullifyQuery(x));
+    let nullifiedPlannableQuery = new _PlannableQuery({
+      query,
+      sort: this.sort
+    });
+    return sha256Base64Sync(serialize(nullifiedPlannableQuery));
+  }
+};
+__decorate4([
+  field({ type: vec(Query) }),
+  __metadata4("design:type", Array)
+], PlannableQuery.prototype, "query", void 0);
+__decorate4([
+  field({ type: vec(Sort) }),
+  __metadata4("design:type", Array)
+], PlannableQuery.prototype, "sort", void 0);
+var QueryPlanner = class {
+  props;
+  stats = /* @__PURE__ */ new Map();
+  pendingIndexCreation = /* @__PURE__ */ new Map();
+  constructor(props) {
+    this.props = props;
+  }
+  async stop() {
+    for (const promise of this.pendingIndexCreation.values()) {
+      await promise.catch(() => {
+      });
+    }
+    this.stats.clear();
+  }
+  scope(query) {
+    let obj = this.stats.get(query.key);
+    if (obj === void 0) {
+      obj = {
+        columnsToIndexes: /* @__PURE__ */ new Map()
+      };
+      this.stats.set(query.key, obj);
+    }
+    let indexCreateCommands = void 0;
+    let pickedIndexKeys = /* @__PURE__ */ new Map();
+    return {
+      beforePrepare: async () => {
+        if (indexCreateCommands != null) {
+          for (const { key, cmd } of indexCreateCommands) {
+            if (this.pendingIndexCreation.has(key)) {
+              await this.pendingIndexCreation.get(key);
+            }
+            const promise = this.props.exec(cmd);
+            this.pendingIndexCreation.set(key, promise);
+            await promise;
+            this.pendingIndexCreation.delete(key);
+          }
+        }
+        if (this.pendingIndexCreation.size > 0) {
+          for (const picked of pickedIndexKeys.keys()) {
+            await this.pendingIndexCreation.get(picked);
+          }
+        }
+      },
+      resolveIndex: (tableName, columns) => {
+        const sortedNameKey = getSortedNameKey(tableName, columns);
+        let indexStats = obj.columnsToIndexes.get(sortedNameKey);
+        if (indexStats === void 0) {
+          indexStats = {
+            results: []
+          };
+          obj.columnsToIndexes.set(sortedNameKey, indexStats);
+        }
+        if (indexStats.results.length === 0) {
+          const permutations = generatePermutations(columns);
+          for (const columns2 of permutations) {
+            const indexKey = createIndexKey(tableName, columns2);
+            const command = `create index if not exists ${indexKey} on ${tableName} (${columns2.map((n) => escapeColumnName(n)).join(", ")})`;
+            (indexCreateCommands || (indexCreateCommands = [])).push({
+              cmd: command,
+              key: indexKey
+            });
+            indexStats.results.push({
+              used: 0,
+              times: [],
+              avg: -1,
+              // setting -1 will force the first time to be the fastest (i.e. new indices are always tested once)
+              indexKey
+            });
+          }
+        }
+        let fastestIndex = indexStats.results[0];
+        fastestIndex.used++;
+        pickedIndexKeys.set(fastestIndex.indexKey, sortedNameKey);
+        return fastestIndex.indexKey;
+      },
+      perform: async (fn) => {
+        let t0 = hrtime.bigint();
+        const out = await fn();
+        let t1 = hrtime.bigint();
+        const time = Number(t1 - t0);
+        for (const [indexKey, columnsKey] of pickedIndexKeys) {
+          const indexStats = obj.columnsToIndexes.get(columnsKey);
+          if (indexStats === void 0) {
+            throw new Error("index stats not found");
+          }
+          const index = indexStats.results.find((x) => x.indexKey === indexKey);
+          if (index === void 0) {
+            throw new Error("index not found");
+          }
+          index.times.push(time);
+          if (index.times.length > 20) {
+            index.times.shift();
+          }
+          index.avg = index.times.reduce((a, b) => a + b, 0) / index.times.length;
+          indexStats.results.sort((a, b) => a.avg - b.avg);
+        }
+        return out;
+      }
+    };
+  }
+};
+var generatePermutations = (list) => {
+  if (list.length === 1)
+    return [list];
+  return [list, [...list].reverse()];
+};
 
 // dist/src/engine.js
 var escapePathToSQLName = (path) => {
@@ -9035,11 +9469,13 @@ var SQLLiteIndex = class {
   properties;
   primaryKeyArr;
   primaryKeyString;
+  planner;
   scopeString;
   _rootTables;
   _tables;
   _cursor;
   // TODO choose limit better
+  cursorPruner;
   iteratorTimeout;
   closed = true;
   id;
@@ -9049,22 +9485,25 @@ var SQLLiteIndex = class {
     this.id = v4_default();
     this.scopeString = properties.scope.length > 0 ? "_" + escapePathToSQLName(properties.scope).join("_") : void 0;
     this.iteratorTimeout = options?.iteratorTimeout || 6e4;
+    this.planner = new QueryPlanner({
+      exec: this.properties.db.exec.bind(this.properties.db)
+    });
   }
   get tables() {
     if (this.closed) {
-      throw new Error("Not started");
+      throw new NotStartedError();
     }
     return this._tables;
   }
   get rootTables() {
     if (this.closed) {
-      throw new Error("Not started");
+      throw new NotStartedError();
     }
     return this._rootTables;
   }
   get cursor() {
     if (this.closed) {
-      throw new Error("Not started");
+      throw new NotStartedError();
     }
     return this._cursor;
   }
@@ -9114,9 +9553,7 @@ var SQLLiteIndex = class {
         continue;
       }
       const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")}) strict`;
-      const sqlCreateIndex = `create index if not exists ${table.name}_index on ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")})`;
       this.properties.db.exec(sqlCreateTable);
-      this.properties.db.exec(sqlCreateIndex);
       let sqlPut = `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
       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));
@@ -9125,6 +9562,14 @@ var SQLLiteIndex = class {
         await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
       }
     }
+    this.cursorPruner = setInterval(() => {
+      const now = Date.now();
+      for (const [k, v2] of this._cursor) {
+        if (v2.expire < now) {
+          this.clearupIterator(k);
+        }
+      }
+    }, this.iteratorTimeout);
     this.closed = false;
   }
   async clearStatements() {
@@ -9137,14 +9582,20 @@ var SQLLiteIndex = class {
       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) {
+      throw new Error(`Already closed index ${this.id}, can not drop`);
+    }
     this.closed = true;
+    clearInterval(this.cursorPruner);
     await this.clearStatements();
     for (const table of this._rootTables) {
       await this.properties.db.exec(`drop table if exists ${table.name}`);
@@ -9153,6 +9604,7 @@ var SQLLiteIndex = class {
     for (const [k, _v] of this._cursor) {
       await this.clearupIterator(k);
     }
+    await this.planner.stop();
   }
   async resolveDependencies(parentId, table) {
     const stmt = this.properties.db.statements.get(resolveChildrenStatement(table));
@@ -9163,33 +9615,40 @@ var SQLLiteIndex = class {
   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, true)} where ${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
-      ]);
-      if (!rows) {
-        continue;
+      const sql = `${generateSelectQuery(table, selects)} ${buildJoin(joinMap).join} where ${this.primaryKeyString} = ? limit 1`;
+      try {
+        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
+        ]);
+        if (rows?.[getTablePrefixedField(table, table.primary)] == null) {
+          continue;
+        }
+        return {
+          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 {
-        value: await resolveInstanceFromValue(rows, this.tables, table, this.resolveDependencies.bind(this), true, options?.shape),
-        id
-      };
     }
     return void 0;
   }
   async put(value, _id) {
     const classOfValue = value.constructor;
     return insert(async (values, table) => {
-      const preId = values[table.primaryIndex];
+      let preId = values[table.primaryIndex];
       if (preId != null) {
         const statement = this.properties.db.statements.get(replaceStatementKey(table));
-        await statement.run(values.map((x) => typeof x === "boolean" ? x ? 1 : 0 : x));
+        await statement.run(values);
         await statement.reset?.();
         return preId;
       } else {
         const statement = this.properties.db.statements.get(putStatementKey(table));
-        const out = await statement.get(values.map((x) => typeof x === "boolean" ? x ? 1 : 0 : x));
+        const out = await statement.get(values);
         await statement.reset?.();
         if (out == null) {
           return void 0;
@@ -9209,26 +9668,35 @@ var SQLLiteIndex = class {
     let kept = void 0;
     let bindable = [];
     let sqlFetch = void 0;
+    const normalizedQuery = new PlannableQuery({
+      query: toQuery(request?.query),
+      sort: request?.sort
+    });
+    let planningScope;
     const fetch2 = async (amount) => {
       kept = void 0;
       if (!once) {
-        let { sql, bindable: toBind } = convertSearchRequestToQuery(request, this.tables, this._rootTables, {
+        planningScope = this.planner.scope(normalizedQuery);
+        let { sql, bindable: toBind } = convertSearchRequestToQuery(normalizedQuery, this.tables, this._rootTables, {
+          planner: planningScope,
           shape: options?.shape,
-          stable: typeof amount === "number"
+          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);
-        clearTimeout(iterator.timeout);
-        iterator.timeout = setTimeout(() => this.clearupIterator(requestId), this.iteratorTimeout);
+        iterator.expire = Date.now() + this.iteratorTimeout;
       }
       once = true;
-      const allResults = await stmt.all([
-        ...bindable,
-        amount === "all" ? Number.MAX_SAFE_INTEGER : amount,
-        offset
-      ]);
+      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);
@@ -9241,14 +9709,13 @@ var SQLLiteIndex = class {
       if (amount === "all" || results.length < amount) {
         hasMore = false;
         await this.clearupIterator(requestId);
-        clearTimeout(iterator.timeout);
       }
       return results;
     };
     const iterator = {
       fetch: fetch2,
       /* countStatement: countStmt, */
-      timeout: setTimeout(() => this.clearupIterator(requestId), this.iteratorTimeout)
+      expire: Date.now() + this.iteratorTimeout
     };
     this.cursor.set(requestId, iterator);
     let totalCount = void 0;
@@ -9256,9 +9723,9 @@ var SQLLiteIndex = class {
       all: async () => {
         const results = [];
         while (true) {
-          const res = await fetch2(100);
+          const res = await fetch2("all");
           results.push(...res);
-          if (res.length === 0) {
+          if (hasMore === false) {
             break;
           }
         }
@@ -9290,7 +9757,6 @@ var SQLLiteIndex = class {
     if (!cache) {
       return;
     }
-    clearTimeout(cache.timeout);
     this._cursor.delete(id);
   }
   async getSize() {
@@ -9460,8 +9926,15 @@ var SQLiteIndices = class _SQLiteIndices {
     for (const scope of this.scopes.values()) {
       await scope.drop();
     }
-    for (const index of this.indices) {
-      await index.index.drop();
+    if (!this.properties.parent) {
+      for (const index of this.indices) {
+        await index.index.stop();
+      }
+      await this.properties.db.drop();
+    } else {
+      for (const index of this.indices) {
+        await index.index.drop();
+      }
     }
     this.scopes.clear();
   }
@@ -17428,10 +17901,10 @@ var sqlite3InitModule = (() => {
       });
       globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite32) {
         sqlite32.version = {
-          libVersion: "3.47.0",
-          libVersionNumber: 3047e3,
-          sourceId: "2024-10-21 16:30:22 03a9703e27c44437c39363d0baf82db4ebc94538a0f28411c85dda156f82636e",
-          downloadVersion: 347e4
+          libVersion: "3.47.2",
+          libVersionNumber: 3047002,
+          sourceId: "2024-12-07 20:39:59 2aabe05e2e8cae4847a802ee2daddc1d7413d8fc560254d93ee3e72c14685b6c",
+          downloadVersion: 3470200
         };
       });
       globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite32) {
@@ -20951,13 +21424,20 @@ var create = async (directory) => {
     await sqliteDb?.close();
     sqliteDb = void 0;
   };
+  let dbFileName;
+  let drop = async () => {
+    if (poolUtil && dbFileName != null) {
+      poolUtil.unlink(dbFileName);
+    }
+    return close();
+  };
   let open = async () => {
     if (sqliteDb) {
       return sqliteDb;
     }
     if (directory) {
       directory = directory.replace(/^\./, "");
-      let dbFileName = `${directory}/db.sqlite`;
+      dbFileName = `${directory}/db.sqlite`;
       poolUtil = poolUtil || await sqlite3.installOpfsSAHPoolVfs({
         directory: "peerbit/sqlite"
         // encodeName("peerbit")
@@ -20976,6 +21456,7 @@ var create = async (directory) => {
       return sqliteDb.exec(sql);
     },
     open,
+    drop,
     prepare: async (sql, id) => {
       if (id == null) {
         id = v4_default();
@@ -21127,6 +21608,13 @@ var ProxyDatabase = class {
       databaseId: this.databaseId
     });
   }
+  async drop() {
+    return this.send({
+      type: "drop",
+      id: v4_default(),
+      databaseId: this.databaseId
+    });
+  }
   async status() {
     return this.send({
       type: "status",