bun-sqlite-for-rxdb 1.5.3 → 1.5.6

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) {
@@ -12286,32 +12463,33 @@ function getColumnInfo(path2, schema) {
   const properties = schema.properties;
   const fieldSchema = properties?.[path2];
   if (fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema) {
-    if (fieldSchema.type === "array") {
+    const schemaType = fieldSchema.type;
+    if (schemaType === "array") {
       return { jsonPath: `$.${path2}`, type: "array" };
     }
+    if (schemaType === "string") {
+      return { jsonPath: `$.${path2}`, type: "string" };
+    }
+    if (schemaType === "number") {
+      return { jsonPath: `$.${path2}`, type: "number" };
+    }
+    if (schemaType === "boolean") {
+      return { jsonPath: `$.${path2}`, type: "boolean" };
+    }
   }
   return { jsonPath: `$.${path2}`, type: "unknown" };
 }
 
 // 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 +12501,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) {
@@ -12363,32 +12536,41 @@ function smartRegexToLike(field, pattern, options, schema, fieldName) {
   const escaped = escapeForLike(unescaped);
   if (startsWithAnchor && endsWithAnchor) {
     if (caseInsensitive) {
-      return hasLowerIndex ? { sql: `LOWER(${field}) = ?`, args: [unescaped.toLowerCase()] } : { sql: `${field} = ? COLLATE NOCASE`, args: [unescaped] };
+      return { sql: `LOWER(${field}) = LOWER(?)`, args: [unescaped] };
     }
     return { sql: `${field} = ?`, args: [unescaped] };
   }
   if (startsWithAnchor) {
-    const suffix = caseInsensitive ? escaped.toLowerCase() : escaped;
-    if (caseInsensitive && hasLowerIndex) {
-      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: [suffix + "%"] };
+    if (caseInsensitive) {
+      return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: [escaped + "%"] };
     }
-    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: [suffix + "%"] };
+    return { sql: `${field} LIKE ? ESCAPE '\\'`, args: [escaped + "%"] };
   }
   if (endsWithAnchor) {
-    const prefix = caseInsensitive ? escaped.toLowerCase() : escaped;
-    if (caseInsensitive && hasLowerIndex) {
-      return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + prefix] };
+    if (caseInsensitive) {
+      return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: ["%" + escaped] };
     }
-    return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + prefix] };
+    return { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped] };
   }
-  const middle = caseInsensitive ? escaped.toLowerCase() : escaped;
-  if (caseInsensitive && hasLowerIndex) {
-    return { sql: `LOWER(${field}) LIKE ? ESCAPE '\\'`, args: ["%" + middle + "%"] };
+  if (caseInsensitive) {
+    return { sql: `LOWER(${field}) LIKE LOWER(?) ESCAPE '\\'`, args: ["%" + escaped + "%"] };
   }
-  return { sql: `${field} LIKE ?${caseInsensitive ? " COLLATE NOCASE" : ""} ESCAPE '\\'`, args: ["%" + middle + "%"] };
+  return { sql: `${field} LIKE ? ESCAPE '\\'`, args: ["%" + escaped + "%"] };
 }
 
 // src/query/operators.ts
+function buildJsonPath(fieldName) {
+  const segments = fieldName.split(".");
+  let path2 = "$";
+  for (const segment of segments) {
+    if (/^\d+$/.test(segment)) {
+      path2 += `[${segment}]`;
+    } else {
+      path2 += `.${segment}`;
+    }
+  }
+  return path2;
+}
 function normalizeValueForSQLite(value) {
   if (value instanceof Date) {
     return value.toISOString();
@@ -12552,6 +12734,18 @@ function translateExists(field, exists) {
   };
 }
 function translateRegex(field, pattern, options, schema, fieldName) {
+  const columnInfo = getColumnInfo(fieldName, schema);
+  const isArray = field !== "value" && columnInfo.type === "array";
+  if (isArray) {
+    const smartResult2 = smartRegexToLike("value", pattern, options, schema, fieldName);
+    if (smartResult2) {
+      return {
+        sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${smartResult2.sql})`,
+        args: smartResult2.args
+      };
+    }
+    return null;
+  }
   const smartResult = smartRegexToLike(field, pattern, options, schema, fieldName);
   if (smartResult)
     return smartResult;
@@ -12594,7 +12788,7 @@ function handleLogicalOperator(operator, value, schema, baseFieldName) {
   };
 }
 function handleFieldCondition(fieldName, value, schema, baseFieldName) {
-  const propertyField = `json_extract(value, '$.${fieldName}')`;
+  const propertyField = `json_extract(value, '${buildJsonPath(fieldName)}')`;
   const nestedFieldName = `${baseFieldName}.${fieldName}`;
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     if (value instanceof RegExp) {
@@ -12668,17 +12862,14 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   if (typeof criteria === "object" && criteria !== null && !Array.isArray(criteria) && Object.keys(criteria).length === 0) {
     return { sql: "1=0", args: [] };
   }
-  if (typeof criteria !== "object" || criteria === null) {
-    return {
-      sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE value = ?)`,
-      args: [criteria]
-    };
+  if (typeof criteria !== "object" || criteria === null || Array.isArray(criteria)) {
+    return null;
   }
   if (criteria.$and && Array.isArray(criteria.$and)) {
     const fragments = criteria.$and.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" AND ");
+    const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" AND ");
     const args = fragments.flatMap((f) => f.args);
     return {
       sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
@@ -12689,7 +12880,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const fragments = criteria.$or.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
       sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${sql})`,
@@ -12700,7 +12891,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
     const fragments = criteria.$nor.map((cond) => buildElemMatchConditions(cond, schema, actualFieldName));
     if (fragments.some((f) => f === null))
       return null;
-    const sql = fragments.map((f) => f.sql).join(" OR ");
+    const sql = fragments.map((f) => `COALESCE((${f.sql}), 0)`).join(" OR ");
     const args = fragments.flatMap((f) => f.args);
     return {
       sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE NOT (${sql}))`,
@@ -12711,7 +12902,7 @@ function translateElemMatch(field, criteria, schema, actualFieldName) {
   if (!fragment)
     return null;
   return {
-    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${fragment.sql})`,
+    sql: `EXISTS (SELECT 1 FROM jsonb_each(${field}) WHERE ${asBoolean(fragment.sql)})`,
     args: fragment.args
   };
 }
@@ -12735,8 +12926,21 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
       return translateNin(field, value, schema, actualFieldName);
     case "$exists":
       return translateExists(field, value);
-    case "$size":
-      return translateSize(field, value);
+    case "$size": {
+      const columnInfo = getColumnInfo(actualFieldName, schema);
+      if (columnInfo.type !== "array" && columnInfo.type !== "unknown") {
+        return { sql: "1=0", args: [] };
+      }
+      let jsonColumn = "data";
+      let jsonPath = actualFieldName;
+      let isDirectPath = false;
+      if (field === "value") {
+        jsonColumn = "value";
+        jsonPath = "";
+        isDirectPath = true;
+      }
+      return translateSize(jsonColumn, jsonPath, value, isDirectPath);
+    }
     case "$mod": {
       const result = translateMod(field, value);
       if (!result)
@@ -12802,9 +13006,12 @@ function translateLeafOperator(op, field, value, schema, actualFieldName) {
       return translateEq(field, value, schema, actualFieldName);
   }
 }
+function asBoolean(sql) {
+  return `COALESCE((${sql}), 0)`;
+}
 function wrapWithNot(innerFragment) {
   return {
-    sql: `NOT (${innerFragment.sql})`,
+    sql: `NOT (${asBoolean(innerFragment.sql)})`,
     args: innerFragment.args
   };
 }
@@ -12814,22 +13021,28 @@ function translateType(jsonColumn, fieldName, type6, isDirectPath = false) {
     case "null":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'null'`, args: [] };
     case "boolean":
+    case "bool":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('true', 'false')`, args: [] };
     case "number":
+    case "int":
+    case "long":
+    case "double":
+    case "decimal":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') IN ('integer', 'real')`, args: [] };
     case "string":
-      return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'text'`, args: [] };
+      return { sql: `COALESCE(json_type(${jsonColumn}, '${jsonPath}') = 'text', 0)`, args: [] };
     case "array":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'array'`, args: [] };
     case "object":
       return { sql: `json_type(${jsonColumn}, '${jsonPath}') = 'object'`, args: [] };
     default:
-      return { sql: "1=0", args: [] };
+      return null;
   }
 }
-function translateSize(field, size) {
+function translateSize(jsonColumn, jsonPath, size, isDirectPath = false) {
+  const path2 = isDirectPath ? jsonPath : `$.${jsonPath}`;
   return {
-    sql: `json_array_length(${field}) = ?`,
+    sql: `json_array_length(${jsonColumn}, '${path2}') = ?`,
     args: [size]
   };
 }
@@ -12949,29 +13162,50 @@ 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 = `v3_${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 coerceToBoolean(sql) {
+  return `COALESCE((${sql}), 0)`;
+}
 function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
   if (conditions.length === 0) {
     return { sql: operator === "or" ? "1=0" : "1=1", args: [] };
@@ -12979,9 +13213,12 @@ function buildLogicalOperator(operator, conditions, schema, logicalDepth) {
   const fragments = conditions.map((subSelector) => processSelector(subSelector, schema, logicalDepth + 1));
   if (fragments.some((f) => f === null))
     return null;
-  const sql = fragments.map((f) => `(${f.sql})`).join(" OR ");
+  const sql = fragments.map((f) => f.sql).join(operator === "and" ? " AND " : " OR ");
   const args = fragments.flatMap((f) => f.args);
-  return operator === "nor" ? { sql: `NOT(${sql})`, args } : { sql, args };
+  if (operator === "nor") {
+    return { sql: `NOT(${coerceToBoolean(sql)})`, args };
+  }
+  return { sql, args };
 }
 function processSelector(selector, schema, logicalDepth) {
   if (!selector || typeof selector !== "object")
@@ -13016,8 +13253,16 @@ 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 fieldName = columnInfo.column || `json_extract(data, '${buildJsonPath(field)}')`;
     const actualFieldName = columnInfo.jsonPath?.replace(/^\$\./, "") || columnInfo.column || field;
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
       if (Object.keys(value).length === 0) {
@@ -13028,15 +13273,15 @@ function processSelector(selector, schema, logicalDepth) {
         let fragment;
         if (op === "$not") {
           if (typeof opValue !== "object" || opValue === null || Array.isArray(opValue)) {
-            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
-            if (!eqFrag)
+            const neFrag = translateLeafOperator("$ne", fieldName, opValue, schema, actualFieldName);
+            if (!neFrag)
               return null;
-            fragment = wrapWithNot(eqFrag);
+            fragment = neFrag;
           } else if (opValue instanceof Date) {
-            const eqFrag = translateLeafOperator("$eq", fieldName, opValue, schema, actualFieldName);
-            if (!eqFrag)
+            const neFrag = translateLeafOperator("$ne", fieldName, opValue, schema, actualFieldName);
+            if (!neFrag)
               return null;
-            fragment = wrapWithNot(eqFrag);
+            fragment = neFrag;
           } else if (opValue instanceof RegExp) {
             const regexFrag = translateLeafOperator("$regex", fieldName, opValue, schema, actualFieldName);
             if (!regexFrag)
@@ -13077,16 +13322,23 @@ function processSelector(selector, schema, logicalDepth) {
             } else {
               const hasOperators = innerKeys.some((k) => k.startsWith("$"));
               if (!hasOperators) {
-                const eqFrag = translateLeafOperator("$eq", fieldName, opValueObj, schema, actualFieldName);
-                if (!eqFrag)
+                const neFrag = translateLeafOperator("$ne", fieldName, opValueObj, schema, actualFieldName);
+                if (!neFrag)
                   return null;
-                fragment = wrapWithNot(eqFrag);
+                fragment = neFrag;
               } else {
                 const [[innerOp, innerVal]] = Object.entries(opValueObj);
-                const innerFrag = translateLeafOperator(innerOp, fieldName, innerVal, schema, actualFieldName);
-                if (!innerFrag)
-                  return null;
-                fragment = wrapWithNot(innerFrag);
+                if (innerOp === "$eq") {
+                  const neFrag = translateLeafOperator("$ne", fieldName, innerVal, schema, actualFieldName);
+                  if (!neFrag)
+                    return null;
+                  fragment = neFrag;
+                } else {
+                  const innerFrag = translateLeafOperator(innerOp, fieldName, innerVal, schema, actualFieldName);
+                  if (!innerFrag)
+                    return null;
+                  fragment = wrapWithNot(innerFrag);
+                }
               }
             }
           }
@@ -13111,7 +13363,7 @@ function processSelector(selector, schema, logicalDepth) {
         } else if (op === "$options") {
           continue;
         } else if (!op.startsWith("$")) {
-          const jsonPath = `json_extract(${fieldName}, '$.${op}')`;
+          const jsonPath = `json_extract(${fieldName}, '${buildJsonPath(op)}')`;
           const nestedFieldName = `${actualFieldName}.${op}`;
           const leafFrag = translateLeafOperator("$eq", jsonPath, opValue, schema, nestedFieldName);
           if (!leafFrag)
@@ -13529,9 +13781,6 @@ class StatementManager {
     this.closed = true;
   }
   isStaticSQL(query) {
-    if (query.includes("WHERE (")) {
-      return false;
-    }
     return true;
   }
 }
@@ -13594,7 +13843,7 @@ class BunSQLiteStorageInstance {
   db;
   stmtManager;
   changeStream$ = new import_rxjs2.Subject;
-  queryCache = new Map;
+  queryCache;
   databaseName;
   collectionName;
   schema;
@@ -13602,6 +13851,7 @@ class BunSQLiteStorageInstance {
   options;
   primaryPath;
   tableName;
+  useStoredColumns;
   closed;
   constructor(params, settings = {}) {
     ensureRxStorageInstanceParamsAreCorrect(params);
@@ -13612,9 +13862,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
@@ -13622,6 +13874,7 @@ class BunSQLiteStorageInstance {
     this.initTable(filename);
   }
   initTable(filename) {
+    this.db.run("PRAGMA case_sensitive_like = ON");
     if (filename !== ":memory:") {
       this.db.run("PRAGMA journal_mode = WAL");
       this.db.run("PRAGMA synchronous = NORMAL");
@@ -13635,15 +13888,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 +13952,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 +14058,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 +14097,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 +14141,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 +14174,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 +14221,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/debug-array-index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debug-array-index.d.ts.map

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/operators.d.ts

@@ -8,6 +8,7 @@ type OperatorExpression = {
     [key: string]: unknown;
 };
 export type ElemMatchCriteria = QueryValue | OperatorExpression;
+export declare function buildJsonPath(fieldName: string): string;
 export declare function translateEq<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
 export declare function translateNe<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
 export declare function translateGt<RxDocType>(field: string, value: unknown, schema?: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName?: string): SqlFragment;
@@ -22,7 +23,7 @@ export declare function translateElemMatch<RxDocType>(field: string, criteria: E
 export declare function translateLeafOperator<RxDocType>(op: string, field: string, value: unknown, schema: RxJsonSchema<RxDocumentData<RxDocType>>, actualFieldName: string): SqlFragment | null;
 export declare function wrapWithNot(innerFragment: SqlFragment): SqlFragment;
 export declare function translateType(jsonColumn: string, fieldName: string, type: string, isDirectPath?: boolean): SqlFragment | null;
-export declare function translateSize(field: string, size: number): SqlFragment;
+export declare function translateSize(jsonColumn: string, jsonPath: string, size: number, isDirectPath?: boolean): SqlFragment;
 export declare function translateMod(field: string, value: unknown): SqlFragment | null;
 export {};
 //# sourceMappingURL=operators.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.3",
+  "version": "1.5.6",
   "author": "adam2am",
   "repository": {
     "type": "git",
@@ -14,6 +14,7 @@
   "main": "dist/index.js",
   "dependencies": {},
   "devDependencies": {
+    "@msgpack/msgpack": "^3.1.3",
     "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "better-sqlite3": "^12.6.2",