@tanstack/db-sqlite-persistence-core 0.4.3 → 0.4.5

package/dist/cjs/sqlite-core-adapter.cjs

@@ -4,7 +4,7 @@ const db = require("@tanstack/db");
 const errors = require("./errors.cjs");
 const persisted = require("./persisted.cjs");
 const sqliteValue = require("./sqlite-value.cjs");
-const REPLACEMENT_BATCH_SIZE = 100;
+const REPLACEMENT_BATCH_SIZE = 125;
 class SharedPersistenceScheduler {
   constructor() {
     this.regularQueue = [];
@@ -96,6 +96,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)),
@@ -109,7 +110,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([
@@ -117,7 +117,10 @@ const persistedTaggedValueTypes = /* @__PURE__ */ new Set([
   `date`,
   `nan`,
   `infinity`,
-  `-infinity`
+  `-infinity`,
+  `string`,
+  `Temporal.Instant`,
+  `Temporal.PlainDate`
 ]);
 const orderByObjectIds = /* @__PURE__ */ new WeakMap();
 let nextOrderByObjectId = 1;
@@ -155,6 +158,8 @@ function encodePersistedJsonValue(value) {
   if (typeof value === `bigint`) {
     return sqliteValue.serializeSQLiteBigInt(value);
   }
+  const temporal = sqliteValue.serializeSQLiteTemporal(value);
+  if (temporal) return temporal;
   if (value instanceof Date) {
     return {
       [sqliteValue.PERSISTED_TYPE_TAG]: `date`,
@@ -194,6 +199,12 @@ function encodePersistedJsonValue(value) {
         encodedRecord[key] = encodedValue;
       }
     }
+    if (typeof recordValue[sqliteValue.PERSISTED_TYPE_TAG] === `string`) {
+      encodedRecord[sqliteValue.PERSISTED_TYPE_TAG] = {
+        [sqliteValue.PERSISTED_TYPE_TAG]: `string`,
+        [sqliteValue.PERSISTED_VALUE_TAG]: recordValue[sqliteValue.PERSISTED_TYPE_TAG]
+      };
+    }
     return encodedRecord;
   }
   return value;
@@ -204,6 +215,14 @@ function decodePersistedJsonValue(value) {
   }
   if (isPersistedTaggedValue(value)) {
     switch (value[sqliteValue.PERSISTED_TYPE_TAG]) {
+      case `string`:
+        return value[sqliteValue.PERSISTED_VALUE_TAG];
+      case `Temporal.Instant`:
+      case `Temporal.PlainDate`:
+        return sqliteValue.reviveSQLiteTemporal(
+          value[sqliteValue.PERSISTED_TYPE_TAG],
+          value[sqliteValue.PERSISTED_VALUE_TAG]
+        );
       case `bigint`:
         return BigInt(value[sqliteValue.PERSISTED_VALUE_TAG]);
       case `date`: {
@@ -263,7 +282,8 @@ function toSqliteParameterValue(value) {
   if (value instanceof Date) {
     return value.toISOString();
   }
-  return serializePersistedRowValue(value);
+  const temporal = sqliteValue.serializeSQLiteTemporal(value);
+  return temporal?.order ?? serializePersistedRowValue(value);
 }
 function toSqliteLiteral(value) {
   if (value === null) {
@@ -272,6 +292,9 @@ function toSqliteLiteral(value) {
   if (typeof value === `number`) {
     return Number.isFinite(value) ? String(value) : `NULL`;
   }
+  if (value.includes(`\0`)) {
+    return `json_extract(${toSqliteLiteral(JSON.stringify(value))}, '$')`;
+  }
   return `'${value.replace(/'/g, `''`)}'`;
 }
 function toSqliteExpressionLiteral(value) {
@@ -347,6 +370,9 @@ function compareOrderByValues(left, right, compareOptions) {
   if (left instanceof Date && right instanceof Date) {
     return left.getTime() - right.getTime();
   }
+  if (sqliteValue.sqliteTemporalKind(left) && sqliteValue.sqliteTemporalKind(right)) {
+    return db.compareTemporalValues(left, right);
+  }
   const leftIsObject = typeof left === `object`;
   const rightIsObject = typeof right === `object`;
   if (leftIsObject || rightIsObject) {
@@ -381,6 +407,33 @@ function createJsonPath(path) {
   }
   return jsonPath;
 }
+const MAX_INDEXED_NUMERIC_PATH_SEGMENTS = 3;
+function hasDeepNumericPath(expression) {
+  if (expression.type === `ref`) {
+    return db.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`;
@@ -426,16 +479,23 @@ function compileRefExpressionSql(jsonPath) {
   const typePathSql = toSqliteLiteral(typePath);
   const taggedValuePathSql = toSqliteLiteral(taggedValuePath);
   const jsonPathSql = toSqliteLiteral(jsonPath);
-  return {
-    supported: true,
-    sql: `(CASE json_extract(value, ${typePathSql})
+  const typeSql = `json_extract(value, ${typePathSql})`;
+  const orderPathSql = toSqliteLiteral(`${jsonPath}.order`);
+  const sql = `(CASE ${typeSql}
       WHEN 'bigint' THEN CAST(json_extract(value, ${taggedValuePathSql}) AS NUMERIC)
       WHEN 'date' THEN json_extract(value, ${taggedValuePathSql})
+      WHEN 'string' THEN json_extract(value, ${taggedValuePathSql})
+      WHEN 'Temporal.Instant' THEN json_extract(value, ${orderPathSql})
+      WHEN 'Temporal.PlainDate' THEN json_extract(value, ${orderPathSql})
       WHEN 'nan' THEN NULL
       WHEN 'infinity' THEN NULL
       WHEN '-infinity' THEN NULL
       ELSE json_extract(value, ${jsonPathSql})
-    END)`,
+    END)`;
+  return {
+    supported: true,
+    sql,
+    identitySql: `(CASE WHEN ${typeSql} IN ('Temporal.Instant', 'Temporal.PlainDate') THEN ${typeSql} || ':' || json_extract(value, ${taggedValuePathSql}) ELSE ${sql} END)`,
     params: [],
     valueKind: `unknown`
   };
@@ -463,6 +523,11 @@ function decodeStoredSqliteRows(storedRows) {
 function stableStringify(value) {
   return serializePersistedRowValue(value);
 }
+function joinSqlDisjunction(parts) {
+  if (parts.length === 1) return parts[0];
+  const middle = Math.floor(parts.length / 2);
+  return `(${joinSqlDisjunction(parts.slice(0, middle))} OR ${joinSqlDisjunction(parts.slice(middle))})`;
+}
 function argumentCompilationContext(parentName, argumentIndex, argument, parentContext) {
   if (parentContext === `index-expression`) return `index-expression`;
   switch (parentName) {
@@ -488,30 +553,59 @@ 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` || sqliteValue.sqliteTemporalKind(value) !== void 0;
+}
+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`) {
-    const valueKind = getLiteralValueKind(expression.value);
+    if (context === `predicate` && typeof expression.value === `string` && hasUnpairedSurrogate(expression.value)) {
+      return {
+        supported: true,
+        sql: `json_extract(?, '$')`,
+        params: [JSON.stringify(expression.value)]
+      };
+    }
+    const temporal = sqliteValue.serializeSQLiteTemporal(expression.value);
+    const value = temporal?.order ?? toSqliteParameterValue(expression.value);
     return {
+      identitySql: temporal ? toSqliteLiteral(sqliteValue.sqliteTemporalIdentity(temporal)) : void 0,
       supported: true,
-      sql: context === `index-expression` ? toSqliteExpressionLiteral(expression.value) : `?`,
-      params: context === `predicate` ? [toSqliteParameterValue(expression.value)] : [],
-      valueKind
+      sql: context === `index-expression` ? toSqliteExpressionLiteral(
+        typeof expression.value === `bigint` ? expression.value : value
+      ) : `?`,
+      params: context === `predicate` ? [value] : [],
+      valueKind: getLiteralValueKind(expression.value)
     };
   }
   if (expression.type === `ref`) {
-    const jsonPath = createJsonPath(
+    const jsonPaths = createJsonPathVariants(
       db.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]);
+    const variants = jsonPaths.map(compileRefExpressionSql);
+    return {
+      supported: true,
+      identitySql: `COALESCE(${variants.map((variant) => variant.identitySql).join(`, `)})`,
+      sql: `COALESCE(${variants.map((variant) => variant.sql).join(`, `)})`,
+      params: [],
+      valueKind: `unknown`
+    };
   }
-  const compiledArgs = expression.args.map(
+  const args = expression.name === `in` ? expression.args.slice(0, 1) : expression.args;
+  const compiledArgs = args.map(
     (arg, index) => compileSqlExpression(
       arg,
       argumentCompilationContext(expression.name, index, arg, context)
@@ -548,38 +642,37 @@ function compileSqlExpression(expression, context = `predicate`) {
         lt: `<`,
         lte: `<=`
       };
+      const comparison = compileComparisonSql(
+        operatorByName[expression.name],
+        expression.args[0],
+        expression.args[1],
+        argSql[0],
+        argSql[1],
+        valueKind,
+        getCompiledValueKind(compiledArgs[0]),
+        getCompiledValueKind(compiledArgs[1])
+      );
+      const needsIdentity = expression.name === `eq` && expression.args.every(
+        (arg) => arg.type !== `val` || sqliteValue.sqliteTemporalKind(arg.value) || context === `index-expression` && typeof arg.value === `string`
+      );
       return {
         supported: true,
-        sql: compileComparisonSql(
-          operatorByName[expression.name],
-          expression.args[0],
-          expression.args[1],
-          argSql[0],
-          argSql[1],
-          valueKind,
-          getCompiledValueKind(compiledArgs[0]),
-          getCompiledValueKind(compiledArgs[1])
-        ),
-        params
-      };
-    }
-    case `and`: {
-      if (argSql.length < 2) {
-        return { supported: false, sql: ``, params: [] };
-      }
-      return {
-        supported: true,
-        sql: argSql.map((sql) => `(${sql})`).join(` AND `),
+        sql: needsIdentity ? `(${comparison} AND (${compiledArgs[0].identitySql ?? argSql[0]} = ${compiledArgs[1].identitySql ?? argSql[1]}))` : comparison,
         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
       };
     }
@@ -609,44 +702,34 @@ function compileSqlExpression(expression, context = `predicate`) {
       if (!leftSql) {
         return { supported: false, sql: ``, params: [] };
       }
-      if (context === `index-expression`) {
+      const values = listValue.map((value) => {
+        const temporal = sqliteValue.serializeSQLiteTemporal(value);
         return {
-          supported: true,
-          sql: `(${leftSql} IN (${listValue.map((value) => toSqliteExpressionLiteral(value)).join(`, `)}))`,
-          params: leftParams
+          value: typeof value === `bigint` ? sqliteValue.assertSQLiteBigIntInRange(value) : temporal?.order ?? toSqliteParameterValue(value),
+          identity: temporal ? sqliteValue.sqliteTemporalIdentity(temporal) : void 0
         };
+      });
+      let identity = ``;
+      if (listValue.some(
+        (value) => sqliteValue.sqliteTemporalKind(value) || context === `index-expression` && typeof value === `string`
+      )) {
+        const leftIdentity = compiledArgs[0]?.identitySql ?? leftSql;
+        identity = context === `index-expression` ? ` AND (${joinSqlDisjunction(values.map(({ value, identity: nativeIdentity }) => `(${leftSql} = ${toSqliteExpressionLiteral(value)} AND ${leftIdentity} = ${toSqliteExpressionLiteral(nativeIdentity ?? value)})`))})` : ` AND ((${leftSql}, ${leftIdentity}) IN (VALUES ${[...new Set(values.map(({ value, identity: nativeIdentity }) => `(${toSqliteExpressionLiteral(value)}, ${toSqliteExpressionLiteral(nativeIdentity ?? value)})`))].join(`, `)}))`;
       }
-      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);
-        }
+      if (context === `index-expression`) {
         return {
           supported: true,
-          sql: `(${chunkClauses.join(` OR `)})`,
-          params: batchedParams
+          sql: `(${leftSql} IN (${values.map(({ value }) => toSqliteExpressionLiteral(value)).join(`, `)})${identity})`,
+          params: leftParams
         };
       }
-      const listParams = [];
-      const listValueSql = listValue.map((value) => {
-        listParams.push(toSqliteParameterValue(value));
-        return typeof value === `bigint` ? `CAST(? AS NUMERIC)` : `?`;
-      });
+      const jsonList = `[${values.map(
+        ({ value }) => typeof value === `bigint` ? sqliteValue.assertSQLiteBigIntInRange(value).toString() : JSON.stringify(value)
+      ).join(`,`)}]`;
       return {
         supported: true,
-        sql: `(${leftSql} IN (${listValueSql.join(`, `)}))`,
-        params: [...leftParams, ...listParams]
+        sql: `(${leftSql} IN (SELECT value FROM json_each(?))${identity})`,
+        params: [...leftParams, jsonList]
       };
     }
     case `like`:
@@ -673,7 +756,12 @@ function compileSqlExpression(expression, context = `predicate`) {
     case `concat`:
       return { supported: true, sql: `(${argSql.join(` || `)})`, params };
     case `coalesce`:
-      return { supported: true, sql: `COALESCE(${argSql.join(`, `)})`, params };
+      return {
+        supported: true,
+        sql: `COALESCE(${argSql.join(`, `)})`,
+        identitySql: `COALESCE(${compiledArgs.map((arg) => arg.identitySql ?? arg.sql).join(`, `)})`,
+        params
+      };
     case `add`:
       return { supported: true, sql: `(${argSql[0]} + ${argSql[1]})`, params };
     case `subtract`:
@@ -710,6 +798,131 @@ function compileSqlExpression(expression, context = `predicate`) {
       };
   }
 }
+function nativeComparisonRef(expression) {
+  if (expression.type !== `func` || expression.args.length !== 2)
+    return void 0;
+  const [left, right] = expression.args;
+  if (expression.name === `in`) {
+    return left?.type === `ref` && right?.type === `val` && Array.isArray(right.value) && right.value.length > 0 && right.value.every((value) => sqliteValue.sqliteTemporalKind(value)) ? left : void 0;
+  }
+  if (![`eq`, `gt`, `gte`, `lt`, `lte`].includes(expression.name))
+    return void 0;
+  if (left?.type === `ref` && right?.type === `val` && sqliteValue.sqliteTemporalKind(right.value))
+    return left;
+  if (right?.type === `ref` && left?.type === `val` && sqliteValue.sqliteTemporalKind(left.value))
+    return right;
+  return void 0;
+}
+function compileNativeRefGuard(ref) {
+  const paths = createJsonPathVariants(
+    db.IR.getPropRefPropertyPath(ref).map(String)
+  );
+  const kinds = paths.map(
+    (path) => `json_extract(value, ${toSqliteLiteral(`${path}.${sqliteValue.PERSISTED_TYPE_TAG}`)})`
+  );
+  const kind = kinds.length === 1 ? kinds[0] : `COALESCE(${kinds.join(`, `)})`;
+  return `${kind} IN ('Temporal.Instant', 'Temporal.PlainDate')`;
+}
+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.name === `not` && expression.args.length === 1 && left && nativeComparisonRef(left)) {
+    return { ...compiled, sql: `COALESCE(${compiled.sql}, 1)` };
+  }
+  if (expression.args.length === 2) {
+    const nativeRef = nativeComparisonRef(expression);
+    if (nativeRef) {
+      if (expression.name === `eq` || expression.name === `in`) return compiled;
+      const fieldSql = compileSqlExpression(nativeRef, `index-expression`).sql;
+      return { ...compiled, sql: `(${compiled.sql} OR ${fieldSql} IS NULL)` };
+    }
+    if (expression.name === `eq` && left?.type === `ref` && right?.type === `ref`) {
+      return {
+        ...compiled,
+        sql: `(CASE WHEN ${compileNativeRefGuard(left)} AND ${compileNativeRefGuard(right)} THEN ${compiled.sql} ELSE 1 END)`
+      };
+    }
+    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 {
@@ -799,6 +1012,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}`;
@@ -1118,158 +1348,172 @@ class SQLiteCorePersistenceAdapter {
         await transactionDriver.run(`DELETE FROM ${collectionTableSql}`);
         await transactionDriver.run(`DELETE FROM ${tombstoneTableSql}`);
       }
-      const replacementKeys = replacesPersistedBaseline ? tx.mutations.map(
-        (mutation) => persisted.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(
-            persisted.encodePersistedStorageKey(mutation.key),
-            mutation.type === `delete` ? void 0 : mutation.value
-          );
+      const rowMutations = /* @__PURE__ */ new Map();
+      for (const mutation of tx.mutations) {
+        const key = persisted.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);
+        }
+        if (mutation.type === `delete`) {
+          rowMutations.set(key, mutation);
+          continue;
         }
-        for (let start = 0; start < tx.mutations.length; start += this.replacementBatchSize) {
-          const mutations = tx.mutations.slice(
-            start,
-            start + this.replacementBatchSize
+        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) => persisted.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) => persisted.encodePersistedStorageKey(mutation.key)
+        );
+        const deleteKeys = deletes.map(
+          (mutation) => persisted.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 = persisted.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) => persisted.encodePersistedStorageKey(mutation.key),
+          true
+        ),
+        this.replacementBatchSize
+      )) {
+        const keys = batch.map(
+          (mutation) => persisted.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 = persisted.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)
+            ])
           );
         }
       }
@@ -1682,18 +1926,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);