bun-sqlite-for-rxdb 1.5.2 → 1.5.4

package/dist/index.js

@@ -12228,9 +12228,191 @@ function addRxStorageMultiInstanceSupport(storageName, instanceCreationParams, i
 // src/instance.ts
 var import_rxjs2 = __toESM(require_cjs(), 1);
 
-// src/query/regex-matcher.ts
-var REGEX_CACHE = new Map;
+// src/query/sieve-cache.ts
+class SieveCache {
+  #capacity;
+  #map;
+  #keys;
+  #values;
+  #visited;
+  #newer;
+  #older;
+  #head = 0;
+  #tail = 0;
+  #hand = 0;
+  #freeHead = 0;
+  #nextFreeIndex = 1;
+  constructor(capacity) {
+    if (capacity < 1)
+      throw new RangeError("Capacity must be at least 1");
+    const arraySize = capacity + 1;
+    this.#capacity = capacity;
+    this.#map = new Map;
+    this.#keys = new Array(arraySize);
+    this.#values = new Array(arraySize);
+    this.#visited = new Uint8Array(arraySize);
+    this.#newer = new Uint32Array(arraySize);
+    this.#older = new Uint32Array(arraySize);
+  }
+  get size() {
+    return this.#map.size;
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  get(key) {
+    const index = this.#map.get(key);
+    if (index !== undefined) {
+      this.#visited[index] = 1;
+      return this.#values[index];
+    }
+    return;
+  }
+  set(key, value) {
+    let index = this.#map.get(key);
+    if (index !== undefined) {
+      this.#values[index] = value;
+      this.#visited[index] = 1;
+      return this;
+    }
+    index = this.#getFreeIndex();
+    this.#keys[index] = key;
+    this.#values[index] = value;
+    this.#visited[index] = 0;
+    this.#map.set(key, index);
+    if (this.#head === 0) {
+      this.#head = this.#tail = index;
+    } else {
+      this.#newer[this.#head] = index;
+      this.#older[index] = this.#head;
+      this.#head = index;
+    }
+    return this;
+  }
+  delete(key) {
+    const index = this.#map.get(key);
+    if (index !== undefined) {
+      this.#map.delete(key);
+      this.#removeNode(index);
+      this.#keys[index] = undefined;
+      this.#values[index] = undefined;
+      this.#newer[index] = this.#freeHead;
+      this.#freeHead = index;
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.#map.clear();
+    this.#head = 0;
+    this.#tail = 0;
+    this.#hand = 0;
+    this.#freeHead = 0;
+    this.#nextFreeIndex = 1;
+    this.#keys.fill(undefined);
+    this.#values.fill(undefined);
+    this.#newer.fill(0);
+    this.#older.fill(0);
+    this.#visited.fill(0);
+  }
+  #getFreeIndex() {
+    if (this.#freeHead !== 0) {
+      const index = this.#freeHead;
+      this.#freeHead = this.#newer[index];
+      this.#newer[index] = 0;
+      return index;
+    }
+    if (this.#nextFreeIndex <= this.#capacity) {
+      return this.#nextFreeIndex++;
+    }
+    return this.#evict();
+  }
+  #evict() {
+    let hand = this.#hand === 0 ? this.#tail : this.#hand;
+    while (this.#visited[hand] === 1) {
+      this.#visited[hand] = 0;
+      hand = this.#newer[hand] === 0 ? this.#tail : this.#newer[hand];
+    }
+    this.#hand = this.#newer[hand];
+    const victimIndex = hand;
+    this.#map.delete(this.#keys[victimIndex]);
+    this.#removeNode(victimIndex);
+    return victimIndex;
+  }
+  #removeNode(index) {
+    const newer = this.#newer[index];
+    const older = this.#older[index];
+    if (newer !== 0) {
+      this.#older[newer] = older;
+    } else {
+      this.#head = older;
+    }
+    if (older !== 0) {
+      this.#newer[older] = newer;
+    } else {
+      this.#tail = newer;
+    }
+    if (this.#hand === index) {
+      this.#hand = newer;
+    }
+    this.#newer[index] = 0;
+    this.#older[index] = 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.#map.forEach((index, key) => {
+      callbackfn.call(thisArg, this.#values[index], key, this);
+    });
+  }
+  *entries() {
+    for (const [key, index] of this.#map.entries()) {
+      yield [key, this.#values[index]];
+    }
+  }
+  *keys() {
+    for (const key of this.#map.keys()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const index of this.#map.values()) {
+      yield this.#values[index];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get [Symbol.toStringTag]() {
+    return `SieveCache(${this.#capacity})`;
+  }
+}
+
+// src/query/cache.ts
+var MAX_QUERY_CACHE_SIZE = 5000;
 var MAX_REGEX_CACHE_SIZE = 100;
+var MAX_INDEX_CACHE_SIZE = 1000;
+var queryCacheByDatabase = new WeakMap;
+var GLOBAL_QUERY_CACHE = new SieveCache(MAX_QUERY_CACHE_SIZE);
+function getQueryCache(database) {
+  let cache = queryCacheByDatabase.get(database);
+  if (!cache) {
+    cache = new SieveCache(MAX_QUERY_CACHE_SIZE);
+    queryCacheByDatabase.set(database, cache);
+  }
+  return cache;
+}
+function getGlobalCache() {
+  return GLOBAL_QUERY_CACHE;
+}
+var REGEX_CACHE = new SieveCache(MAX_REGEX_CACHE_SIZE);
+function getRegexCache() {
+  return REGEX_CACHE;
+}
+var INDEX_CACHE = new SieveCache(MAX_INDEX_CACHE_SIZE);
+function getIndexCache() {
+  return INDEX_CACHE;
+}
+
+// src/query/regex-matcher.ts
 function isValidRegexOptions(options) {
   for (let i = 0;i < options.length; i++) {
     const c = options[i];
@@ -12240,22 +12422,17 @@ function isValidRegexOptions(options) {
   return true;
 }
 function compileRegex(pattern, options) {
-  const cacheKey = `${pattern}::${options || ""}`;
-  const cached = REGEX_CACHE.get(cacheKey);
+  const cache = getRegexCache();
+  const cacheKey = `${pattern}:${options || ""}`;
+  const cached = cache.get(cacheKey);
   if (cached) {
     return cached.regex;
   }
   if (options && !isValidRegexOptions(options)) {
-    throw new Error(`Invalid regex options: "${options}". Valid options are: i, m, s, x, u`);
+    throw new Error(`Invalid regex options: ${options}`);
   }
   const regex = new RegExp(pattern, options);
-  if (REGEX_CACHE.size >= MAX_REGEX_CACHE_SIZE) {
-    const firstKey = REGEX_CACHE.keys().next().value;
-    if (firstKey) {
-      REGEX_CACHE.delete(firstKey);
-    }
-  }
-  REGEX_CACHE.set(cacheKey, { regex });
+  cache.set(cacheKey, { regex });
   return regex;
 }
 function matchesRegex(value, pattern, options) {
@@ -12294,24 +12471,15 @@ function getColumnInfo(path2, schema) {
 }
 
 // src/query/smart-regex.ts
-var INDEX_CACHE = new Map;
-var MAX_INDEX_CACHE_SIZE = 1000;
 function hasExpressionIndex(fieldName, schema) {
-  const indexKey = schema.indexes ? JSON.stringify(schema.indexes) : "none";
-  const cacheKey = `${schema.version}_${fieldName}_${indexKey}`;
-  const cached = INDEX_CACHE.get(cacheKey);
+  const cache = getIndexCache();
+  const cacheKey = `${fieldName}:${JSON.stringify(schema.indexes || [])}`;
+  const cached = cache.get(cacheKey);
   if (cached !== undefined) {
-    INDEX_CACHE.delete(cacheKey);
-    INDEX_CACHE.set(cacheKey, cached);
     return cached;
   }
   if (!schema.indexes) {
-    if (INDEX_CACHE.size >= MAX_INDEX_CACHE_SIZE) {
-      const firstKey = INDEX_CACHE.keys().next().value;
-      if (firstKey)
-        INDEX_CACHE.delete(firstKey);
-    }
-    INDEX_CACHE.set(cacheKey, false);
+    cache.set(cacheKey, false);
     return false;
   }
   const hasLowerIndex = schema.indexes.some((idx) => {
@@ -12323,12 +12491,7 @@ function hasExpressionIndex(fieldName, schema) {
       return normalized === `lower(${fieldName})`;
     });
   });
-  if (INDEX_CACHE.size >= MAX_INDEX_CACHE_SIZE) {
-    const firstKey = INDEX_CACHE.keys().next().value;
-    if (firstKey)
-      INDEX_CACHE.delete(firstKey);
-  }
-  INDEX_CACHE.set(cacheKey, hasLowerIndex);
+  cache.set(cacheKey, hasLowerIndex);
   return hasLowerIndex;
 }
 function isValidRegexOptions2(options) {
@@ -12949,29 +13112,47 @@ function _stringify(value, stack) {
 }
 
 // src/query/builder.ts
-var MAX_CACHE_SIZE = 1000;
-var GLOBAL_CACHE = new Map;
-function buildWhereClause(selector, schema, collectionName, cache = GLOBAL_CACHE) {
+function buildWhereClause(selector, schema, collectionName, cache) {
   if (!selector || typeof selector !== "object")
     return null;
-  const cacheKey = `v${schema.version}_${collectionName}_${stableStringify(selector)}`;
-  const cached = cache.get(cacheKey);
+  const actualCache = cache ?? getGlobalCache();
+  const cacheKey = `v${schema.version}_${stableStringify(selector)}`;
+  const cached = actualCache.get(cacheKey);
   if (cached !== undefined) {
-    cache.delete(cacheKey);
-    cache.set(cacheKey, cached);
     return cached;
   }
   const result = processSelector(selector, schema, 0);
-  if (!result)
-    return null;
-  if (cache.size >= MAX_CACHE_SIZE) {
-    const firstKey = cache.keys().next().value;
-    if (firstKey)
-      cache.delete(firstKey);
-  }
-  cache.set(cacheKey, result);
+  actualCache.set(cacheKey, result);
   return result;
 }
+function buildWhereClauseWithFallback(selector, schema, collectionName, cache) {
+  if (!selector || typeof selector !== "object") {
+    return { sqlWhere: null, jsSelector: null };
+  }
+  const sqlResult = buildWhereClause(selector, schema, collectionName, cache);
+  if (sqlResult) {
+    return { sqlWhere: sqlResult, jsSelector: null };
+  }
+  const splitResult = splitSelector(selector, schema);
+  return splitResult;
+}
+function splitSelector(selector, schema) {
+  const sqlConditions = [];
+  const jsConditions = [];
+  const entries = Object.entries(selector);
+  for (const [field, value] of entries) {
+    const testSelector = { [field]: value };
+    const sqlFragment = processSelector(testSelector, schema, 0);
+    if (sqlFragment) {
+      sqlConditions.push(testSelector);
+    } else {
+      jsConditions.push(testSelector);
+    }
+  }
+  const sqlWhere = sqlConditions.length > 0 ? processSelector({ $and: sqlConditions }, schema, 0) : null;
+  const jsSelector = jsConditions.length > 0 ? jsConditions.length === 1 ? jsConditions[0] : { $and: jsConditions } : null;
+  return { sqlWhere, jsSelector };
+}
 function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
   if (conditions.length === 0) {
     return { sql: operator === "or" ? "1=0" : "1=1", args: [] };
@@ -13016,6 +13197,14 @@ function processSelector(selector, schema, logicalDepth) {
       args.push(...norFragment.args);
       continue;
     }
+    if (field === "$not" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const innerFragment = processSelector(value, schema, logicalDepth + 1);
+      if (!innerFragment)
+        return null;
+      conditions.push(`NOT (${innerFragment.sql})`);
+      args.push(...innerFragment.args);
+      continue;
+    }
     const columnInfo = getColumnInfo(field, schema);
     const fieldName = columnInfo.column || `json_extract(data, '${columnInfo.jsonPath}')`;
     const actualFieldName = columnInfo.jsonPath?.replace(/^\$\./, "") || columnInfo.column || field;
@@ -13529,9 +13718,6 @@ class StatementManager {
     this.closed = true;
   }
   isStaticSQL(query) {
-    if (query.includes("WHERE (")) {
-      return false;
-    }
     return true;
   }
 }
@@ -13594,7 +13780,7 @@ class BunSQLiteStorageInstance {
   db;
   stmtManager;
   changeStream$ = new import_rxjs2.Subject;
-  queryCache = new Map;
+  queryCache;
   databaseName;
   collectionName;
   schema;
@@ -13602,6 +13788,7 @@ class BunSQLiteStorageInstance {
   options;
   primaryPath;
   tableName;
+  useStoredColumns;
   closed;
   constructor(params, settings = {}) {
     ensureRxStorageInstanceParamsAreCorrect(params);
@@ -13612,9 +13799,11 @@ class BunSQLiteStorageInstance {
     const primaryKey = params.schema.primaryKey;
     this.primaryPath = typeof primaryKey === "string" ? primaryKey : primaryKey.key;
     this.tableName = `${params.collectionName}_v${params.schema.version}`;
+    this.useStoredColumns = this.options?.useStoredColumns ?? "virtual";
     const filename = settings.filename || ":memory:";
     this.db = getDatabase(this.databaseName, filename);
     this.stmtManager = new StatementManager(this.db);
+    this.queryCache = getQueryCache(this.db);
     this.internals = {
       db: this.db,
       primaryPath: this.primaryPath
@@ -13635,15 +13824,37 @@ class BunSQLiteStorageInstance {
       this.db.run("PRAGMA temp_store = MEMORY");
       this.db.run("PRAGMA locking_mode = NORMAL");
     }
-    this.db.run(`
-			CREATE TABLE IF NOT EXISTS "${this.tableName}" (
-				id TEXT PRIMARY KEY NOT NULL,
-				data BLOB NOT NULL,
-				deleted INTEGER NOT NULL DEFAULT 0,
-				rev TEXT NOT NULL,
-				mtime_ms REAL NOT NULL
-			)
-		`);
+    if (this.useStoredColumns === "virtual") {
+      this.db.run(`
+				CREATE TABLE IF NOT EXISTS "${this.tableName}" (
+					id TEXT PRIMARY KEY NOT NULL,
+					data BLOB NOT NULL,
+					deleted INTEGER GENERATED ALWAYS AS (json_extract(data, '$._deleted')) VIRTUAL,
+					rev TEXT GENERATED ALWAYS AS (json_extract(data, '$._rev')) VIRTUAL,
+					mtime_ms REAL GENERATED ALWAYS AS (json_extract(data, '$._meta.lwt')) VIRTUAL
+				)
+			`);
+    } else if (this.useStoredColumns === "stored") {
+      this.db.run(`
+				CREATE TABLE IF NOT EXISTS "${this.tableName}" (
+					id TEXT PRIMARY KEY NOT NULL,
+					data BLOB NOT NULL,
+					deleted INTEGER GENERATED ALWAYS AS (json_extract(data, '$._deleted')) STORED,
+					rev TEXT GENERATED ALWAYS AS (json_extract(data, '$._rev')) STORED,
+					mtime_ms REAL GENERATED ALWAYS AS (json_extract(data, '$._meta.lwt')) STORED
+				)
+			`);
+    } else {
+      this.db.run(`
+				CREATE TABLE IF NOT EXISTS "${this.tableName}" (
+					id TEXT PRIMARY KEY NOT NULL,
+					data BLOB NOT NULL,
+					deleted INTEGER NOT NULL DEFAULT 0,
+					rev TEXT NOT NULL,
+					mtime_ms REAL NOT NULL
+				)
+			`);
+    }
     this.db.run(`CREATE INDEX IF NOT EXISTS "idx_${this.tableName}_deleted_id" ON "${this.tableName}"(deleted, id)`);
     this.db.run(`CREATE INDEX IF NOT EXISTS "idx_${this.tableName}_mtime_ms_id" ON "${this.tableName}"(mtime_ms, id)`);
     if (this.schema.indexes) {
@@ -13677,49 +13888,70 @@ class BunSQLiteStorageInstance {
         return { error: [] };
       }
       const ids = documentWrites.map((w) => w.document[this.primaryPath]);
-      const docsInDb = await this.findDocumentsById(ids, true);
+      const LOOKUP_BATCH_SIZE = 500;
+      const docsInDb = [];
+      for (let i = 0;i < ids.length; i += LOOKUP_BATCH_SIZE) {
+        const batch = ids.slice(i, i + LOOKUP_BATCH_SIZE);
+        const batchDocs = await this.findDocumentsById(batch, true);
+        docsInDb.push(...batchDocs);
+      }
       const docsInDbMap = new Map(docsInDb.map((d) => [d[this.primaryPath], d]));
       const categorized = categorizeBulkWriteRows(this, this.primaryPath, docsInDbMap, documentWrites, context);
-      const updateQuery = `UPDATE "${this.tableName}" SET data = jsonb(?), deleted = ?, rev = ?, mtime_ms = ? WHERE id = ?`;
-      const BATCH_SIZE = 100;
-      for (let i = 0;i < categorized.bulkInsertDocs.length; i += BATCH_SIZE) {
-        const batch = categorized.bulkInsertDocs.slice(i, i + BATCH_SIZE);
-        const placeholders = batch.map(() => "(?, jsonb(?), ?, ?, ?)").join(", ");
-        const insertQuery = `INSERT INTO "${this.tableName}" (id, data, deleted, rev, mtime_ms) VALUES ${placeholders}`;
-        const params = [];
-        for (const row of batch) {
-          const doc = row.document;
-          const id = doc[this.primaryPath];
-          params.push(id, JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt);
-        }
-        try {
-          this.stmtManager.run({ query: insertQuery, params });
-        } catch (err) {
-          if (err && typeof err === "object" && "code" in err && (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || err.code === "SQLITE_CONSTRAINT_UNIQUE")) {
-            for (const row of batch) {
-              const doc = row.document;
-              const id = doc[this.primaryPath];
-              const documentInDb = docsInDbMap.get(id);
-              categorized.errors.push({
-                isError: true,
-                status: 409,
-                documentId: id,
-                writeRow: row,
-                documentInDb: documentInDb || doc
-              });
+      const CHUNK_SIZE = 50;
+      const updateStmt = this.useStoredColumns ? this.db.prepare(`UPDATE "${this.tableName}" SET data = jsonb(?) WHERE id = ?`) : this.db.prepare(`UPDATE "${this.tableName}" SET data = jsonb(?), deleted = ?, rev = ?, mtime_ms = ? WHERE id = ?`);
+      const insertBatch = this.db.transaction((docs) => {
+        for (let i = 0;i < docs.length; i += CHUNK_SIZE) {
+          const chunk = docs.slice(i, i + CHUNK_SIZE);
+          const placeholders = this.useStoredColumns ? chunk.map(() => "(?, jsonb(?))").join(", ") : chunk.map(() => "(?, jsonb(?), ?, ?, ?)").join(", ");
+          const insertQuery = this.useStoredColumns ? `INSERT INTO "${this.tableName}" (id, data) VALUES ${placeholders}` : `INSERT INTO "${this.tableName}" (id, data, deleted, rev, mtime_ms) VALUES ${placeholders}`;
+          const params = [];
+          for (const row of chunk) {
+            const doc = row.document;
+            const id = doc[this.primaryPath];
+            if (this.useStoredColumns) {
+              params.push(id, JSON.stringify(doc));
+            } else {
+              params.push(id, JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt);
+            }
+          }
+          try {
+            this.stmtManager.run({ query: insertQuery, params });
+          } catch (err) {
+            if (err && typeof err === "object" && "code" in err && (err.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || err.code === "SQLITE_CONSTRAINT_UNIQUE")) {
+              for (const row of chunk) {
+                const doc = row.document;
+                const id = doc[this.primaryPath];
+                const documentInDb = docsInDbMap.get(id);
+                categorized.errors.push({
+                  isError: true,
+                  status: 409,
+                  documentId: id,
+                  writeRow: row,
+                  documentInDb: documentInDb || doc
+                });
+              }
+            } else {
+              throw err;
             }
-          } else {
-            throw err;
           }
         }
-      }
-      for (let i = 0;i < categorized.bulkUpdateDocs.length; i += BATCH_SIZE) {
-        const batch = categorized.bulkUpdateDocs.slice(i, i + BATCH_SIZE);
-        for (const row of batch) {
+      });
+      const updateBatch = this.db.transaction((docs) => {
+        for (const row of docs) {
           const doc = row.document;
           const id = doc[this.primaryPath];
-          this.stmtManager.run({ query: updateQuery, params: [JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt, id] });
+          if (this.useStoredColumns) {
+            updateStmt.run(JSON.stringify(doc), id);
+          } else {
+            updateStmt.run(JSON.stringify(doc), doc._deleted ? 1 : 0, doc._rev, doc._meta.lwt, id);
+          }
         }
+      });
+      if (categorized.bulkInsertDocs.length > 0) {
+        insertBatch(categorized.bulkInsertDocs);
+      }
+      if (categorized.bulkUpdateDocs.length > 0) {
+        updateBatch(categorized.bulkUpdateDocs);
       }
       const insertAttQuery = `INSERT OR REPLACE INTO "${this.tableName}_attachments" (id, data, digest) VALUES (?, ?, ?)`;
       const deleteAttQuery = `DELETE FROM "${this.tableName}_attachments" WHERE id = ?`;
@@ -13762,31 +13994,37 @@ class BunSQLiteStorageInstance {
     return rows.map((row) => JSON.parse(row.data));
   }
   async query(preparedQuery) {
-    const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName, this.queryCache);
-    if (!whereResult) {
-      return this.queryWithOurMemory(preparedQuery);
+    const { sqlWhere, jsSelector } = buildWhereClauseWithFallback(preparedQuery.query.selector, this.schema, this.collectionName, this.queryCache);
+    let sql = `SELECT json(data) as data FROM "${this.tableName}"`;
+    const queryArgs = [];
+    if (sqlWhere) {
+      sql += ` WHERE (${sqlWhere.sql})`;
+      queryArgs.push(...sqlWhere.args);
     }
-    const { sql: whereClause, args } = whereResult;
-    let sql = `SELECT json(data) as data FROM "${this.tableName}" WHERE (${whereClause})`;
-    const queryArgs = [...args];
     if (preparedQuery.query.sort && preparedQuery.query.sort.length > 0) {
       const orderBy = preparedQuery.query.sort.map((sortField) => {
         const [field, direction] = Object.entries(sortField)[0];
         const dir = direction === "asc" ? "ASC" : "DESC";
-        return `json_extract(data, '$.${field}') ${dir}`;
+        const colInfo = getColumnInfo(field, this.schema);
+        const colName = colInfo.column || `json_extract(data, '${colInfo.jsonPath}')`;
+        return `${colName} ${dir}`;
       }).join(", ");
       sql += ` ORDER BY ${orderBy}`;
     }
-    if (preparedQuery.query.limit) {
-      sql += ` LIMIT ?`;
-      queryArgs.push(preparedQuery.query.limit);
-    }
-    if (preparedQuery.query.skip) {
-      if (!preparedQuery.query.limit) {
-        sql += ` LIMIT -1`;
+    const skip = preparedQuery.query.skip || 0;
+    const limit = preparedQuery.query.limit;
+    if (!jsSelector) {
+      if (limit !== undefined) {
+        sql += ` LIMIT ?`;
+        queryArgs.push(limit);
+      }
+      if (skip > 0) {
+        if (limit === undefined) {
+          sql += ` LIMIT -1`;
+        }
+        sql += ` OFFSET ?`;
+        queryArgs.push(skip);
       }
-      sql += ` OFFSET ?`;
-      queryArgs.push(preparedQuery.query.skip);
     }
     if (process.env.DEBUG_QUERIES) {
       const explainSql = `EXPLAIN QUERY PLAN ${sql}`;
@@ -13795,9 +14033,29 @@ class BunSQLiteStorageInstance {
       console.log("[DEBUG_QUERIES] SQL:", sql);
       console.log("[DEBUG_QUERIES] Args:", queryArgs);
     }
-    const rows = this.stmtManager.all({ query: sql, params: queryArgs });
-    const documents = rows.map((row) => JSON.parse(row.data));
-    return { documents };
+    if (jsSelector) {
+      const stmt = this.db.prepare(sql);
+      const documents = [];
+      let skipped = 0;
+      for (const row of stmt.all(...queryArgs)) {
+        const doc = JSON.parse(row.data);
+        if (matchesSelector(doc, jsSelector)) {
+          if (skip > 0 && skipped < skip) {
+            skipped++;
+            continue;
+          }
+          documents.push(doc);
+          if (limit !== undefined && documents.length >= limit) {
+            break;
+          }
+        }
+      }
+      return { documents };
+    } else {
+      const rows = this.stmtManager.all({ query: sql, params: queryArgs });
+      const documents = rows.map((row) => JSON.parse(row.data));
+      return { documents };
+    }
   }
   sortDocuments(docs, sort) {
     return docs.sort((a, b) => {
@@ -13819,7 +14077,7 @@ class BunSQLiteStorageInstance {
   async count(preparedQuery) {
     const whereResult = buildWhereClause(preparedQuery.query.selector, this.schema, this.collectionName, this.queryCache);
     if (!whereResult) {
-      const allDocs = await this.queryWithOurMemory(preparedQuery);
+      const allDocs = this.queryWithOurMemory(preparedQuery);
       return {
         count: allDocs.documents.length,
         mode: "fast"
@@ -13852,7 +14110,6 @@ class BunSQLiteStorageInstance {
     if (this.closed)
       return this.closed;
     this.closed = (async () => {
-      this.queryCache.clear();
       this.changeStream$.complete();
       this.stmtManager.close();
       releaseDatabase(this.databaseName);
@@ -13900,21 +14157,16 @@ class BunSQLiteStorageInstance {
     return { documents, checkpoint: newCheckpoint };
   }
   queryWithOurMemory(preparedQuery) {
-    const query = `SELECT json(data) as data FROM "${this.tableName}"`;
+    let query = `SELECT json(data) as data FROM "${this.tableName}"`;
     const selector = preparedQuery.query.selector;
     const hasSort = preparedQuery.query.sort && preparedQuery.query.sort.length > 0;
     if (hasSort) {
-      const rows = this.stmtManager.all({ query, params: [] });
-      let documents2 = rows.map((row) => JSON.parse(row.data));
-      documents2 = documents2.filter((doc) => matchesSelector(doc, selector));
-      documents2 = this.sortDocuments(documents2, preparedQuery.query.sort);
-      if (preparedQuery.query.skip) {
-        documents2 = documents2.slice(preparedQuery.query.skip);
-      }
-      if (preparedQuery.query.limit) {
-        documents2 = documents2.slice(0, preparedQuery.query.limit);
-      }
-      return { documents: documents2 };
+      const orderBy = preparedQuery.query.sort.map((sortField) => {
+        const [field, direction] = Object.entries(sortField)[0];
+        const dir = direction === "asc" ? "ASC" : "DESC";
+        return `json_extract(data, '$.${field}') ${dir}`;
+      }).join(", ");
+      query += ` ORDER BY ${orderBy}`;
     }
     const stmt = this.db.prepare(query);
     const documents = [];

package/dist/src/instance.d.ts

@@ -13,6 +13,7 @@ export declare class BunSQLiteStorageInstance<RxDocType> implements RxStorageIns
     readonly options: Readonly<BunSQLiteStorageSettings>;
     private primaryPath;
     private tableName;
+    private useStoredColumns;
     closed?: Promise<void>;
     constructor(params: RxStorageInstanceCreationParams<RxDocType, BunSQLiteStorageSettings>, settings?: BunSQLiteStorageSettings);
     private initTable;

package/dist/src/query/builder.d.ts

@@ -1,7 +1,12 @@
 import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
 import type { SqlFragment } from './operators';
-export declare function getCacheSize(): number;
-export declare function clearCache(): void;
-export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null>): SqlFragment | null;
+import type { SieveCache } from './sieve-cache';
+export { getCacheSize, clearCache } from './cache';
+export interface BipartiteQuery<RxDocType> {
+    sqlWhere: SqlFragment | null;
+    jsSelector: MangoQuerySelector<RxDocumentData<RxDocType>> | null;
+}
+export declare function buildWhereClause<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null> | SieveCache<string, SqlFragment | null>): SqlFragment | null;
+export declare function buildWhereClauseWithFallback<RxDocType>(selector: MangoQuerySelector<RxDocumentData<RxDocType>>, schema: RxJsonSchema<RxDocumentData<RxDocType>>, collectionName: string, cache?: Map<string, SqlFragment | null> | SieveCache<string, SqlFragment | null>): BipartiteQuery<RxDocType>;
 export declare function buildLogicalOperator<RxDocType>(operator: 'or' | 'nor' | 'and', conditions: MangoQuerySelector<RxDocumentData<RxDocType>>[], schema: RxJsonSchema<RxDocumentData<RxDocType>>, logicalDepth: number): SqlFragment | null;
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/query/cache.d.ts

@@ -0,0 +1,18 @@
+import type { Database } from 'bun:sqlite';
+import type { SqlFragment } from './operators';
+import { SieveCache } from './sieve-cache';
+export declare const MAX_QUERY_CACHE_SIZE = 5000;
+export declare const MAX_REGEX_CACHE_SIZE = 100;
+export declare const MAX_INDEX_CACHE_SIZE = 1000;
+export declare function getQueryCache(database: Database): SieveCache<string, SqlFragment | null>;
+export declare function getGlobalCache(): SieveCache<string, SqlFragment | null>;
+export declare function getCacheSize(): number;
+export declare function clearCache(): void;
+export interface RegexCacheEntry {
+    regex: RegExp;
+}
+export declare function getRegexCache(): SieveCache<string, RegexCacheEntry>;
+export declare function clearRegexCache(): void;
+export declare function getIndexCache(): SieveCache<string, boolean>;
+export declare function clearIndexCache(): void;
+//# sourceMappingURL=cache.d.ts.map

package/dist/src/query/no-op-cache.d.ts

@@ -0,0 +1,10 @@
+import type { SqlFragment } from './operators';
+export declare class NoOpCache<K, V> {
+    get size(): number;
+    has(_key: K): boolean;
+    get(_key: K): V | undefined;
+    set(_key: K, _value: V): this;
+    clear(): void;
+}
+export declare const NO_CACHE: NoOpCache<string, SqlFragment | null>;
+//# sourceMappingURL=no-op-cache.d.ts.map

package/dist/src/query/sieve-cache.d.ts

@@ -0,0 +1,17 @@
+export declare class SieveCache<K, V> {
+    #private;
+    constructor(capacity: number);
+    get size(): number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callbackfn: (value: V, key: K, map: SieveCache<K, V>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=sieve-cache.d.ts.map

package/dist/src/query/smart-regex.d.ts

@@ -3,6 +3,5 @@ export interface SqlFragment {
     sql: string;
     args: (string | number | boolean)[];
 }
-export declare function clearRegexCache(): void;
 export declare function smartRegexToLike<RxDocType>(field: string, pattern: string, options: string | undefined, schema: RxJsonSchema<RxDocumentData<RxDocType>>, fieldName: string): SqlFragment | null;
 //# sourceMappingURL=smart-regex.d.ts.map

package/dist/src/types.d.ts

@@ -12,6 +12,16 @@ export interface BunSQLiteStorageSettings {
      * @default 268435456 (256MB)
      */
     mmapSize?: number;
+    /**
+     * Use generated columns for _deleted and _meta.lwt fields.
+     * - false: Regular columns with manual extraction (baseline)
+     * - 'virtual': VIRTUAL generated columns (computed on-the-fly, no storage overhead) - RECOMMENDED
+     * - 'stored': STORED generated columns (pre-computed, +11% storage, 58% faster queries)
+     * Requires SQLite 3.31.0+ (Bun 1.0+ includes SQLite 3.42+).
+     * @default 'virtual'
+     * @experimental Alpha feature - opt-in for testing
+     */
+    useStoredColumns?: false | 'virtual' | 'stored';
 }
 export interface BunSQLiteInternals {
     db: Database;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-sqlite-for-rxdb",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "author": "adam2am",
   "repository": {
     "type": "git",