@tanstack/db-sqlite-persistence-core 0.4.1 → 0.4.4

package/dist/esm/sqlite-core-adapter.js

@@ -1,8 +1,8 @@
 import { IR, toBooleanPredicate, compileSingleRowExpression } from "@tanstack/db";
 import { InvalidPersistedCollectionConfigError, InvalidPersistedStorageKeyEncodingError } from "./errors.js";
 import { encodePersistedStorageKey, createPersistedTableName, decodePersistedStorageKey, SQLITE_DRIVER_SHARED_LOGICAL_SCHEDULING_KEY } from "./persisted.js";
-import { PERSISTED_TYPE_TAG, PERSISTED_VALUE_TAG, serializeSQLiteBigInt, assertSQLiteBigIntInRange } from "./sqlite-value.js";
-const REPLACEMENT_BATCH_SIZE = 100;
+import { assertSQLiteBigIntInRange, PERSISTED_TYPE_TAG, PERSISTED_VALUE_TAG, serializeSQLiteBigInt } from "./sqlite-value.js";
+const REPLACEMENT_BATCH_SIZE = 125;
 class SharedPersistenceScheduler {
   constructor() {
     this.regularQueue = [];
@@ -94,6 +94,7 @@ function observeSharedLogicalSchedulingSupport(driver, onSupport) {
     return promise;
   };
   return {
+    maxBoundParameters: driver.maxBoundParameters,
     exec: (sql) => observe(driver.exec(sql)),
     query: (sql, params = []) => observe(driver.query(sql, params)),
     run: (sql, params = []) => observe(driver.run(sql, params)),
@@ -107,7 +108,6 @@ const DEFAULT_SCHEMA_VERSION = 1;
 const DEFAULT_PULL_SINCE_RELOAD_THRESHOLD = 128;
 const DEFAULT_APPLIED_TX_PRUNE_MAX_ROWS = 1e3;
 const DEFAULT_APPLIED_TX_PRUNE_MAX_AGE_SECONDS = 24 * 60 * 60;
-const SQLITE_MAX_IN_BATCH_SIZE = 900;
 const SAFE_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 const FORBIDDEN_SQL_FRAGMENT_PATTERN = /(;|--|\/\*)/;
 const persistedTaggedValueTypes = /* @__PURE__ */ new Set([
@@ -379,6 +379,33 @@ function createJsonPath(path) {
   }
   return jsonPath;
 }
+const MAX_INDEXED_NUMERIC_PATH_SEGMENTS = 3;
+function hasDeepNumericPath(expression) {
+  if (expression.type === `ref`) {
+    return IR.getPropRefPropertyPath(expression).filter(
+      (segment) => /^[0-9]+$/.test(String(segment))
+    ).length > MAX_INDEXED_NUMERIC_PATH_SEGMENTS;
+  }
+  return expression.type === `func` && expression.args.some(hasDeepNumericPath);
+}
+function createJsonPathVariants(path) {
+  const canonical = createJsonPath(path);
+  if (!canonical) return null;
+  let paths = [`$`];
+  for (const segment of path) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment)) {
+      paths = paths.map((prefix) => `${prefix}.${segment}`);
+    } else if (/^[0-9]+$/.test(segment)) {
+      if (paths.length >= 2 ** MAX_INDEXED_NUMERIC_PATH_SEGMENTS)
+        return [canonical];
+      paths = paths.flatMap((prefix) => [
+        `${prefix}[${segment}]`,
+        `${prefix}."${segment}"`
+      ]);
+    }
+  }
+  return paths;
+}
 function getLiteralValueKind(value) {
   if (typeof value === `bigint`) {
     return `bigint`;
@@ -486,8 +513,24 @@ function argumentCompilationContext(parentName, argumentIndex, argument, parentC
       return `index-expression`;
   }
 }
+function hasUnpairedSurrogate(value) {
+  return /[\uD800-\uDFFF]/u.test(value);
+}
+function isSafeEqualityLiteral(value) {
+  return typeof value === `string` || typeof value === `boolean` || typeof value === `bigint`;
+}
+function isSafeCoalesceOperand(expression) {
+  return expression?.type === `func` && expression.name === `coalesce` && expression.args.length === 2 && expression.args[0]?.type === `ref` && expression.args[1]?.type === `val` && isSafeEqualityLiteral(expression.args[1].value) && !(typeof expression.args[1].value === `string` && hasUnpairedSurrogate(expression.args[1].value));
+}
 function compileSqlExpression(expression, context = `predicate`) {
   if (expression.type === `val`) {
+    if (context === `predicate` && typeof expression.value === `string` && hasUnpairedSurrogate(expression.value)) {
+      return {
+        supported: true,
+        sql: `json_extract(?, '$')`,
+        params: [JSON.stringify(expression.value)]
+      };
+    }
     const valueKind = getLiteralValueKind(expression.value);
     return {
       supported: true,
@@ -497,17 +540,23 @@ function compileSqlExpression(expression, context = `predicate`) {
     };
   }
   if (expression.type === `ref`) {
-    const jsonPath = createJsonPath(
+    const jsonPaths = createJsonPathVariants(
       IR.getPropRefPropertyPath(expression).map(String)
     );
-    if (!jsonPath) {
+    if (!jsonPaths) {
       return {
         supported: false,
         sql: ``,
         params: []
       };
     }
-    return compileRefExpressionSql(jsonPath);
+    if (jsonPaths.length === 1) return compileRefExpressionSql(jsonPaths[0]);
+    return {
+      supported: true,
+      sql: `COALESCE(${jsonPaths.map((path) => compileRefExpressionSql(path).sql).join(`, `)})`,
+      params: [],
+      valueKind: `unknown`
+    };
   }
   const compiledArgs = expression.args.map(
     (arg, index) => compileSqlExpression(
@@ -561,23 +610,18 @@ function compileSqlExpression(expression, context = `predicate`) {
         params
       };
     }
-    case `and`: {
-      if (argSql.length < 2) {
-        return { supported: false, sql: ``, params: [] };
-      }
-      return {
-        supported: true,
-        sql: argSql.map((sql) => `(${sql})`).join(` AND `),
-        params
-      };
-    }
+    case `and`:
     case `or`: {
-      if (argSql.length < 2) {
-        return { supported: false, sql: ``, params: [] };
+      if (argSql.length === 0) {
+        return {
+          supported: true,
+          sql: expression.name === `and` ? `(1 = 1)` : `(0 = 1)`,
+          params: []
+        };
       }
       return {
         supported: true,
-        sql: argSql.map((sql) => `(${sql})`).join(` OR `),
+        sql: argSql.map((sql) => `(${sql})`).join(expression.name === `and` ? ` AND ` : ` OR `),
         params
       };
     }
@@ -614,37 +658,13 @@ function compileSqlExpression(expression, context = `predicate`) {
           params: leftParams
         };
       }
-      if (listValue.length > SQLITE_MAX_IN_BATCH_SIZE) {
-        const chunkClauses = [];
-        const batchedParams = [];
-        for (let startIndex = 0; startIndex < listValue.length; startIndex += SQLITE_MAX_IN_BATCH_SIZE) {
-          const chunkValues = listValue.slice(
-            startIndex,
-            startIndex + SQLITE_MAX_IN_BATCH_SIZE
-          );
-          const chunkParams = [];
-          const chunkValueSql = chunkValues.map((value) => {
-            chunkParams.push(toSqliteParameterValue(value));
-            return typeof value === `bigint` ? `CAST(? AS NUMERIC)` : `?`;
-          });
-          chunkClauses.push(`(${leftSql} IN (${chunkValueSql.join(`, `)}))`);
-          batchedParams.push(...leftParams, ...chunkParams);
-        }
-        return {
-          supported: true,
-          sql: `(${chunkClauses.join(` OR `)})`,
-          params: batchedParams
-        };
-      }
-      const listParams = [];
-      const listValueSql = listValue.map((value) => {
-        listParams.push(toSqliteParameterValue(value));
-        return typeof value === `bigint` ? `CAST(? AS NUMERIC)` : `?`;
-      });
+      const jsonList = `[${listValue.map(
+        (value) => typeof value === `bigint` ? assertSQLiteBigIntInRange(value).toString() : JSON.stringify(toSqliteParameterValue(value))
+      ).join(`,`)}]`;
       return {
         supported: true,
-        sql: `(${leftSql} IN (${listValueSql.join(`, `)}))`,
-        params: [...leftParams, ...listParams]
+        sql: `(${leftSql} IN (SELECT value FROM json_each(?)))`,
+        params: [...leftParams, jsonList]
       };
     }
     case `like`:
@@ -708,6 +728,91 @@ function compileSqlExpression(expression, context = `predicate`) {
       };
   }
 }
+function compileSafeSqlPrefilter(expression, compiled) {
+  const direct = () => {
+    const candidate = compiled ?? compileSqlExpression(expression);
+    return candidate.supported ? candidate : void 0;
+  };
+  if (expression.type === `val`) {
+    return typeof expression.value === `boolean` || expression.value == null ? direct() : void 0;
+  }
+  if (expression.type === `ref`) return void 0;
+  if (expression.name === `and` || expression.name === `or`) {
+    if (expression.args.length === 0) return direct();
+    const candidates = expression.args.map(
+      (argument) => compileSafeSqlPrefilter(argument)
+    );
+    if (expression.name === `or` && candidates.some((candidate) => !candidate))
+      return void 0;
+    const selected = candidates.filter(
+      (candidate) => candidate !== void 0
+    );
+    if (selected.length === 0) return void 0;
+    return {
+      supported: true,
+      sql: selected.map(({ sql }) => `(${sql})`).join(expression.name === `and` ? ` AND ` : ` OR `),
+      params: selected.flatMap(({ params }) => params)
+    };
+  }
+  if (hasDeepNumericPath(expression)) return void 0;
+  compiled ??= compileSqlExpression(expression);
+  if (!compiled.supported) return void 0;
+  const [left, right] = expression.args;
+  if (expression.args.length === 2) {
+    if ([`gt`, `gte`, `lt`, `lte`].includes(expression.name) && (left?.type === `ref` || right?.type === `ref`)) {
+      const field = left?.type === `ref` ? left : right?.type === `ref` ? right : void 0;
+      const literal = field === left ? right : left;
+      if (field && literal?.type === `val` && (typeof literal.value === `number` && Number.isSafeInteger(literal.value) || typeof literal.value === `bigint`)) {
+        const fieldSql = compileSqlExpression(field, `index-expression`).sql;
+        const literalSql = compileSqlExpression(
+          literal,
+          typeof literal.value === `bigint` ? `index-expression` : `predicate`
+        );
+        const greaterSide = field === left && [`gt`, `gte`].includes(expression.name) || field === right && [`lt`, `lte`].includes(expression.name);
+        const unsafeBigInt = typeof literal.value === `bigint` && !Number.isSafeInteger(Number(literal.value));
+        const roundedNumberCandidates = unsafeBigInt ? literal.value > 0n ? ` OR ${fieldSql} >= ${Number.MAX_SAFE_INTEGER}` : ` OR ${fieldSql} <= -${Number.MAX_SAFE_INTEGER}` : ``;
+        return {
+          supported: true,
+          sql: greaterSide ? `(${fieldSql} >= ${literalSql.sql} OR ${fieldSql} IS NULL${roundedNumberCandidates})` : `(${fieldSql} <= ${literalSql.sql} OR ${fieldSql} IS NULL OR ${fieldSql} >= ''${roundedNumberCandidates})`,
+          params: literalSql.params
+        };
+      }
+    }
+    if (expression.name === `eq`) {
+      if ((left?.type === `ref` || isSafeCoalesceOperand(left)) && right?.type === `val` && isSafeEqualityLiteral(right.value) || (right?.type === `ref` || isSafeCoalesceOperand(right)) && left?.type === `val` && isSafeEqualityLiteral(left.value)) {
+        return compiled;
+      }
+      const lower = left?.type === `func` && left.name === `lower` ? left : right?.type === `func` && right.name === `lower` ? right : void 0;
+      const literal = lower === left ? right : left;
+      if (lower?.args.length === 1 && lower.args[0]?.type === `ref` && literal?.type === `val` && typeof literal.value === `string` && [...literal.value].every((char) => char.charCodeAt(0) <= 127) && !literal.value.includes(`\0`)) {
+        const lowerSql = compileSqlExpression(lower, `index-expression`).sql;
+        return {
+          supported: true,
+          sql: `(${compiled.sql} OR (${lowerSql} >= ? AND ${lowerSql} GLOB '*[^ -~]*'))`,
+          params: [...compiled.params, literal.value]
+        };
+      }
+    }
+  }
+  if (expression.name === `in` && expression.args.length === 2 && right?.type === `val` && Array.isArray(right.value)) {
+    if (right.value.length === 0) return compiled;
+    if (left?.type === `ref`) {
+      if (right.value.every((value) => typeof value === `bigint`))
+        return compiled;
+      if (right.value.every((value) => typeof value === `string`)) {
+        return {
+          supported: true,
+          sql: `(${compileSqlExpression(left, `index-expression`).sql} IN (SELECT value FROM json_each(?)))`,
+          params: [JSON.stringify(right.value)]
+        };
+      }
+    }
+  }
+  if (expression.name === `like` && expression.args.length === 2 && left?.type === `ref` && right?.type === `val` && typeof right.value === `string` && /^[\x20-\x7e]*%$/.test(right.value) && !right.value.slice(0, -1).includes(`%`) && !right.value.includes(`_`)) {
+    return compiled;
+  }
+  return void 0;
+}
 function compileOrderByClauses(orderBy) {
   if (!orderBy || orderBy.length === 0) {
     return {
@@ -797,6 +902,23 @@ function mergeObjectRows(existing, incoming) {
   }
   return incoming;
 }
+function* batches(changes, maxSize) {
+  for (let offset = 0; offset < changes.length; offset += maxSize) {
+    yield changes.slice(offset, offset + maxSize);
+  }
+}
+function lastMetadataByKey(changes, keyOf, undefinedSetIsNull = false) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const key = keyOf(change);
+    const previous = latest.get(key);
+    if (previous?.type === `set` && (previous.value !== void 0 || !undefinedSetIsNull) && serializePersistedRowValue(previous.value) === void 0) {
+      throw new TypeError(`Metadata value cannot be bound to SQLite`);
+    }
+    latest.set(key, change);
+  }
+  return [...latest.values()];
+}
 function buildIndexName(collectionId, signature) {
   const sanitizedSignature = signature.toLowerCase().replace(/[^a-z0-9]+/g, `_`).replace(/^_+|_+$/g, ``).slice(0, 24);
   const hashSource = `${collectionId}:${signature}`;
@@ -1116,158 +1238,172 @@ class SQLiteCorePersistenceAdapter {
         await transactionDriver.run(`DELETE FROM ${collectionTableSql}`);
         await transactionDriver.run(`DELETE FROM ${tombstoneTableSql}`);
       }
-      const replacementKeys = replacesPersistedBaseline ? tx.mutations.map(
-        (mutation) => encodePersistedStorageKey(mutation.key)
-      ) : [];
-      const batchReplacement = replacesPersistedBaseline && tx.mutations.length > 0 && tx.mutations.every((mutation) => mutation.type !== `delete`) && new Set(replacementKeys).size === replacementKeys.length;
-      if (batchReplacement) {
-        const finalRowMetadata = /* @__PURE__ */ new Map();
-        for (const mutation of tx.rowMetadataMutations ?? []) {
-          finalRowMetadata.set(
-            encodePersistedStorageKey(mutation.key),
-            mutation.type === `delete` ? void 0 : mutation.value
-          );
+      const rowMutations = /* @__PURE__ */ new Map();
+      for (const mutation of tx.mutations) {
+        const key = encodePersistedStorageKey(mutation.key);
+        const previous = rowMutations.get(key);
+        if (!previous) {
+          rowMutations.set(key, mutation);
+          continue;
+        }
+        serializePersistedRowValue(previous.value);
+        if (previous.type !== `delete` && previous.metadataChanged === true && previous.metadata !== void 0) {
+          serializePersistedRowValue(previous.metadata);
         }
-        for (let start = 0; start < tx.mutations.length; start += this.replacementBatchSize) {
-          const mutations = tx.mutations.slice(
-            start,
-            start + this.replacementBatchSize
+        if (mutation.type === `delete`) {
+          rowMutations.set(key, mutation);
+          continue;
+        }
+        const value = mutation.type === `insert` || previous.type === `delete` ? mutation.value : mergeObjectRows(previous.value, mutation.value);
+        const metadataChanged = mutation.metadataChanged === true || previous.type === `delete` || previous.metadataChanged === true;
+        const metadata = mutation.metadataChanged === true ? mutation.metadata : previous.type === `delete` ? void 0 : previous.metadata;
+        const next = { key: mutation.key, value, metadataChanged, metadata };
+        rowMutations.set(
+          key,
+          mutation.type === `insert` || previous.type !== `update` ? { type: `insert`, ...next } : { type: `update`, ...next }
+        );
+      }
+      for (const batch of batches(
+        [...rowMutations.values()],
+        this.replacementBatchSize
+      )) {
+        const writes = batch.filter((mutation) => mutation.type !== `delete`);
+        const deletes = batch.filter((mutation) => mutation.type === `delete`);
+        const readKeys = writes.filter(
+          (mutation) => mutation.type === `update` || mutation.metadataChanged !== true
+        ).map((mutation) => encodePersistedStorageKey(mutation.key));
+        const existingRows = readKeys.length > 0 ? await transactionDriver.query(
+          `SELECT key, value, metadata
+               FROM ${collectionTableSql}
+               WHERE key IN (${readKeys.map(() => `?`).join(`, `)})`,
+          readKeys
+        ) : [];
+        const existing = new Map(existingRows.map((row) => [row.key, row]));
+        const writeKeys = writes.map(
+          (mutation) => encodePersistedStorageKey(mutation.key)
+        );
+        const deleteKeys = deletes.map(
+          (mutation) => encodePersistedStorageKey(mutation.key)
+        );
+        if (tracksPersistedKeySet && writeKeys.length > 0) {
+          await transactionDriver.run(
+            `INSERT INTO collection_expected_keys (collection_id, key)
+             VALUES ${writeKeys.map(() => `(?, ?)`).join(`, `)}
+             ON CONFLICT(collection_id, key) DO NOTHING`,
+            writeKeys.flatMap((key) => [collectionId, key])
           );
-          const keys = replacementKeys.slice(
-            start,
-            start + this.replacementBatchSize
+        }
+        if (tracksPersistedKeySet && deleteKeys.length > 0) {
+          await transactionDriver.run(
+            `DELETE FROM collection_expected_keys
+             WHERE collection_id = ? AND key IN (${deleteKeys.map(() => `?`).join(`, `)})`,
+            [collectionId, ...deleteKeys]
           );
+        }
+        if (deleteKeys.length > 0) {
           await transactionDriver.run(
-            `INSERT INTO collection_expected_keys (collection_id, key)
-             VALUES ${keys.map(() => `(?, ?)`).join(`, `)}`,
-            keys.flatMap((key) => [collectionId, key])
+            `DELETE FROM ${collectionTableSql}
+             WHERE key IN (${deleteKeys.map(() => `?`).join(`, `)})`,
+            deleteKeys
           );
+        }
+        if (writeKeys.length > 0) {
           await transactionDriver.run(
             `INSERT INTO ${collectionTableSql} (key, value, metadata, row_version)
-             VALUES ${keys.map(() => `(?, ?, ?, ?)`).join(`, `)}`,
-            mutations.flatMap((mutation, index) => {
-              const key = keys[index];
-              const metadata = finalRowMetadata.has(key) ? finalRowMetadata.get(key) : mutation.type !== `delete` && mutation.metadataChanged === true ? mutation.metadata : void 0;
+             VALUES ${writeKeys.map(() => `(?, ?, ?, ?)`).join(`, `)}
+             ON CONFLICT(key) DO UPDATE SET
+               value = excluded.value,
+               metadata = excluded.metadata,
+               row_version = excluded.row_version`,
+            writes.flatMap((mutation, index) => {
+              const previous = existing.get(writeKeys[index]);
+              const previousValue = previous?.value ? deserializePersistedRowValue(previous.value) : void 0;
+              const previousMetadata = previous?.metadata != null ? deserializePersistedRowValue(previous.metadata) : void 0;
+              const value = mutation.type === `update` ? mergeObjectRows(previousValue, mutation.value) : mutation.value;
+              const metadata = mutation.metadataChanged === true ? mutation.metadata : previousMetadata;
               return [
-                key,
-                serializePersistedRowValue(mutation.value),
+                writeKeys[index],
+                serializePersistedRowValue(value),
                 metadata === void 0 ? null : serializePersistedRowValue(metadata),
                 nextRowVersion
               ];
             })
           );
-        }
-      }
-      for (const mutation of batchReplacement ? [] : tx.mutations) {
-        const encodedKey = encodePersistedStorageKey(mutation.key);
-        if (mutation.type === `delete`) {
-          if (tracksPersistedKeySet) {
-            await transactionDriver.run(
-              `DELETE FROM collection_expected_keys
-               WHERE collection_id = ? AND key = ?`,
-              [collectionId, encodedKey]
-            );
-          }
           await transactionDriver.run(
-            `DELETE FROM ${collectionTableSql}
-             WHERE key = ?`,
-            [encodedKey]
+            `DELETE FROM ${tombstoneTableSql}
+             WHERE key IN (${writeKeys.map(() => `?`).join(`, `)})`,
+            writeKeys
           );
+        }
+        if (deletes.length > 0) {
           await transactionDriver.run(
             `INSERT INTO ${tombstoneTableSql} (key, value, row_version, deleted_at)
-             VALUES (?, ?, ?, ?)
+             VALUES ${deleteKeys.map(() => `(?, ?, ?, ?)`).join(`, `)}
              ON CONFLICT(key) DO UPDATE SET
                value = excluded.value,
                row_version = excluded.row_version,
                deleted_at = excluded.deleted_at`,
-            [
-              encodedKey,
+            deletes.flatMap((mutation, index) => [
+              deleteKeys[index],
               serializePersistedRowValue(mutation.value),
               nextRowVersion,
               (/* @__PURE__ */ new Date()).toISOString()
-            ]
+            ])
           );
-          continue;
         }
-        const existingRows = await transactionDriver.query(
-          `SELECT value, metadata
-           FROM ${collectionTableSql}
-           WHERE key = ?
-           LIMIT 1`,
-          [encodedKey]
+      }
+      for (const batch of batches(
+        lastMetadataByKey(
+          tx.rowMetadataMutations ?? [],
+          (mutation) => encodePersistedStorageKey(mutation.key),
+          true
+        ),
+        this.replacementBatchSize
+      )) {
+        const keys = batch.map(
+          (mutation) => encodePersistedStorageKey(mutation.key)
         );
-        const existingValue = existingRows[0]?.value ? deserializePersistedRowValue(existingRows[0].value) : void 0;
-        const existingMetadata = existingRows[0]?.metadata != null ? deserializePersistedRowValue(existingRows[0].metadata) : void 0;
-        const mergedValue = mutation.type === `update` ? mergeObjectRows(existingValue, mutation.value) : mutation.value;
-        const nextMetadata = mutation.metadataChanged === true ? mutation.metadata : existingMetadata;
-        if (tracksPersistedKeySet) {
-          await transactionDriver.run(
-            `INSERT INTO collection_expected_keys (collection_id, key)
-             VALUES (?, ?)
-             ON CONFLICT(collection_id, key) DO NOTHING`,
-            [collectionId, encodedKey]
-          );
-        }
         await transactionDriver.run(
-          `INSERT INTO ${collectionTableSql} (key, value, metadata, row_version)
-           VALUES (?, ?, ?, ?)
-           ON CONFLICT(key) DO UPDATE SET
-             value = excluded.value,
-             metadata = excluded.metadata,
-             row_version = excluded.row_version`,
+          `UPDATE ${collectionTableSql}
+           SET metadata = CASE key ${keys.map(() => `WHEN ? THEN ?`).join(` `)} END
+           WHERE key IN (${keys.map(() => `?`).join(`, `)})`,
           [
-            encodedKey,
-            serializePersistedRowValue(mergedValue),
-            nextMetadata === void 0 ? null : serializePersistedRowValue(nextMetadata),
-            nextRowVersion
+            ...batch.flatMap((mutation, index) => [
+              keys[index],
+              mutation.type === `delete` || mutation.value === void 0 ? null : serializePersistedRowValue(mutation.value)
+            ]),
+            ...keys
           ]
         );
-        await transactionDriver.run(
-          `DELETE FROM ${tombstoneTableSql}
-           WHERE key = ?`,
-          [encodedKey]
-        );
       }
-      for (const rowMetadataMutation of batchReplacement ? [] : tx.rowMetadataMutations ?? []) {
-        const encodedKey = encodePersistedStorageKey(rowMetadataMutation.key);
-        if (rowMetadataMutation.type === `delete`) {
-          await transactionDriver.run(
-            `UPDATE ${collectionTableSql}
-             SET metadata = NULL
-             WHERE key = ?`,
-            [encodedKey]
-          );
-        } else {
-          await transactionDriver.run(
-            `UPDATE ${collectionTableSql}
-             SET metadata = ?
-             WHERE key = ?`,
-            [
-              rowMetadataMutation.value === void 0 ? null : serializePersistedRowValue(rowMetadataMutation.value),
-              encodedKey
-            ]
-          );
-        }
-      }
-      for (const metadataMutation of tx.collectionMetadataMutations ?? []) {
-        if (metadataMutation.type === `delete`) {
+      for (const batch of batches(
+        lastMetadataByKey(
+          tx.collectionMetadataMutations ?? [],
+          (mutation) => mutation.key
+        ),
+        this.replacementBatchSize
+      )) {
+        const deletes = batch.filter((mutation) => mutation.type === `delete`);
+        const sets = batch.filter((mutation) => mutation.type === `set`);
+        if (deletes.length > 0) {
           await transactionDriver.run(
             `DELETE FROM collection_metadata
-             WHERE collection_id = ? AND key = ?`,
-            [collectionId, metadataMutation.key]
+             WHERE collection_id = ? AND key IN (${deletes.map(() => `?`).join(`, `)})`,
+            [collectionId, ...deletes.map((mutation) => mutation.key)]
           );
-        } else {
+        }
+        if (sets.length > 0) {
           await transactionDriver.run(
             `INSERT INTO collection_metadata (collection_id, key, value, updated_at)
-             VALUES (?, ?, ?, CAST(strftime('%s', 'now') AS INTEGER))
+             VALUES ${sets.map(() => `(?, ?, ?, CAST(strftime('%s', 'now') AS INTEGER))`).join(`, `)}
              ON CONFLICT(collection_id, key) DO UPDATE SET
                value = excluded.value,
                updated_at = excluded.updated_at`,
-            [
+            sets.flatMap((mutation) => [
               collectionId,
-              metadataMutation.key,
-              serializePersistedRowValue(metadataMutation.value)
-            ]
+              mutation.key,
+              serializePersistedRowValue(mutation.value)
+            ])
           );
         }
       }
@@ -1680,18 +1816,23 @@ class SQLiteCorePersistenceAdapter {
   }
   async loadSubsetInternal(tableMapping, options, driver = this.driver) {
     const collectionTableSql = quoteIdentifier(tableMapping.tableName);
-    const whereCompiled = options.where ? compileSqlExpression(options.where) : { supported: true, sql: ``, params: [] };
+    const whereCompiled = options.where ? compileSqlExpression(options.where) : { supported: false, sql: ``, params: [] };
+    const safePrefilter = options.where ? compileSafeSqlPrefilter(options.where, whereCompiled) : void 0;
     const orderByCompiled = compileOrderByClauses(options.orderBy);
     const queryParams = [];
     let sql = `SELECT key, value, metadata, row_version FROM ${collectionTableSql}`;
-    if (options.where && whereCompiled.supported) {
-      sql = `${sql} WHERE ${whereCompiled.sql}`;
-      queryParams.push(...whereCompiled.params);
+    if (safePrefilter) {
+      sql = `${sql} WHERE ${safePrefilter.sql}`;
+      queryParams.push(...safePrefilter.params);
     }
     if (options.orderBy && orderByCompiled.supported) {
       sql = `${sql} ORDER BY ${orderByCompiled.sql}, key ASC`;
       queryParams.push(...orderByCompiled.params);
     }
+    if (queryParams.length > (driver.maxBoundParameters ?? this.driver.maxBoundParameters ?? 999)) {
+      sql = `SELECT key, value, metadata, row_version FROM ${collectionTableSql}`;
+      queryParams.length = 0;
+    }
     const storedRows = await driver.query(sql, queryParams);
     const parsedRows = decodeStoredSqliteRows(storedRows);
     const filteredRows = this.applyInMemoryWhere(parsedRows, options.where);