@rocicorp/zero 0.26.0-canary.8 → 0.26.0

package/out/zero-cache/src/services/view-syncer/cvr-store.js

@@ -13,6 +13,7 @@ import { ClientNotFound, Rehome, SchemaVersionNotSupported, Internal } from "../
 import { ZeroCache } from "../../../../zero-protocol/src/error-origin-enum.js";
 import { clampTTL, DEFAULT_TTL_MS } from "../../../../zql/src/query/ttl.js";
 import { READONLY, READ_COMMITTED } from "../../db/mode-enum.js";
+import { runTx } from "../../db/run-transaction.js";
 import { TransactionPool } from "../../db/transaction-pool.js";
 import { recordRowsSynced } from "../../server/anonymous-otel-start.js";
 import { ProtocolErrorWithLevel } from "../../types/error-with-level.js";
@@ -24,6 +25,16 @@ import "../../../../shared/src/bigint-json.js";
 import { EMPTY_CVR_VERSION, versionFromString, versionString, queryRecordToQueryRow, cmpVersions } from "./schema/types.js";
 import { ttlClockFromNumber, ttlClockAsNumber } from "./ttl-clock.js";
 let flushCounter = 0;
+function convertTTLValues(inactivatedAt, ttl) {
+  return {
+    ttlInterval: ttl < 0 ? null : ttl / 1e3,
+    // INTERVAL needs seconds
+    ttlMs: ttl < 0 ? null : ttl,
+    // New column stores ms directly
+    inactivatedAtTimestamp: inactivatedAt === void 0 ? null : ttlClockFromNumber(ttlClockAsNumber(inactivatedAt) / 1e3),
+    inactivatedAtMs: inactivatedAt ?? null
+  };
+}
 const tracer = trace.getTracer("cvr-store", version);
 function asQuery(row) {
   const maybeVersion = (s) => s === null ? void 0 : versionFromString(s);
@@ -69,6 +80,10 @@ class CVRStore {
   #failService;
   #db;
   #writes = /* @__PURE__ */ new Set();
+  // Stored separately so repeated putInstance() calls (e.g. setClientSchema,
+  // setProfileID, and the final call in #flush) replace each other rather than
+  // accumulating as independent statements in #writes.
+  #pendingInstanceWrite = void 0;
   #pendingRowRecordUpdates = new CustomKeyMap(
     rowIDString
   );
@@ -77,6 +92,9 @@ class CVRStore {
   #loadAttemptIntervalMs;
   #maxLoadAttempts;
   #rowCount = 0;
+  #pendingQueryUpdates = /* @__PURE__ */ new Map();
+  #pendingDesireUpdates = /* @__PURE__ */ new Map();
+  #pendingQueryPartialUpdates = /* @__PURE__ */ new Map();
   constructor(lc, cvrDb, shard, taskID, cvrID, failService, loadAttemptIntervalMs = LOAD_ATTEMPT_INTERVAL_MS, maxLoadAttempts = MAX_LOAD_ATTEMPTS, deferredRowFlushThreshold = 100, setTimeoutFn = setTimeout) {
     this.#failService = failService;
     this.#db = cvrDb;
@@ -98,6 +116,9 @@ class CVRStore {
   #cvr(table) {
     return this.#db(`${this.#schema}.${table}`);
   }
+  #updateQueryFields(queryHash, fields) {
+    this.#pendingQueryPartialUpdates.set(queryHash, fields);
+  }
   load(lc, lastConnectTime) {
     return startAsyncSpan(tracer, "cvr.load", async () => {
       let err;
@@ -134,10 +155,12 @@ class CVRStore {
       clientSchema: null,
       profileID: null
     };
-    const [instance, clientsRows, queryRows, desiresRows] = await this.#db.begin(READONLY, (tx) => {
-      lc.debug?.(`CVR tx started after ${Date.now() - start} ms`);
-      return [
-        tx`SELECT cvr."version",
+    const [instance, clientsRows, queryRows, desiresRows] = await runTx(
+      this.#db,
+      (tx) => {
+        lc.debug?.(`CVR tx started after ${Date.now() - start} ms`);
+        return [
+          tx`SELECT cvr."version",
                  "lastActive",
                  "ttlClock",
                  "replicaVersion",
@@ -151,13 +174,13 @@ class CVRStore {
             LEFT JOIN ${this.#cvr("rowsVersion")} AS rows
             ON cvr."clientGroupID" = rows."clientGroupID"
             WHERE cvr."clientGroupID" = ${id}`,
-        tx`SELECT "clientID" FROM ${this.#cvr(
-          "clients"
-        )}
+          tx`SELECT "clientID" FROM ${this.#cvr(
+            "clients"
+          )}
            WHERE "clientGroupID" = ${id}`,
-        tx`SELECT * FROM ${this.#cvr("queries")}
+          tx`SELECT * FROM ${this.#cvr("queries")}
           WHERE "clientGroupID" = ${id} AND deleted IS DISTINCT FROM true`,
-        tx`SELECT
+          tx`SELECT
           "clientGroupID",
           "clientID",
           "queryHash",
@@ -167,8 +190,10 @@ class CVRStore {
           "inactivatedAtMs" AS "inactivatedAt"
           FROM ${this.#cvr("desires")}
           WHERE "clientGroupID" = ${id}`
-      ];
-    });
+        ];
+      },
+      { mode: READONLY }
+    );
     lc.debug?.(
       `CVR tx completed after ${Date.now() - start} ms (${clientsRows.length} clients, ${queryRows.length} queries, ${desiresRows.length} desires)`
     );
@@ -332,89 +357,50 @@ class CVRStore {
     profileID,
     ttlClock
   }) {
-    this.#writes.add({
-      stats: { instances: 1 },
-      write: (tx, lastConnectTime) => {
-        const change = {
-          clientGroupID: this.#id,
-          version: versionString(version2),
-          lastActive,
-          ttlClock,
-          replicaVersion,
-          owner: this.#taskID,
-          grantedAt: lastConnectTime,
-          clientSchema,
-          profileID
-        };
-        return tx`
+    this.#pendingInstanceWrite = (tx, lastConnectTime) => {
+      const change = {
+        clientGroupID: this.#id,
+        version: versionString(version2),
+        lastActive,
+        ttlClock,
+        replicaVersion,
+        owner: this.#taskID,
+        grantedAt: lastConnectTime,
+        clientSchema,
+        profileID
+      };
+      return tx`
         INSERT INTO ${this.#cvr("instances")} ${tx(change)} 
           ON CONFLICT ("clientGroupID") DO UPDATE SET ${tx(change)}`;
-      }
-    });
+    };
   }
   markQueryAsDeleted(version2, queryPatch) {
-    this.#writes.add({
-      stats: { queries: 1 },
-      write: (tx) => tx`UPDATE ${this.#cvr("queries")} SET ${tx({
-        patchVersion: versionString(version2),
-        deleted: true,
-        transformationHash: null,
-        transformationVersion: null
-      })}
-      WHERE "clientGroupID" = ${this.#id} AND "queryHash" = ${queryPatch.id}`
+    this.#updateQueryFields(queryPatch.id, {
+      patchVersion: versionString(version2),
+      deleted: true,
+      transformationHash: null,
+      transformationVersion: null
     });
   }
   putQuery(query) {
     const change = queryRecordToQueryRow(this.#id, query);
-    this.#writes.add({
-      stats: { queries: 1 },
-      write: (tx) => tx`INSERT INTO ${this.#cvr("queries")} (
-        "clientGroupID",
-        "queryHash",
-        "clientAST",
-        "queryName",
-        "queryArgs",
-        "patchVersion",
-        "transformationHash",
-        "transformationVersion",
-        "internal",
-        "deleted"
-      ) VALUES (
-        ${change.clientGroupID},
-        ${change.queryHash},
-        ${change.clientAST},
-        ${change.queryName},
-        ${change.queryArgs === void 0 ? null : JSON.stringify(change.queryArgs)}::text::json,
-        ${change.patchVersion},
-        ${change.transformationHash ?? null},
-        ${change.transformationVersion ?? null},
-        ${change.internal},
-        ${change.deleted ?? false}
-      )
-      ON CONFLICT ("clientGroupID", "queryHash")
-      DO UPDATE SET 
-        "clientAST" = ${change.clientAST},
-        "queryName" = ${change.queryName},
-        "queryArgs" = ${change.queryArgs === void 0 ? null : JSON.stringify(change.queryArgs)}::text::json,
-        "patchVersion" = ${change.patchVersion},
-        "transformationHash" = ${change.transformationHash ?? null},
-        "transformationVersion" = ${change.transformationVersion ?? null},
-        "internal" = ${change.internal},
-        "deleted" = ${change.deleted ?? false}`
-    });
+    const c = {
+      ...change,
+      // Pre-stringify queryArgs to handle postgres.js boolean array bug
+      queryArgs: change.queryArgs !== null ? JSON.stringify(change.queryArgs) : null,
+      transformationHash: change.transformationHash ?? null,
+      transformationVersion: change.transformationVersion ?? null,
+      deleted: change.deleted ?? false
+    };
+    this.#pendingQueryUpdates.set(query.id, c);
   }
   updateQuery(query) {
     const maybeVersionString = (v2) => v2 ? versionString(v2) : null;
-    const change = {
+    this.#updateQueryFields(query.id, {
       patchVersion: query.type === "internal" ? null : maybeVersionString(query.patchVersion),
       transformationHash: query.transformationHash ?? null,
       transformationVersion: maybeVersionString(query.transformationVersion),
       deleted: false
-    };
-    this.#writes.add({
-      stats: { queries: 1 },
-      write: (tx) => tx`UPDATE ${this.#cvr("queries")} SET ${tx(change)}
-      WHERE "clientGroupID" = ${this.#id} AND "queryHash" = ${query.id}`
     });
   }
   insertClient(client) {
@@ -436,38 +422,18 @@ class CVRStore {
     });
   }
   putDesiredQuery(newVersion, query, client, deleted, inactivatedAt, ttl) {
+    const { ttlMs, inactivatedAtMs } = convertTTLValues(inactivatedAt, ttl);
     const change = {
       clientGroupID: this.#id,
       clientID: client.id,
       deleted,
+      inactivatedAt: inactivatedAtMs,
       patchVersion: versionString(newVersion),
-      queryHash: query.id
+      queryHash: query.id,
+      ttl: ttlMs
     };
-    const inactivatedAtTimestamp = inactivatedAt === void 0 ? null : ttlClockFromNumber(ttlClockAsNumber(inactivatedAt) / 1e3);
-    const inactivatedAtMs = inactivatedAt ?? null;
-    const ttlInterval = ttl < 0 ? null : ttl / 1e3;
-    const ttlMs = ttl < 0 ? null : ttl;
-    this.#writes.add({
-      stats: { desires: 1 },
-      write: (tx) => tx`
-      INSERT INTO ${this.#cvr("desires")} (
-        "clientGroupID", "clientID", "queryHash", "patchVersion", "deleted",
-        "ttl", "ttlMs", "inactivatedAt", "inactivatedAtMs"
-      ) VALUES (
-        ${change.clientGroupID}, ${change.clientID}, ${change.queryHash}, 
-        ${change.patchVersion}, ${change.deleted}, ${ttlInterval}, ${ttlMs},
-        ${inactivatedAtTimestamp}, ${inactivatedAtMs}
-      )
-      ON CONFLICT ("clientGroupID", "clientID", "queryHash")
-      DO UPDATE SET
-        "patchVersion" = ${change.patchVersion},
-        "deleted" = ${change.deleted},
-        "ttl" = ${ttlInterval},
-        "ttlMs" = ${ttlMs},
-        "inactivatedAt" = ${inactivatedAtTimestamp},
-        "inactivatedAtMs" = ${inactivatedAtMs}
-      `
-    });
+    const key = `${client.id}:${query.id}`;
+    this.#pendingDesireUpdates.set(key, change);
   }
   catchupRowPatches(lc, afterVersion, upToCVR, current, excludeQueryHashes = []) {
     return this.#rowCache.catchupRowPatches(
@@ -526,13 +492,200 @@ class CVRStore {
       reader.setDone();
     }
   }
+  #flushQueries(tx, lc) {
+    const partialOnly = /* @__PURE__ */ new Map();
+    for (const [queryHash, partial] of this.#pendingQueryPartialUpdates) {
+      const existing = this.#pendingQueryUpdates.get(queryHash);
+      if (existing) {
+        Object.assign(existing, partial);
+      } else {
+        partialOnly.set(queryHash, partial);
+      }
+    }
+    const queries = [];
+    if (this.#pendingQueryUpdates.size > 0) {
+      const rows = [...this.#pendingQueryUpdates.values()];
+      lc.debug?.(`Batch flushing ${rows.length} full query updates`);
+      queries.push(tx`
+        INSERT INTO ${this.#cvr("queries")} (
+          "clientGroupID",
+          "queryHash",
+          "clientAST",
+          "queryName",
+          "queryArgs",
+          "patchVersion",
+          "transformationHash",
+          "transformationVersion",
+          "internal",
+          "deleted"
+        )
+        SELECT
+          "clientGroupID",
+          "queryHash",
+          "clientAST",
+          "queryName",
+          CASE
+            WHEN "queryArgs" IS NULL THEN NULL
+            ELSE "queryArgs"::json
+          END,
+          "patchVersion",
+          "transformationHash",
+          "transformationVersion",
+          "internal",
+          "deleted"
+        FROM json_to_recordset(${rows}) AS x(
+          "clientGroupID" TEXT,
+          "queryHash" TEXT,
+          "clientAST" JSONB,
+          "queryName" TEXT,
+          "queryArgs" TEXT,
+          "patchVersion" TEXT,
+          "transformationHash" TEXT,
+          "transformationVersion" TEXT,
+          "internal" BOOLEAN,
+          "deleted" BOOLEAN
+        )
+        ON CONFLICT ("clientGroupID", "queryHash") DO UPDATE SET
+          "clientAST" = excluded."clientAST",
+          "queryName" = excluded."queryName",
+          "queryArgs" = CASE 
+            WHEN excluded."queryArgs" IS NULL THEN NULL
+            ELSE excluded."queryArgs"::json
+          END,
+          "patchVersion" = excluded."patchVersion",
+          "transformationHash" = excluded."transformationHash",
+          "transformationVersion" = excluded."transformationVersion",
+          "internal" = excluded."internal",
+          "deleted" = excluded."deleted"
+      `);
+    }
+    if (partialOnly.size > 0) {
+      lc.debug?.(`Batch flushing ${partialOnly.size} partial query updates`);
+      const rows = Array.from(
+        partialOnly.entries(),
+        ([queryHash, partial]) => ({
+          clientGroupID: this.#id,
+          queryHash,
+          patchVersionSet: partial.patchVersion !== void 0,
+          patchVersion: partial.patchVersion ?? null,
+          deletedSet: partial.deleted !== void 0,
+          deleted: partial.deleted ?? null,
+          transformationHashSet: partial.transformationHash !== void 0,
+          transformationHash: partial.transformationHash ?? null,
+          transformationVersionSet: partial.transformationVersion !== void 0,
+          transformationVersion: partial.transformationVersion ?? null
+        })
+      );
+      queries.push(tx`
+        UPDATE ${this.#cvr("queries")} AS q
+        SET
+          "patchVersion" = CASE
+            WHEN u."patchVersionSet" THEN u."patchVersion"
+            ELSE q."patchVersion"
+          END,
+          "deleted" = CASE
+            WHEN u."deletedSet" THEN u."deleted"
+            ELSE q."deleted"
+          END,
+          "transformationHash" = CASE
+            WHEN u."transformationHashSet" THEN u."transformationHash"
+            ELSE q."transformationHash"
+          END,
+          "transformationVersion" = CASE
+            WHEN u."transformationVersionSet" THEN u."transformationVersion"
+            ELSE q."transformationVersion"
+          END
+        FROM json_to_recordset(${rows}) AS u(
+          "clientGroupID" TEXT,
+          "queryHash" TEXT,
+          "patchVersionSet" BOOLEAN,
+          "patchVersion" TEXT,
+          "deletedSet" BOOLEAN,
+          "deleted" BOOLEAN,
+          "transformationHashSet" BOOLEAN,
+          "transformationHash" TEXT,
+          "transformationVersionSet" BOOLEAN,
+          "transformationVersion" TEXT
+        )
+        WHERE q."clientGroupID" = u."clientGroupID"
+          AND q."queryHash" = u."queryHash"
+      `);
+    }
+    return queries;
+  }
+  #flushDesires(tx, lc) {
+    if (this.#pendingDesireUpdates.size === 0) {
+      return null;
+    }
+    const rows = Array.from(this.#pendingDesireUpdates.values(), (row) => {
+      const { ttlInterval, ttlMs, inactivatedAtTimestamp, inactivatedAtMs } = convertTTLValues(row.inactivatedAt ?? void 0, row.ttl ?? -1);
+      return {
+        clientGroupID: row.clientGroupID,
+        clientID: row.clientID,
+        queryHash: row.queryHash,
+        patchVersion: row.patchVersion,
+        deleted: row.deleted,
+        ttl: ttlInterval,
+        ttlMs,
+        inactivatedAt: inactivatedAtTimestamp,
+        inactivatedAtMs
+      };
+    });
+    lc.debug?.(`Batch flushing ${rows.length} desire updates`);
+    return tx`
+      INSERT INTO ${this.#cvr("desires")} (
+        "clientGroupID",
+        "clientID",
+        "queryHash",
+        "patchVersion",
+        "deleted",
+        "ttl",
+        "ttlMs",
+        "inactivatedAt",
+        "inactivatedAtMs"
+      )
+      SELECT
+        "clientGroupID",
+        "clientID",
+        "queryHash",
+        "patchVersion",
+        "deleted",
+        "ttl",
+        "ttlMs",
+        CASE
+          WHEN "inactivatedAt" IS NULL THEN NULL
+          -- Divide by 1000 because postgres.js serializeTimestamp treats numbers as ms
+          -- and to_timestamp expects seconds. This matches non-batched behavior.
+          ELSE to_timestamp("inactivatedAt" / 1000.0)
+        END,
+        "inactivatedAtMs"
+      FROM json_to_recordset(${rows}) AS x(
+        "clientGroupID" TEXT,
+        "clientID" TEXT,
+        "queryHash" TEXT,
+        "patchVersion" TEXT,
+        "deleted" BOOLEAN,
+        "ttl" INTERVAL,
+        "ttlMs" DOUBLE PRECISION,
+        "inactivatedAt" DOUBLE PRECISION,
+        "inactivatedAtMs" DOUBLE PRECISION
+      )
+      ON CONFLICT ("clientGroupID", "clientID", "queryHash") DO UPDATE SET
+        "patchVersion" = excluded."patchVersion",
+        "deleted" = excluded."deleted",
+        "ttl" = excluded."ttl",
+        "ttlMs" = excluded."ttlMs",
+        "inactivatedAt" = excluded."inactivatedAt",
+        "inactivatedAtMs" = excluded."inactivatedAtMs"
+      `;
+  }
   async #checkVersionAndOwnership(lc, tx, expectedCurrentVersion, lastConnectTime) {
     const start = Date.now();
     lc.debug?.("checking cvr version and ownership");
-    const expected = versionString(expectedCurrentVersion);
     const result = await tx`SELECT "version", "owner", "grantedAt" FROM ${this.#cvr("instances")}
         WHERE "clientGroupID" = ${this.#id}
-        FOR UPDATE`.execute();
+        FOR UPDATE`;
+    const expected = versionString(expectedCurrentVersion);
     const { version: version2, owner, grantedAt } = result.length > 0 ? result[0] : {
       version: EMPTY_CVR_VERSION.stateVersion,
       owner: null,
@@ -578,65 +731,82 @@ class CVRStore {
         }
       }
     }
-    if (this.#pendingRowRecordUpdates.size === 0 && this.#writes.size === 0) {
+    if (this.#pendingRowRecordUpdates.size === 0 && this.#writes.size === 0 && this.#pendingInstanceWrite === void 0 && this.#pendingQueryUpdates.size === 0 && this.#pendingQueryPartialUpdates.size === 0 && this.#pendingDesireUpdates.size === 0) {
       return null;
     }
     this.putInstance(cvr);
     const start = Date.now();
     lc.debug?.("flush tx beginning");
-    const rowsFlushed = await this.#db.begin(READ_COMMITTED, async (tx) => {
-      lc.debug?.(`flush tx begun after ${Date.now() - start} ms`);
-      const pipelined = [
-        // #checkVersionAndOwnership() executes a `SELECT ... FOR UPDATE`
-        // query to acquire a row-level lock so that version-updating
-        // transactions are effectively serialized per cvr.instance.
-        //
-        // Note that `rowsVersion` updates, on the other hand, are not subject
-        // to this lock and can thus commit / be-committed independently of
-        // cvr.instances.
-        this.#checkVersionAndOwnership(
+    const results = await runTx(
+      this.#db,
+      async (tx) => {
+        lc.debug?.(`flush tx begun after ${Date.now() - start} ms`);
+        await this.#checkVersionAndOwnership(
           lc,
           tx,
           expectedCurrentVersion,
           lastConnectTime
-        )
-      ];
-      let i = 0;
-      for (const write of this.#writes) {
-        stats.instances += write.stats.instances ?? 0;
-        stats.queries += write.stats.queries ?? 0;
-        stats.desires += write.stats.desires ?? 0;
-        stats.clients += write.stats.clients ?? 0;
-        stats.rows += write.stats.rows ?? 0;
-        const writeIndex = i++;
-        const writeStart = Date.now();
-        pipelined.push(
-          write.write(tx, lastConnectTime).execute().then(() => {
-            lc.debug?.(
-              `write ${writeIndex}/${this.#writes.size} completed in ${Date.now() - writeStart} ms`
-            );
-          })
         );
-        stats.statements++;
-      }
-      const rowUpdates = this.#rowCache.executeRowUpdates(
-        tx,
-        cvr.version,
-        this.#pendingRowRecordUpdates,
-        "allow-defer",
-        lc
-      );
-      pipelined.push(...rowUpdates);
-      stats.statements += rowUpdates.length;
-      await Promise.all(pipelined);
-      lc.debug?.(`flush tx returning after ${Date.now() - start} ms`);
-      if (rowUpdates.length === 0) {
-        stats.rowsDeferred = this.#pendingRowRecordUpdates.size;
-        return false;
-      }
+        const writeQueries = [];
+        if (this.#pendingInstanceWrite) {
+          writeQueries.push(this.#pendingInstanceWrite(tx, lastConnectTime));
+          stats.instances++;
+          stats.statements++;
+        }
+        for (const write of this.#writes) {
+          stats.clients += write.stats.clients ?? 0;
+          stats.rows += write.stats.rows ?? 0;
+          writeQueries.push(write.write(tx, lastConnectTime));
+          stats.statements++;
+        }
+        const hasQueryUpdates = this.#pendingQueryUpdates.size > 0 || this.#pendingQueryPartialUpdates.size > 0;
+        const desireFlush = this.#flushDesires(tx, lc);
+        let queryFlushes = [];
+        if (hasQueryUpdates) {
+          queryFlushes = this.#flushQueries(tx, lc);
+          const partialOnlyCount = Array.from(
+            this.#pendingQueryPartialUpdates.keys()
+          ).filter((key) => !this.#pendingQueryUpdates.has(key)).length;
+          stats.queries = this.#pendingQueryUpdates.size + partialOnlyCount;
+          stats.statements += (this.#pendingQueryUpdates.size > 0 ? 1 : 0) + (partialOnlyCount > 0 ? 1 : 0);
+          if (desireFlush) {
+            stats.desires = this.#pendingDesireUpdates.size;
+            stats.statements++;
+          }
+        } else if (desireFlush) {
+          stats.desires = this.#pendingDesireUpdates.size;
+          stats.statements++;
+        }
+        const rowUpdates = this.#rowCache.executeRowUpdates(
+          tx,
+          cvr.version,
+          this.#pendingRowRecordUpdates,
+          "allow-defer",
+          lc
+        );
+        stats.statements += rowUpdates.length;
+        const pipelined = [
+          ...writeQueries,
+          ...queryFlushes,
+          ...desireFlush ? [desireFlush] : [],
+          ...rowUpdates
+        ];
+        lc.debug?.(`returning ${pipelined.length} queries for pipelining`);
+        return Promise.all(pipelined);
+      },
+      { mode: READ_COMMITTED }
+    );
+    lc.debug?.(`flush tx completed after ${Date.now() - start} ms`);
+    const baseQueries = (this.#pendingInstanceWrite ? 1 : 0) + this.#writes.size + (this.#pendingQueryUpdates.size > 0 ? 1 : 0) + (Array.from(this.#pendingQueryPartialUpdates.keys()).filter(
+      (key) => !this.#pendingQueryUpdates.has(key)
+    ).length > 0 ? 1 : 0) + (this.#pendingDesireUpdates.size > 0 ? 1 : 0);
+    const rowUpdateCount = results.length - baseQueries;
+    const rowsFlushed = rowUpdateCount > 0;
+    if (!rowsFlushed) {
+      stats.rowsDeferred = this.#pendingRowRecordUpdates.size;
+    } else {
       stats.rows += this.#pendingRowRecordUpdates.size;
-      return true;
-    });
+    }
     this.#rowCount = await this.#rowCache.apply(
       this.#pendingRowRecordUpdates,
       cvr.version,
@@ -671,8 +841,12 @@ class CVRStore {
       throw e;
     } finally {
       this.#writes.clear();
+      this.#pendingInstanceWrite = void 0;
       this.#pendingRowRecordUpdates.clear();
       this.#forceUpdates.clear();
+      this.#pendingQueryUpdates.clear();
+      this.#pendingDesireUpdates.clear();
+      this.#pendingQueryPartialUpdates.clear();
     }
   }
   hasPendingUpdates() {