@minnowdb/core 0.7.10 → 0.8.0

package/dist/engine/sql-domains.d.ts

@@ -91,3 +91,7 @@ export declare function concatenatedSqlValue(leftValue: unknown, rightValue: unk
  */
 export declare function intervalDomainCompare(left: unknown, right: unknown): number | undefined;
 export declare function isSqlDomainValue(value: unknown): value is string;
+/** SQL extraction from TIME and INTERVAL without collapsing calendar months into a timestamp. */
+export declare function temporalDomainPart(field: string, value: unknown): number | undefined;
+/** Structural ordering for shipped JSONB and one-dimensional ARRAY values. */
+export declare function structuredDomainCompare(left: unknown, right: unknown): number | undefined;

package/dist/engine/sql-domains.js

@@ -722,6 +722,125 @@ function intervalDomainCompare(left, right) {
 function isSqlDomainValue(value) {
   return typeof value === "string" && value.startsWith(PREFIX);
 }
+function temporalDomainPart(field, value) {
+  if (typeof value !== "string")
+    return void 0;
+  let months = 0;
+  let days = 0;
+  let usecs;
+  const interval = value.startsWith(INTERVAL_VALUE);
+  if (interval) {
+    [months, days, usecs] = JSON.parse(value.slice(INTERVAL_VALUE.length));
+  } else if (value.startsWith(TIME_VALUE)) {
+    const [hour = "0", minute = "0", second = "0"] = value.slice(TIME_VALUE.length).split(":");
+    usecs = Number(hour) * 36e8 + Number(minute) * 6e7 + Math.round(Number(second) * 1e6);
+  } else
+    return void 0;
+  switch (field) {
+    case "hour":
+      return Math.trunc(usecs / 36e8);
+    case "minute":
+      return Math.trunc(usecs / 6e7) % 60;
+    case "second":
+      return usecs % 6e7 / 1e6;
+    case "milliseconds":
+      return usecs % 6e7 / 1e3;
+    case "microseconds":
+      return usecs % 6e7;
+    case "epoch":
+      return interval ? (Math.trunc(months / 12) * 365.25 + months % 12 * 30 + days) * 86400 + usecs / 1e6 : usecs / 1e6;
+  }
+  if (interval) {
+    const years = Math.trunc(months / 12);
+    switch (field) {
+      case "year":
+        return years;
+      case "month":
+        return months % 12;
+      case "day":
+        return days;
+      case "quarter":
+        return Math.trunc(months % 12 / 3) + 1;
+      case "decade":
+        return Math.trunc(years / 10);
+      case "century":
+        return Math.trunc(years / 100);
+      case "millennium":
+        return Math.trunc(years / 1e3);
+    }
+  }
+  throw new TypeError(`Cannot extract ${field} from ${interval ? "INTERVAL" : "TIME"}`);
+}
+function structuredDomainCompare(left, right) {
+  if (typeof left !== "string" || typeof right !== "string")
+    return void 0;
+  const array = left.startsWith(ARRAY_VALUE) && right.startsWith(ARRAY_VALUE);
+  const jsonb = left.startsWith(JSONB_VALUE) && right.startsWith(JSONB_VALUE);
+  if (!array && !jsonb)
+    return void 0;
+  if (left === right)
+    return 0;
+  const prefix = array ? ARRAY_VALUE : JSONB_VALUE;
+  const a = JSON.parse(left.slice(prefix.length));
+  const b = JSON.parse(right.slice(prefix.length));
+  if (array && Array.isArray(a) && Array.isArray(b)) {
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+      const x = a[index];
+      const y = b[index];
+      const order = x === null || y === null ? x === y ? 0 : x === null ? 1 : -1 : compareJsonStructure(x, y);
+      if (order !== 0)
+        return order;
+    }
+    return a.length - b.length;
+  }
+  if (Array.isArray(a) && a.length === 0)
+    return Array.isArray(b) && b.length === 0 ? 0 : -1;
+  if (Array.isArray(b) && b.length === 0)
+    return 1;
+  return compareJsonStructure(a, b);
+}
+function compareJsonStructure(left, right) {
+  if (left === right)
+    return 0;
+  const rank = (value) => value === null ? 0 : typeof value === "string" ? 1 : typeof value === "number" ? 2 : typeof value === "boolean" ? 3 : Array.isArray(value) ? 4 : 5;
+  const difference = rank(left) - rank(right);
+  if (difference !== 0)
+    return difference;
+  if (typeof left === "number" && typeof right === "number")
+    return left - right;
+  if (typeof left === "string" && typeof right === "string")
+    return left < right ? -1 : 1;
+  if (typeof left === "boolean" && typeof right === "boolean")
+    return Number(left) - Number(right);
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length)
+      return left.length - right.length;
+    for (let index = 0; index < left.length; index += 1) {
+      const order = compareJsonStructure(left[index], right[index]);
+      if (order !== 0)
+        return order;
+    }
+    return 0;
+  }
+  const a = left;
+  const b = right;
+  const encoder = new TextEncoder();
+  const keyOrder = (x, y) => encoder.encode(x).length - encoder.encode(y).length || (x === y ? 0 : x < y ? -1 : 1);
+  const keysA = Object.keys(a).sort(keyOrder);
+  const keysB = Object.keys(b).sort(keyOrder);
+  if (keysA.length !== keysB.length)
+    return keysA.length - keysB.length;
+  for (let index = 0; index < keysA.length; index += 1) {
+    const x = keysA[index] ?? "";
+    const y = keysB[index] ?? "";
+    if (x !== y)
+      return x < y ? -1 : 1;
+    const order = compareJsonStructure(a[x], b[y]);
+    if (order !== 0)
+      return order;
+  }
+  return 0;
+}
 export {
   arrayDomainValue,
   boundedJsonText,
@@ -751,6 +870,8 @@ export {
   normalizeSqlDomainValue,
   preservedJsonDomainValue,
   protectedSqlTextValue,
+  structuredDomainCompare,
+  temporalDomainPart,
   timeDomainValue,
   uuidDomainValue
 };

package/dist/engine/sql-semantics.js

@@ -1,7 +1,7 @@
 import { dateMilliseconds } from "../date-value.js";
 import { assertWellFormedString } from "../block-format/unicode.js";
 import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS } from "./cache-limits.js";
-import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue } from "./sql-domains.js";
+import { structuredDomainCompare, collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue } from "./sql-domains.js";
 const SQL_TIMESTAMP_TEXT = /^(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?))?(Z|[+-]\d{2}:?\d{2})?$/;
 function parseSqlTimestampText(text) {
   const match = SQL_TIMESTAMP_TEXT.exec(text.trim());
@@ -33,9 +33,9 @@ function readUntypedText(type, text) {
   }
   if (type === "boolean") {
     const lowered = text.trim().toLowerCase();
-    if (lowered === "t" || lowered === "true" || lowered === "1")
+    if (/^(?:t(?:r(?:u(?:e)?)?)?|y(?:e(?:s)?)?|on|1)$/.test(lowered))
       return true;
-    if (lowered === "f" || lowered === "false" || lowered === "0")
+    if (/^(?:f(?:a(?:l(?:s(?:e)?)?)?)?|n(?:o)?|of(?:f)?|0)$/.test(lowered))
       return false;
   }
   return text;
@@ -72,6 +72,9 @@ function compareSqlValues(left, right) {
     }
     return compareSqlStrings(plainLeft, plainRight);
   }
+  const structured = structuredDomainCompare(left, right);
+  if (structured !== void 0)
+    return structured;
   const collated = collatedDomainCompare(left, right);
   if (collated !== void 0)
     return collated;
@@ -347,7 +350,7 @@ function generalLikeMatcher(tokens, caseInsensitive) {
 }
 function compileLikePattern(pattern, caseInsensitive = false, escape) {
   assertBoundedPattern(pattern, "LIKE pattern");
-  const exactEscape = escape === void 0 ? void 0 : exactSingleCharacter(escape, "LIKE escape");
+  const exactEscape = escape === void 0 || escape === "" ? void 0 : exactSingleCharacter(escape, "LIKE escape");
   const key = JSON.stringify([caseInsensitive, exactEscape ?? null, pattern]);
   const cached = cachedPattern(likeCache, key);
   if (cached !== void 0)

package/dist/engine/typed-live.js

@@ -6,7 +6,7 @@ function reconcileRows(previous, next, retained) {
   for (let index = 0; index < next.length; index += 1) {
     const row = next[index];
     const was = provenance?.[index] ?? -1;
-    if (was >= 0 && was < previous.length) {
+    if (was >= 0 && was < previous.length && sameLiveValue(previous[was], row)) {
       rows[index] = previous[was];
       if (was !== index)
         changed = true;
@@ -38,6 +38,7 @@ class LiveQuery {
   #executionAbort;
   #invalidationSequence = 0;
   #closed = false;
+  #refreshLeases = 0;
   constructor(backend, source, onClose) {
     this.#backend = backend;
     this.#source = source;
@@ -57,32 +58,39 @@ class LiveQuery {
         return;
       subscribed = false;
       this.#listeners.delete(registered);
-      if (this.#listeners.size === 0)
+      if (this.#listeners.size === 0 && this.#refreshLeases === 0)
         this.#stopObservation();
     };
   };
   async refresh() {
     if (this.#closed)
       throw new Error("Live query is closed");
-    const sequence = this.#invalidationSequence;
-    if (this.#listeners.size > 0) {
-      if (this.#subscription === void 0)
-        this.#startObservation();
-      const opening = this.#subscription;
-      if (opening !== void 0)
-        await opening.catch(() => void 0);
-      await this.#backend.refresh();
-    }
-    if (this.#invalidationSequence === sequence) {
-      const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
-      if (this.#decodes()) {
-        const last = this.#lastDelivered;
-        if (this.#snapshot.status === "error" && last !== void 0)
-          this.#schedule(last);
-      } else
-        this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
+    this.#refreshLeases += 1;
+    try {
+      const sequence = this.#invalidationSequence;
+      if (this.#listeners.size > 0 || this.#decodes()) {
+        if (this.#subscription === void 0)
+          this.#startObservation();
+        const opening = this.#subscription;
+        if (opening !== void 0)
+          await opening.catch(() => void 0);
+        await this.#backend.refresh();
+      }
+      if (this.#invalidationSequence === sequence) {
+        const version = this.#snapshot.status === "loading" ? null : this.#snapshot.version;
+        if (this.#decodes()) {
+          const last = this.#lastDelivered;
+          if (this.#snapshot.status === "error" && last !== void 0)
+            this.#schedule(last);
+        } else
+          this.#schedule({ manifestVersion: version, catalogEpoch: 0, initial: false });
+      }
+      await this.#waitForIdle();
+    } finally {
+      this.#refreshLeases -= 1;
+      if (this.#refreshLeases === 0 && this.#listeners.size === 0)
+        this.#stopObservation();
     }
-    await this.#waitForIdle();
   }
   #decodes() {
     return this.#source.decode !== void 0 && this.#backend.subscribe !== void 0;

package/dist/engine/windows.d.ts

@@ -0,0 +1,12 @@
+import type { QueryResult, WindowSpec } from "../plan/model.js";
+import { QueryMemoryContext } from "./memory.js";
+interface WindowOptions {
+    copyRows?: boolean;
+    memoryContext?: QueryMemoryContext;
+    signal?: AbortSignal;
+}
+/** Synchronous executor used by standalone queries; shares every kernel with asynchronous reads. */
+export declare function applyWindowFunctions(result: QueryResult, windows: readonly WindowSpec[], options?: WindowOptions): QueryResult;
+/** Cooperatively runs window passes so cancellation can arrive while a large partition is active. */
+export declare function applyWindowFunctionsAsync(result: QueryResult, windows: readonly WindowSpec[], options?: WindowOptions): Promise<QueryResult>;
+export {};

package/dist/engine/windows.js

@@ -0,0 +1,386 @@
+import { QueryMemoryContext } from "./memory.js";
+import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
+import { compareSqlValues } from "./sql-semantics.js";
+import { exactNumericBinary, exactNumericValue, isExactNumeric } from "./sql-domains.js";
+import { throwIfAborted } from "./cancellation.js";
+class FrameAggregate {
+  #width;
+  #values;
+  #counts;
+  #window;
+  #exact;
+  #prefixEnd = 0;
+  #prefixTotal = null;
+  #prefixCount = 0;
+  constructor(values, window, memory, prefix) {
+    this.#window = window;
+    this.#exact = values.some(isExactNumeric);
+    if (prefix) {
+      this.#width = 0;
+      this.#values = values;
+      this.#counts = new Uint32Array(0);
+      return;
+    }
+    const width = 2 ** Math.ceil(Math.log2(Math.max(1, values.length)));
+    this.#width = width;
+    memory.tally(width * 2 * 20, "Window aggregate tree");
+    this.#values = new Array(width * 2).fill(null);
+    this.#counts = new Uint32Array(width * 2);
+    for (let index = 0; index < values.length; index += 1) {
+      const value = values[index] ?? null;
+      this.#values[width + index] = value;
+      this.#counts[width + index] = value === null ? 0 : 1;
+    }
+    for (let index = width - 1; index > 0; index -= 1) {
+      this.#counts[index] = (this.#counts[index * 2] ?? 0) + (this.#counts[index * 2 + 1] ?? 0);
+      this.#values[index] = this.#combine(this.#values[index * 2] ?? null, this.#values[index * 2 + 1] ?? null);
+    }
+  }
+  #combine(left, right) {
+    if (left === null)
+      return right;
+    if (right === null)
+      return left;
+    if (this.#window.name === "COUNT")
+      return null;
+    if (this.#window.name === "MIN")
+      return compareSqlValues(left, right) <= 0 ? left : right;
+    if (this.#window.name === "MAX")
+      return compareSqlValues(left, right) >= 0 ? left : right;
+    if (this.#exact) {
+      const total = exactNumericBinary("+", left, right);
+      if (total === void 0)
+        throw new TypeError("Window SUM requires numeric values");
+      return total;
+    }
+    if (typeof left !== "number" || typeof right !== "number")
+      throw new TypeError("Window SUM requires numeric values");
+    return left + right;
+  }
+  prefixValue(end, scale) {
+    while (this.#prefixEnd < end) {
+      const value = this.#values[this.#prefixEnd] ?? null;
+      this.#prefixEnd += 1;
+      if (value === null)
+        continue;
+      this.#prefixCount += 1;
+      this.#prefixTotal = this.#combine(this.#prefixTotal, value);
+    }
+    return this.#finish(this.#prefixTotal, this.#prefixCount, scale);
+  }
+  value(ranges, scale) {
+    let total = null;
+    let count = 0;
+    for (const [from, to] of ranges) {
+      let low = from + this.#width;
+      let high = to + this.#width;
+      let left = null;
+      let right = null;
+      while (low < high) {
+        if (low % 2 === 1) {
+          count += this.#counts[low] ?? 0;
+          left = this.#combine(left, this.#values[low] ?? null);
+          low += 1;
+        }
+        if (high % 2 === 1) {
+          high -= 1;
+          count += this.#counts[high] ?? 0;
+          right = this.#combine(this.#values[high] ?? null, right);
+        }
+        low = Math.floor(low / 2);
+        high = Math.floor(high / 2);
+      }
+      total = this.#combine(total, this.#combine(left, right));
+    }
+    return this.#finish(total, count, scale);
+  }
+  #finish(total, count, scale) {
+    if (this.#window.name === "COUNT")
+      return count;
+    if (count === 0)
+      return null;
+    if (this.#window.name !== "AVG")
+      return total;
+    if (this.#exact)
+      return exactNumericBinary("/", total ?? exactNumericValue(0), count, scale) ?? null;
+    if (typeof total !== "number")
+      throw new TypeError("Window AVG requires numeric values");
+    return total / count;
+  }
+}
+function frameRanges(partition, window, position) {
+  const size = partition.indexes.length;
+  const frame = window.frame ?? {
+    unit: "range",
+    start: { kind: "unbounded-preceding" },
+    end: { kind: window.orderAliases.length === 0 ? "unbounded-following" : "current-row" }
+  };
+  const groupEdge = (group) => group < 0 ? 0 : partition.groupStarts[group] ?? size;
+  const bound = (edge, start) => {
+    switch (edge.kind) {
+      case "unbounded-preceding":
+        return 0;
+      case "unbounded-following":
+        return size;
+      case "current-row":
+        return frame.unit === "rows" ? position + (start ? 0 : 1) : start ? partition.peerStart[position] ?? 0 : partition.peerEnd[position] ?? size;
+      case "preceding":
+      case "following": {
+        const delta = (edge.offset ?? 0) * (edge.kind === "preceding" ? -1 : 1);
+        if (frame.unit === "range") {
+          const current = partition.orderValues[position] ?? null;
+          if (current === null)
+            return start ? partition.peerStart[position] ?? 0 : partition.peerEnd[position] ?? size;
+          if (typeof current !== "number" && !isExactNumeric(current))
+            throw new TypeError("Offset RANGE frames require numeric ORDER BY values");
+          const order = window.orderAliases[0];
+          if (window.orderAliases.length !== 1 || order === void 0)
+            throw new TypeError("Offset RANGE frames require exactly one ORDER BY expression");
+          const descending = order.direction === "desc";
+          const distance = descending ? -delta : delta;
+          const target = isExactNumeric(current) ? exactNumericBinary("+", current, distance) ?? null : current + distance;
+          let low2 = 0;
+          let high2 = size;
+          while (low2 < high2) {
+            const middle = Math.floor((low2 + high2) / 2);
+            const value = partition.orderValues[middle] ?? null;
+            const comparison = value === null ? (order.nulls ?? (descending ? "first" : "last")) === "first" ? -1 : 1 : compareSqlValues(value, target) * (descending ? -1 : 1);
+            if (comparison < 0 || !start && comparison === 0)
+              low2 = middle + 1;
+            else
+              high2 = middle;
+          }
+          return low2;
+        }
+        return frame.unit === "groups" ? groupEdge((partition.groupOrdinal[position] ?? 0) + delta + (start ? 0 : 1)) : position + delta + (start ? 0 : 1);
+      }
+    }
+  };
+  const low = Math.max(0, Math.min(size, bound(frame.start, true)));
+  const high = Math.max(0, Math.min(size, bound(frame.end, false)));
+  if (high <= low)
+    return [];
+  if (frame.exclude === void 0 || frame.exclude === "no-others")
+    return [[low, high]];
+  const from = frame.exclude === "current-row" ? position : partition.peerStart[position] ?? position;
+  const to = frame.exclude === "current-row" ? position + 1 : partition.peerEnd[position] ?? position + 1;
+  const ranges = [];
+  if (low < Math.min(high, from))
+    ranges.push([low, Math.min(high, from)]);
+  if (frame.exclude === "ties" && position >= low && position < high)
+    ranges.push([position, position + 1]);
+  if (Math.max(low, to) < high)
+    ranges.push([Math.max(low, to), high]);
+  return ranges;
+}
+function* applyPartition(rows, partition, window, result, memory) {
+  const { indexes, peerStart, peerEnd, groupOrdinal } = partition;
+  const size = indexes.length;
+  memory.tally(size * 8, "Window argument values");
+  const values = Array.from(indexes, (index) => window.argumentAlias === void 0 ? 1 : rows[index]?.[window.argumentAlias] ?? null);
+  const aggregates = /* @__PURE__ */ new Set(["SUM", "AVG", "COUNT", "MIN", "MAX"]);
+  const frame = window.frame;
+  const prefix = frame === void 0 || (frame.exclude === void 0 || frame.exclude === "no-others") && frame.start.kind === "unbounded-preceding" && (frame.end.kind === "current-row" || frame.end.kind === "unbounded-following");
+  const whole = frame?.end.kind === "unbounded-following" || frame === void 0 && window.orderAliases.length === 0;
+  const aggregate = aggregates.has(window.name) ? new FrameAggregate(values, window, memory, prefix) : void 0;
+  const domain = result.columnDomains[result.columns.indexOf(window.argumentAlias ?? "")];
+  for (let position = 0; position < size; position += 1) {
+    if (position % 2048 === 0)
+      yield;
+    let value;
+    switch (window.name) {
+      case "ROW_NUMBER":
+        value = position + 1;
+        break;
+      case "RANK":
+        value = (peerStart[position] ?? 0) + 1;
+        break;
+      case "DENSE_RANK":
+        value = (groupOrdinal[position] ?? 0) + 1;
+        break;
+      case "PERCENT_RANK":
+        value = size === 1 ? 0 : (peerStart[position] ?? 0) / (size - 1);
+        break;
+      case "CUME_DIST":
+        value = (peerEnd[position] ?? size) / size;
+        break;
+      case "NTILE": {
+        const buckets = window.offset ?? 1;
+        const width = Math.floor(size / buckets);
+        const extra = size % buckets;
+        const larger = (width + 1) * extra;
+        value = position < larger ? Math.floor(position / (width + 1)) + 1 : extra + Math.floor((position - larger) / width) + 1;
+        break;
+      }
+      case "LAG":
+      case "LEAD": {
+        const target = position + (window.offset ?? 1) * (window.name === "LAG" ? -1 : 1);
+        value = target < 0 || target >= size ? window.fallback ?? null : values[target] ?? null;
+        break;
+      }
+      default: {
+        if (aggregate !== void 0 && prefix) {
+          const end = whole ? size : frame?.unit === "rows" ? position + 1 : peerEnd[position] ?? size;
+          value = aggregate.prefixValue(end, domain?.kind === "numeric" ? domain.scale : void 0);
+          break;
+        }
+        const ranges = frameRanges(partition, window, position);
+        if (aggregate !== void 0)
+          value = aggregate.value(ranges, domain?.kind === "numeric" ? domain.scale : void 0);
+        else {
+          let remaining = window.name === "NTH_VALUE" ? window.offset ?? 1 : 1;
+          value = null;
+          if (window.name === "LAST_VALUE") {
+            const last = ranges.at(-1);
+            value = last === void 0 ? null : values[last[1] - 1] ?? null;
+          } else {
+            for (const [from, to] of ranges) {
+              if (remaining <= to - from) {
+                value = values[from + remaining - 1] ?? null;
+                break;
+              }
+              remaining -= to - from;
+            }
+          }
+        }
+      }
+    }
+    const row = rows[indexes[position] ?? -1];
+    if (row !== void 0)
+      Object.defineProperty(row, window.alias, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+  }
+}
+function* windowSteps(result, windows, options) {
+  const memory = options.memoryContext ?? new QueryMemoryContext();
+  const owned = options.memoryContext === void 0;
+  const rows = [];
+  try {
+    memory.tally(result.rows.length * (24 + windows.length * 16 + (options.copyRows === false ? 0 : 48 + result.columns.length * 16)), "Window result rows");
+    for (let index = 0; index < result.rows.length; index += 1) {
+      if (index % 2048 === 0)
+        yield;
+      const row = result.rows[index] ?? {};
+      rows.push(options.copyRows === false ? row : { ...row });
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const window of windows) {
+      const key = JSON.stringify([window.partitionAliases, window.orderAliases]);
+      const group = groups.get(key);
+      if (group === void 0)
+        groups.set(key, [window]);
+      else
+        group.push(window);
+    }
+    for (const group of groups.values()) {
+      const window = group[0];
+      if (window === void 0)
+        continue;
+      const work = memory.createChild();
+      try {
+        const aliases = [
+          ...window.partitionAliases,
+          ...window.orderAliases.map(({ alias }) => alias)
+        ];
+        work.tally(rows.length * (48 + aliases.length * 40), "Window sort and partition buffers");
+        const columns = aliases.map((alias) => buildSortKeyColumn(rows.length, (index) => rows[index]?.[alias] ?? null));
+        yield;
+        const indexes = sortKeyIndexes(rows.length, columns.map((column, index) => {
+          const order = window.orderAliases[index - window.partitionAliases.length];
+          return { column, descending: order?.direction === "desc", nulls: order?.nulls };
+        }));
+        const partitions = columns.slice(0, window.partitionAliases.length);
+        const orders = columns.slice(window.partitionAliases.length);
+        let start = 0;
+        while (start < indexes.length) {
+          let end = start + 1;
+          while (end < indexes.length && partitions.every((column) => column.compare(indexes[start] ?? 0, indexes[end] ?? 0) === 0)) {
+            if (end % 2048 === 0)
+              yield;
+            end += 1;
+          }
+          const size = end - start;
+          const partition = {
+            indexes: indexes.subarray(start, end),
+            peerStart: new Int32Array(size),
+            peerEnd: new Int32Array(size),
+            groupOrdinal: new Int32Array(size),
+            groupStarts: [],
+            orderValues: Array.from(indexes.subarray(start, end), (index) => rows[index]?.[window.orderAliases[0]?.alias ?? ""] ?? null)
+          };
+          let begin = 0;
+          for (let position = 1; position <= size; position += 1) {
+            if (position % 2048 === 0)
+              yield;
+            if (position === size || orders.some((column) => column.compare(indexes[start + begin] ?? 0, indexes[start + position] ?? 0) !== 0)) {
+              const ordinal = partition.groupStarts.length;
+              partition.groupStarts.push(begin);
+              partition.peerStart.fill(begin, begin, position);
+              partition.peerEnd.fill(position, begin, position);
+              partition.groupOrdinal.fill(ordinal, begin, position);
+              begin = position;
+            }
+          }
+          for (const member of group) {
+            const frameMemory = work.createChild();
+            try {
+              yield* applyPartition(rows, partition, member, result, frameMemory);
+            } finally {
+              frameMemory.close();
+            }
+          }
+          start = end;
+        }
+      } finally {
+        work.close();
+      }
+    }
+    return {
+      columns: [...result.columns, ...windows.map(({ alias }) => alias)],
+      columnDomains: [...result.columnDomains, ...windows.map(() => null)],
+      rows
+    };
+  } finally {
+    if (owned)
+      memory.close();
+  }
+}
+function applyWindowFunctions(result, windows, options = {}) {
+  const steps = windowSteps(result, windows, options);
+  try {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const step = steps.next();
+      if (step.done)
+        return step.value;
+    }
+  } finally {
+    steps.return({ columns: [], columnDomains: [], rows: [] });
+  }
+}
+async function applyWindowFunctionsAsync(result, windows, options = {}) {
+  const steps = windowSteps(result, windows, options);
+  let yieldedAt = performance.now();
+  try {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const step = steps.next();
+      if (step.done)
+        return step.value;
+      if (performance.now() - yieldedAt >= 8) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        yieldedAt = performance.now();
+      }
+    }
+  } finally {
+    steps.return({ columns: [], columnDomains: [], rows: [] });
+  }
+}
+export {
+  applyWindowFunctions,
+  applyWindowFunctionsAsync
+};

package/dist/plan/model.d.ts

@@ -17,7 +17,7 @@ export type ComparisonOperator = "=" | "!=" | "<>" | ">" | ">=" | "<" | "<=";
 export type AggregateName = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX" | "JSON_ARRAYAGG" | "STRING_AGG"
 /** Optimizer-only aggregate that enforces scalar-subquery cardinality. */
  | "MINNOW_SINGLE_VALUE";
-export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "TO_JSON" | "IS_JSON" | "ARRAY"
+export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "TO_JSON" | "IS_JSON" | "MINNOW_ARRAY_AT" | "MINNOW_ARRAY_FROM_JSON" | "MINNOW_ARRAY_ELEMENT" | "ARRAY"
 /** Parser-produced `->` JSON member/element access returning a JSON value. */
  | "MINNOW_JSON_GET"
 /** Parser-produced `->>` JSON member/element access returning text. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.10",
+  "version": "0.8.0",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",