@minnowdb/core 0.7.10 → 0.9.0

package/dist/engine/live.js

@@ -1,3 +1,8 @@
+import { createLiveQueryPatch } from "./live-patch.js";
+import { acceptLiveExecution } from "./live-accept.js";
+import { copyQueryResult, queryResultRetainedBytes, sameQueryRow } from "./query-cache.js";
+import { encodeQueryIdentity } from "./query-identity.js";
+import { OpfsCoordinationError } from "../storage/types.js";
 import { LiveQueryLimitError } from "./errors.js";
 const DEFAULT_LIVE_QUERY_MAX_GROUPS = 256;
 const DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS = 1024;
@@ -6,12 +11,6 @@ const MAX_LIVE_QUERY_SUBSCRIPTIONS = 16384;
 const MAX_LIVE_QUERY_SETS_PER_DATABASE = 256;
 const LIVE_QUERY_EXECUTION_CONCURRENCY = 8;
 import { LiveQueryLimitError as LiveQueryLimitError2 } from "./errors.js";
-function sameQueryValue(left, right) {
-  if (left instanceof Date || right instanceof Date) {
-    return left instanceof Date && right instanceof Date && Object.is(dateMilliseconds(left), dateMilliseconds(right));
-  }
-  return Object.is(left, right);
-}
 function sameResult(left, right) {
   if (left.columns.length !== right.columns.length || left.rows.length !== right.rows.length) {
     return false;
@@ -29,75 +28,11 @@ function sameResult(left, right) {
     const rightRow = right.rows[rowIndex];
     if (leftRow === void 0 || rightRow === void 0)
       return false;
-    if (leftRow === rightRow)
-      continue;
-    for (const column of columns) {
-      if (!sameQueryValue(leftRow[column] ?? null, rightRow[column] ?? null))
-        return false;
-    }
+    if (!sameQueryRow(leftRow, rightRow, columns))
+      return false;
   }
   return true;
 }
-function cloneRow(row, columns) {
-  const cloned = {};
-  for (const column of columns) {
-    const value = row[column] ?? null;
-    const copy = value instanceof Date ? copyDate(value) : value;
-    if (column === "__proto__") {
-      Object.defineProperty(cloned, column, {
-        value: copy,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else
-      cloned[column] = copy;
-  }
-  return cloned;
-}
-function cloneResult(result) {
-  const columns = [...result.columns];
-  return {
-    columns,
-    columnDomains: structuredClone(result.columnDomains),
-    rows: result.rows.map((row) => cloneRow(row, columns))
-  };
-}
-function encodeQueryIdentity(value, ancestors = /* @__PURE__ */ new Set()) {
-  if (value === null)
-    return "z";
-  if (typeof value === "undefined")
-    return "u";
-  if (typeof value === "boolean")
-    return value ? "b1" : "b0";
-  if (typeof value === "number") {
-    if (Number.isNaN(value))
-      return "nNaN;";
-    if (Object.is(value, -0))
-      return "n-0;";
-    return `n${String(value)};`;
-  }
-  if (typeof value === "string")
-    return `s${String(value.length)}:${value}`;
-  if (value instanceof Date)
-    return `d${String(dateMilliseconds(value))};`;
-  if (typeof value !== "object") {
-    throw new TypeError(`Unsupported live-query identity value: ${typeof value}`);
-  }
-  if (ancestors.has(value))
-    throw new TypeError("Live-query identity contains a cycle");
-  ancestors.add(value);
-  let encoded;
-  if (Array.isArray(value)) {
-    encoded = `a${String(value.length)}[${value.map((item) => encodeQueryIdentity(item, ancestors)).join("")}]`;
-  } else {
-    const record = value;
-    const keys = Object.keys(record).sort();
-    encoded = `o${String(keys.length)}{${keys.map((key) => `${encodeQueryIdentity(key, ancestors)}${encodeQueryIdentity(record[key], ancestors)}`).join("")}}`;
-  }
-  ancestors.delete(value);
-  return encoded;
-}
 function queryKey(query) {
   return encodeQueryIdentity(typeof query === "string" ? ["sql", query] : query.kind === "sql-query" ? ["sql-query", query.sql, query.params] : ["typed-query", query.plan]);
 }
@@ -134,13 +69,19 @@ function groupExecutes(group) {
   }
   return false;
 }
-function groupMemoizes(group) {
+function groupMemoizes(group, changed = true) {
   for (const subscriber of group.subscribers) {
-    if (!subscriber.closed && subscriber.kind === "observer")
+    if (!subscriber.closed && subscriber.kind === "observer" && (changed || subscriber.options.suppressUnchanged !== true))
       return true;
   }
   return false;
 }
+function callLiveCallback(callback) {
+  try {
+    callback?.();
+  } catch {
+  }
+}
 class LiveQuerySet {
   #host;
   #channel;
@@ -153,6 +94,7 @@ class LiveQuerySet {
   #lagging = /* @__PURE__ */ new Set();
   #maxGroups;
   #maxSubscriptions;
+  #maxRetainedBytes;
   #sharedResults;
   #incremental;
   #stats = {
@@ -167,6 +109,7 @@ class LiveQuerySet {
     maintained: 0,
     groupsVisited: 0,
     retainedRows: 0,
+    retainedBytes: 0,
     sharedExecutions: 0,
     lastSweepMs: 0
   };
@@ -176,9 +119,12 @@ class LiveQuerySet {
   #executionWaiters = [];
   #sweepChain = Promise.resolve();
   #sweepQueued = false;
+  #retryTimer;
+  #retryDelayMs = 100;
   #pollTimer;
   #closed = false;
   #subscriptionCount = 0;
+  #retainedBytes = 0;
   #ownsChannel;
   #onClosed;
   constructor(host, options = {}) {
@@ -187,6 +133,9 @@ class LiveQuerySet {
     }
     this.#maxGroups = boundedLiveLimit(options.maxGroups ?? DEFAULT_LIVE_QUERY_MAX_GROUPS, MAX_LIVE_QUERY_GROUPS, "group");
     this.#maxSubscriptions = boundedLiveLimit(options.maxSubscriptions ?? DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS, MAX_LIVE_QUERY_SUBSCRIPTIONS, "subscription");
+    this.#maxRetainedBytes = options.maxRetainedBytes ?? 64 * 1024 * 1024;
+    if (!Number.isSafeInteger(this.#maxRetainedBytes) || this.#maxRetainedBytes < 0)
+      throw new RangeError("Live query retained byte limit must be a non-negative safe integer");
     this.#sharedResults = options.sharedResults === true;
     this.#incremental = options.incremental !== false;
     this.#host = host;
@@ -212,7 +161,7 @@ class LiveQuerySet {
     let retainedRows = 0;
     for (const group of this.#groups.values())
       retainedRows += group.result?.rows.length ?? 0;
-    return { ...this.#stats, retainedRows };
+    return { ...this.#stats, retainedRows, retainedBytes: this.#retainedBytes };
   }
   #freshProbe() {
     let pending = this.#pendingProbe;
@@ -236,72 +185,59 @@ class LiveQuerySet {
     }
     this.#subscriptionCount += 1;
   }
-  async subscribe(query, options) {
-    this.#throwIfClosed();
-    this.#reserveSubscription();
-    let group;
-    let subscriber;
-    try {
-      const opened = await this.#getOrOpenGroup(query);
-      group = opened.group;
-      this.#throwIfClosed();
-      subscriber = {
-        kind: "result",
-        options,
-        delivered: false,
-        closed: false,
-        seenDelivery: -1
-      };
-      group.subscribers.add(subscriber);
-      await this.#settleGroup(group, opened.fresh, true);
-      this.#throwIfClosed();
-      if (!subscriber.delivered) {
-        const result = group.result ?? (await this.#executeGroup(group)).result;
-        this.#throwIfClosed();
-        if (!subscriber.closed) {
-          this.#deliverResult(group, subscriber, result, { ...group.seenProbe, initial: true });
-        }
-      }
-    } catch (error) {
-      if (group !== void 0 && subscriber !== void 0) {
-        this.#removeSubscriber(group, subscriber, false);
-      } else {
-        this.#subscriptionCount -= 1;
-        if (group !== void 0)
-          this.#removeEmptyGroup(group);
-      }
-      throw error;
-    }
-    return this.#subscriptionHandle(group, subscriber);
+  subscribe(query, options) {
+    return this.#register(query, {
+      kind: "result",
+      options,
+      delivered: false,
+      closed: false,
+      seenDelivery: -1
+    });
+  }
+  subscribePatches(query, options) {
+    return this.subscribe(query, {
+      sharedResults: true,
+      onChange: (result, delivery) => options.onPatch(createLiveQueryPatch(result, delivery), delivery),
+      ...options.onError === void 0 ? {} : { onError: options.onError.bind(options) },
+      ...options.onComplete === void 0 ? {} : { onComplete: options.onComplete.bind(options) }
+    });
   }
-  async observe(query, options) {
+  observe(query, options) {
+    return this.#register(query, { kind: "observer", options, delivered: false, closed: false });
+  }
+  async #register(query, subscriber) {
     this.#throwIfClosed();
     this.#reserveSubscription();
     let group;
-    let subscriber;
+    let installed = false;
     try {
       const opened = await this.#getOrOpenGroup(query);
       group = opened.group;
       this.#throwIfClosed();
-      subscriber = {
-        kind: "observer",
-        options,
-        delivered: false,
-        closed: false
-      };
       group.subscribers.add(subscriber);
-      await this.#settleGroup(group, opened.fresh, options.suppressUnchanged === true);
+      group.pendingSubscriptions -= 1;
+      installed = true;
+      await this.#settleGroup(group, opened.fresh, subscriber.kind === "result" || subscriber.options.suppressUnchanged === true);
       this.#throwIfClosed();
       if (!subscriber.delivered) {
-        this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
+        if (subscriber.kind === "observer")
+          this.#deliverInvalidation(subscriber, { ...group.seenProbe, initial: true });
+        else {
+          const result = group.result ?? (await this.#executeGroup(group)).result;
+          this.#throwIfClosed();
+          if (!subscriber.closed)
+            this.#deliverResult(group, subscriber, result, { ...group.seenProbe, initial: true });
+        }
       }
     } catch (error) {
-      if (group !== void 0 && subscriber !== void 0) {
+      if (group !== void 0 && installed) {
         this.#removeSubscriber(group, subscriber, false);
       } else {
         this.#subscriptionCount -= 1;
-        if (group !== void 0)
+        if (group !== void 0) {
+          group.pendingSubscriptions -= 1;
           this.#removeEmptyGroup(group);
+        }
       }
       throw error;
     }
@@ -337,30 +273,39 @@ class LiveQuerySet {
     subscriber.closed = true;
     this.#subscriptionCount -= 1;
     group.subscribers.delete(subscriber);
-    if (complete)
-      subscriber.options.onComplete?.();
     this.#removeEmptyGroup(group);
+    if (complete)
+      callLiveCallback(() => subscriber.options.onComplete?.());
   }
   #removeEmptyGroup(group) {
-    if (group.subscribers.size !== 0)
+    if (group.subscribers.size !== 0 || group.pendingSubscriptions !== 0)
       return;
     if (this.#groups.get(group.key) !== group)
       return;
     this.#groups.delete(group.key);
+    this.#retainedBytes -= group.retainedBytes;
+    group.retainedBytes = 0;
+    group.result = void 0;
+    group.maintenance = void 0;
     this.#lagging.delete(group);
     this.#unindexGroup(group, group.dependencies);
   }
   async #getOrOpenGroup(query) {
+    if (typeof query !== "string")
+      query = structuredClone(query);
     const key = queryKey(query);
     const existing = this.#groups.get(key);
     if (existing !== void 0) {
       this.#stats.sharedExecutions += 1;
+      existing.pendingSubscriptions += 1;
       return { group: existing, fresh: false };
     }
     const opening = this.#opening.get(key);
     if (opening !== void 0) {
       this.#stats.sharedExecutions += 1;
-      return { group: await opening, fresh: false };
+      const group = await opening;
+      group.pendingSubscriptions += 1;
+      return { group, fresh: false };
     }
     if (this.#groups.size + this.#opening.size >= this.#maxGroups) {
       throw new LiveQueryLimitError("group", this.#maxGroups);
@@ -368,7 +313,9 @@ class LiveQuerySet {
     const created = this.#openGroup(key, query);
     this.#opening.set(key, created);
     try {
-      return { group: await created, fresh: true };
+      const group = await created;
+      group.pendingSubscriptions += 1;
+      return { group, fresh: true };
     } finally {
       this.#opening.delete(key);
     }
@@ -380,8 +327,10 @@ class LiveQuerySet {
       query,
       dependencies,
       subscribers: /* @__PURE__ */ new Set(),
+      pendingSubscriptions: 0,
       seenProbe: after,
       result: void 0,
+      retainedBytes: 0,
       execution: void 0,
       deliveries: 0,
       maintenance: void 0,
@@ -445,14 +394,18 @@ class LiveQuerySet {
       await this.#acquireExecutionSlot();
       let executed;
       let maintenance;
+      let retainedBytes;
+      let candidate;
       try {
         if (this.#incremental && this.#host.executeMaintainable !== void 0 && !group.unmaintainable) {
           const maintained = await this.#host.executeMaintainable(group.query, context);
           if (maintained === void 0)
             group.unmaintainable = true;
           else {
+            candidate = maintained;
             executed = maintained.result;
             maintenance = maintained.state;
+            retainedBytes = maintained.retainedBytes;
           }
         }
         executed ??= await this.#host.execute(group.query, context);
@@ -461,8 +414,9 @@ class LiveQuerySet {
       }
       const previous = group.result;
       const changed = previous === void 0 || !sameResult(previous, executed);
-      group.result = executed;
-      group.maintenance = maintenance;
+      this.#retain(group, executed, maintenance, retainedBytes, candidate);
+      if (candidate !== void 0 && context !== void 0 && groupMemoizes(group, changed))
+        await this.#memoizeGroup(group, executed, context.probe);
       return { result: executed, changed };
     })();
     group.execution = execution;
@@ -473,6 +427,28 @@ class LiveQuerySet {
         group.execution = void 0;
     }
   }
+  async #memoizeGroup(group, result, probe) {
+    if (this.#closed || this.#groups.get(group.key) !== group)
+      return;
+    try {
+      await this.#host.memoize?.(group.query, result, probe);
+    } catch {
+    }
+  }
+  #retain(group, result, state, hint, candidate) {
+    if (this.#closed || this.#groups.get(group.key) !== group)
+      return;
+    const bytes = hint ?? (result === group.result && state === group.maintenance ? group.retainedBytes : queryResultRetainedBytes(result) + result.rows.length * 48);
+    const total = this.#retainedBytes - group.retainedBytes + bytes;
+    if (!Number.isSafeInteger(bytes) || bytes < 0 || !Number.isSafeInteger(total) || total > this.#maxRetainedBytes)
+      throw new LiveQueryLimitError("byte", this.#maxRetainedBytes);
+    if (candidate !== void 0)
+      acceptLiveExecution(candidate);
+    group.result = result;
+    group.maintenance = state;
+    group.retainedBytes = bytes;
+    this.#retainedBytes = total;
+  }
   async #acquireExecutionSlot() {
     if (this.#executing < LIVE_QUERY_EXECUTION_CONCURRENCY) {
       this.#executing += 1;
@@ -509,8 +485,9 @@ class LiveQuerySet {
         verdict.declined = true;
         return { result: retained, changed: false };
       }
-      group.result = maintained.result;
-      group.maintenance = maintained.state;
+      this.#retain(group, maintained.result, maintained.state, maintained.retainedBytes, maintained);
+      if (groupMemoizes(group, maintained.changed))
+        await this.#memoizeGroup(group, maintained.result, probe);
       return {
         result: maintained.result,
         changed: maintained.changed,
@@ -531,7 +508,7 @@ class LiveQuerySet {
       return;
     subscriber.delivered = true;
     const consecutive = subscriber.seenDelivery === group.deliveries - 1;
-    subscriber.options.onChange(this.#sharedResults ? result : cloneResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
+    subscriber.options.onChange(this.#sharedResults || subscriber.options.sharedResults === true ? result : copyQueryResult(result), retained !== void 0 && consecutive && !delivery.initial ? { ...delivery, retained } : delivery);
     subscriber.seenDelivery = group.deliveries;
   }
   #deliverInvalidation(subscriber, invalidation) {
@@ -557,11 +534,17 @@ class LiveQuerySet {
       this.#channel?.close?.();
     if (this.#pollTimer !== void 0)
       clearInterval(this.#pollTimer);
+    if (this.#retryTimer !== void 0)
+      clearTimeout(this.#retryTimer);
     const groups = [...this.#groups.values()];
     this.#groups.clear();
+    this.#retainedBytes = 0;
     this.#groupsByTable.clear();
     this.#lagging.clear();
     for (const group of groups) {
+      group.result = void 0;
+      group.maintenance = void 0;
+      group.retainedBytes = 0;
       const subscribers = [...group.subscribers];
       group.subscribers.clear();
       for (const subscriber of subscribers) {
@@ -569,28 +552,46 @@ class LiveQuerySet {
           continue;
         subscriber.closed = true;
         this.#subscriptionCount -= 1;
-        subscriber.options.onComplete?.();
+        callLiveCallback(() => subscriber.options.onComplete?.());
       }
     }
-    this.#onClosed?.();
+    callLiveCallback(this.#onClosed);
   }
   #hint() {
     if (this.#closed)
       return;
     this.#stats.hints += 1;
+    if (this.#retryTimer !== void 0)
+      return;
     if (this.#sweepQueued)
       return;
     this.#sweepQueued = true;
     this.#sweepChain = this.#sweepChain.then(async () => {
       this.#sweepQueued = false;
+      if (this.#retryTimer !== void 0)
+        return;
       try {
         await this.#sweep();
+        this.#retryDelayMs = 100;
       } catch (error) {
+        if (error instanceof OpfsCoordinationError) {
+          this.#retrySweep();
+          return;
+        }
         for (const group of this.#groups.values())
           this.#notifyGroupError(group, error);
       }
     });
   }
+  #retrySweep() {
+    if (this.#closed || this.#groups.size === 0 || this.#retryTimer !== void 0)
+      return;
+    this.#retryTimer = setTimeout(() => {
+      this.#retryTimer = void 0;
+      this.#hint();
+    }, this.#retryDelayMs);
+    this.#retryDelayMs = Math.min(this.#retryDelayMs * 2, 5e3);
+  }
   #stillOpen() {
     return !this.#closed;
   }
@@ -668,6 +669,8 @@ class LiveQuerySet {
         await this.#refreshDependencies(group);
       } catch (error) {
         this.#lagging.add(group);
+        if (error instanceof OpfsCoordinationError)
+          throw error;
         this.#notifyGroupError(group, error);
         return;
       }
@@ -735,29 +738,31 @@ class LiveQuerySet {
         if (isObserver(subscriber)) {
           if (execution !== void 0 && !execution.changed && subscriber.options.suppressUnchanged === true) {
             this.#stats.notificationsSuppressed += 1;
-            return;
+            continue;
           }
           try {
             this.#deliverInvalidation(subscriber, invalidation);
             this.#stats.invalidations += 1;
           } catch (error) {
-            subscriber.options.onError?.(error);
+            callLiveCallback(() => subscriber.options.onError?.(error));
           }
         } else if (isResultSubscriber(subscriber) && execution !== void 0) {
           if (!execution.changed) {
             this.#stats.notificationsSuppressed += 1;
-            return;
+            continue;
           }
           try {
             this.#deliverResult(group, subscriber, execution.result, invalidation, execution.retained);
           } catch (error) {
-            subscriber.options.onError?.(error);
+            callLiveCallback(() => subscriber.options.onError?.(error));
           }
         }
       }
       this.#settleProbe(group, current);
     } catch (error) {
       this.#lagging.add(group);
+      if (error instanceof OpfsCoordinationError)
+        throw error;
       this.#notifyGroupError(group, error);
     }
   }
@@ -769,7 +774,7 @@ class LiveQuerySet {
     for (const subscriber of group.subscribers) {
       if (subscriber.closed)
         continue;
-      subscriber.options.onError?.(error);
+      callLiveCallback(() => subscriber.options.onError?.(error));
     }
   }
   async #changedTablesSince(after, until) {
@@ -797,7 +802,6 @@ class LiveQuerySet {
     }
   }
 }
-import { copyDate, dateMilliseconds } from "../date-value.js";
 export {
   DEFAULT_LIVE_QUERY_MAX_GROUPS,
   DEFAULT_LIVE_QUERY_MAX_SUBSCRIPTIONS,

package/dist/engine/optimizer.js

@@ -1,3 +1,4 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { dateIsoString, dateMilliseconds } from "../date-value.js";
 import { crossJoinPlan } from "../plan/model.js";
 import { blockHasRowWindow, blockHasSubqueries, childExpressions, DUAL_TABLE, expressionAliases, forEachBlockExpression, forEachNestedBlock, hasAggregate, isAggregateCall, isScalarFunctionName, mapBlockExpressions, mapChildExpressions, parseQuantified, scalarFunctionNames, scalarFunctionValue, splitCondition, statementDatetimeNames, volatileScalarFunctionNames, transparentProjectionSource, dateTruncValue, integerQuotient } from "./query.js";
@@ -557,7 +558,7 @@ function propagateJoinKeyConstants(block) {
   }
   if (pairs.length === 0)
     return;
-  const signature = (predicate) => JSON.stringify(predicate);
+  const signature = (predicate) => encodeQueryIdentity(predicate);
   const present = new Set(block.predicates.map(signature));
   const implied = [];
   const constantSide = (predicate) => {
@@ -785,9 +786,9 @@ function decorrelateBlock(block, nextAlias) {
     if (!expressionHasCorrelatedSubquery(item.expression))
       continue;
     if (grouped) {
-      const groupedExpressions = new Set(block.groupBy.map((group) => JSON.stringify(group)));
+      const groupedExpressions = new Set(block.groupBy.map((group) => encodeQueryIdentity(group)));
       const outerReferences = correlatedOuterReferences(item.expression);
-      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(JSON.stringify({ kind: "column", reference })))) {
+      if (containsAggregateCall(item.expression) || outerReferences.some((reference) => !groupedExpressions.has(encodeQueryIdentity({ kind: "column", reference })))) {
         throw new TypeError("A grouped correlated select-list subquery must reference only GROUP BY columns and cannot be nested inside an aggregate");
       }
     }
@@ -2428,7 +2429,11 @@ function foldExpression(expression) {
         if (folded === null || typeof folded === "string" || typeof folded === "boolean" || folded instanceof Date || typeof folded === "number" && Number.isFinite(folded)) {
           const target = foldedArguments[1];
           const targetWord = expression.name === "CAST" && target?.kind === "literal" && typeof target.value === "string" ? target.value : void 0;
-          const sqlDomain = targetWord?.startsWith("numeric:") === true ? (() => {
+          const first = literalValues[0];
+          const sqlDomain = expression.name === "ARRAY" ? {
+            kind: "array",
+            element: typeof first === "number" ? "DOUBLE" : typeof first === "boolean" ? "BOOLEAN" : first instanceof Date ? "TIMESTAMP" : "TEXT"
+          } : targetWord?.startsWith("numeric:") === true ? (() => {
             const [, precisionWord = "", scaleWord = ""] = targetWord.split(":");
             return {
               kind: "numeric",
@@ -2565,8 +2570,8 @@ function rewriteForInner(expression, source, derived, singleSource) {
     if (containsAggregateOrWindow(item.expression))
       return void 0;
     if (derived.groupBy.length > 0) {
-      const signature = JSON.stringify(item.expression);
-      if (!derived.groupBy.some((group) => JSON.stringify(group) === signature)) {
+      const signature = encodeQueryIdentity(item.expression);
+      if (!derived.groupBy.some((group) => encodeQueryIdentity(group) === signature)) {
         return void 0;
       }
     }

package/dist/engine/query-cache.js

@@ -1,25 +1,28 @@
+import { encodeQueryIdentity } from "./query-identity.js";
 import { copyDate, dateMilliseconds } from "../date-value.js";
 import { estimateValuesBytes } from "./byte-estimates.js";
-import { copyQueryResultExternalization } from "./query.js";
+import { copyQueryResultExternalization } from "./result-state.js";
 import { defineSqlResultProperty } from "./sql-semantics.js";
 const RESULT_MEMO_MAX_BYTES = 4 * 1024 * 1024;
+function sameQueryRow(left, right, columns) {
+  if (left === right)
+    return true;
+  for (const column of columns) {
+    const a = left[column] ?? null;
+    const b = right[column] ?? null;
+    if (a instanceof Date || b instanceof Date) {
+      if (!(a instanceof Date && b instanceof Date) || !Object.is(dateMilliseconds(a), dateMilliseconds(b)))
+        return false;
+    } else if (!Object.is(a, b))
+      return false;
+  }
+  return true;
+}
 function queryResultMemoKey(sql, params) {
   return JSON.stringify([sql, params.map(encodeParameter)]);
 }
 function planMemoKey(plan) {
-  return JSON.stringify(plan, (_key, value) => {
-    if (value instanceof Date)
-      return { $date: dateMilliseconds(value) };
-    if (typeof value === "bigint")
-      return { $bigint: value.toString() };
-    if (typeof value === "number") {
-      if (Object.is(value, -0))
-        return { $number: "-0" };
-      if (!Number.isFinite(value))
-        return { $number: String(value) };
-    }
-    return value;
-  });
+  return encodeQueryIdentity(plan);
 }
 function copyQueryResult(result) {
   const columns = result.columns;
@@ -67,5 +70,6 @@ export {
   copyQueryResult,
   planMemoKey,
   queryResultMemoKey,
-  queryResultRetainedBytes
+  queryResultRetainedBytes,
+  sameQueryRow
 };