@minnowdb/core 0.7.8 → 0.8.0

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/engine/worker-server.js

@@ -379,7 +379,8 @@ class DatabaseRpcServer {
         try {
           set = this.database.liveQueries({
             ...channelName === void 0 ? {} : { channelName },
-            ...pollIntervalMs === void 0 ? {} : { pollIntervalMs }
+            ...pollIntervalMs === void 0 ? {} : { pollIntervalMs },
+            sharedResults: true
           });
           this.#publishHandle(handleId, { type: "live-set", set, subscriptionIds: /* @__PURE__ */ new Set() });
         } catch (error) {
@@ -667,11 +668,15 @@ class DatabaseRpcServer {
         let subscription;
         try {
           subscription = await handle.set.subscribe(query, {
-            onChange: (result) => {
+            onChange: (result, delivery) => {
               const encoded = encodeQueryResult(result);
-              this.scope.postMessage(rpcEvent(subscriptionId, "change", encoded.payload), {
-                transfer: encoded.transfer
-              });
+              const retained = delivery.retained?.slice();
+              if (retained !== void 0)
+                encoded.transfer.push(retained.buffer);
+              this.scope.postMessage(rpcEvent(subscriptionId, "change", {
+                result: encoded.payload,
+                delivery: retained === void 0 ? delivery : { ...delivery, retained }
+              }), { transfer: encoded.transfer });
             },
             onError: (error) => {
               this.scope.postMessage(rpcEvent(subscriptionId, "error", serializeError(error)));
@@ -700,9 +705,11 @@ class DatabaseRpcServer {
       case "observe": {
         const subscriptionId = this.#claimHandleId(args[0]);
         const query = args[1];
+        const { suppressUnchanged } = args[2] ?? {};
         let subscription;
         try {
           subscription = await handle.set.observe(query, {
+            ...suppressUnchanged === true ? { suppressUnchanged: true } : {},
             onInvalidate: (invalidation) => {
               this.scope.postMessage(rpcEvent(subscriptionId, "invalidate", invalidation));
             },

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/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 4;
+export declare const protocolVersion: 6;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type RpcRequest = {

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-const protocolVersion = 4;
+const protocolVersion = 6;
 const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 function serializeError(error) {
   if (!(error instanceof Error)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.7.8",
+  "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",

package/postgres-feature-profile.json

@@ -142,7 +142,7 @@
     {
       "id": "type.exact-numeric",
       "classification": "different",
-      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings, as PGlite's default decoder also does. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. Division and AVG select their result scale the way PostgreSQL does, so quotient digits agree — including AVG over a column whose declared scale exceeds the selection. The canonical encoding does drop a stored value's display scale, so an explicit arithmetic quotient (such as SUM(v) / COUNT(v)) over a column declared with more than about twenty fractional digits can carry fewer digits than PostgreSQL, which floors the selection at the operand's display scale. An arithmetic or comparison expression mixing a float column with a constant Float64 cannot represent stays exact, where PostgreSQL casts the constant to float8 and rounds it before evaluating."
+      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings, as PGlite's default decoder also does. A declared scale renders at exactly that scale as PostgreSQL does; a bare NUMERIC column, a derived arithmetic result, and a value cast or concatenated to text render canonically, without the trailing fractional zeros PostgreSQL preserves. Division and AVG select their result scale the way PostgreSQL does, so quotient digits agree \u2014 including AVG over a column whose declared scale exceeds the selection. The canonical encoding does drop a stored value's display scale, so an explicit arithmetic quotient (such as SUM(v) / COUNT(v)) over a column declared with more than about twenty fractional digits can carry fewer digits than PostgreSQL, which floors the selection at the operand's display scale. An arithmetic or comparison expression mixing a float column with a constant Float64 cannot represent stays exact, where PostgreSQL casts the constant to float8 and rounds it before evaluating."
     },
     {
       "id": "type.json-jsonb",
@@ -258,6 +258,11 @@
       "id": "privileges.grant",
       "classification": "inapplicable",
       "reason": "An embedded database has no server roles, owners, or GRANT boundary."
+    },
+    {
+      "id": "aggregate.array-agg",
+      "classification": "different",
+      "reason": "Minnow returns arrays as canonical JSON text at the JavaScript boundary; PostgreSQL clients return native arrays. ARRAY_AGG supports DISTINCT and ordering, but not FILTER or window use."
     }
   ]
 }

package/sql-feature-matrix.json

@@ -653,14 +653,13 @@
       "id": "window.frame",
       "status": "supported",
       "example": "SELECT amount, SUM(amount) OVER (ORDER BY amount, joined ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS windowed FROM rows",
-      "notes": "ROWS frames take row-distance bounds; RANGE frames take UNBOUNDED and CURRENT ROW bounds, where CURRENT ROW spans the ordering peer group."
+      "notes": "ROWS frames use row distances; RANGE frames use peers or numeric ordering-value distances; GROUPS frames use peer-group distances. Exclusions are supported."
     },
     {
       "id": "window.frame-range-offset",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT amount, SUM(amount) OVER (ORDER BY amount RANGE BETWEEN 1 PRECEDING AND CURRENT ROW) AS windowed FROM rows",
-      "error": "RANGE frames take only UNBOUNDED and CURRENT ROW bounds; use ROWS",
-      "notes": "A numeric RANGE offset bounds the frame by ordering-value distance, which the engine does not implement. ROWS frames take numeric offsets; RANGE frames take UNBOUNDED and CURRENT ROW bounds only."
+      "notes": "Numeric RANGE offsets measure ordering-value distance and require one numeric ORDER BY expression. Temporal interval offsets are not supported."
     },
     {
       "id": "window.distinct-aggregate",
@@ -671,10 +670,9 @@
     },
     {
       "id": "window.outside-select",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT amount FROM rows ORDER BY ROW_NUMBER() OVER (ORDER BY amount)",
-      "error": "Window functions are only allowed in the select list",
-      "notes": "PostgreSQL also evaluates window functions in ORDER BY; Minnow evaluates them only as select items. Alias the window in the select list and order by the alias."
+      "notes": "Window functions work in SELECT and ORDER BY. WHERE, GROUP BY, and HAVING cannot contain windows."
     },
     {
       "id": "join.right",
@@ -843,7 +841,7 @@
       "id": "expression.cast",
       "status": "supported",
       "example": "SELECT CAST(amount AS INTEGER) AS whole, CAST(amount AS TEXT) AS label FROM rows",
-      "notes": "Common PostgreSQL type names map to the four stored value kinds; integer targets round to the nearest integer with ties to even, PostgreSQL's float8 cast (SQLite truncates), and non-numeric strings fail rather than becoming 0. The postfix spelling amount::INTEGER is the same cast."
+      "notes": "Integer casts round exact NUMERIC ties away from zero and floating-point ties to even. Integer text accepts signed decimal digits. Postfix :: and CAST use the same rules."
     },
     {
       "id": "identifier.quoted",
@@ -928,10 +926,9 @@
     },
     {
       "id": "join.full-grouped",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT r.region AS region, COUNT(*) AS matched FROM rows r FULL JOIN dims d ON d.region = r.region GROUP BY r.region",
-      "error": "FULL JOIN cannot be combined with grouping, DISTINCT, or window functions yet",
-      "notes": "FULL JOIN desugars into a union of two left joins, and grouping, DISTINCT, and window functions do not distribute over that union yet. Put the FULL JOIN in a derived table and group, deduplicate, or window in the outer block."
+      "notes": "The sole FULL JOIN composes with grouping, DISTINCT, wildcards, and window functions by applying these operations after both unmatched sides are included."
     },
     {
       "id": "order-by.ordinal",
@@ -1114,10 +1111,9 @@
     },
     {
       "id": "join.full-compound-on",
-      "status": "unsupported",
-      "example": "SELECT r.region FROM rows r FULL JOIN keyed k ON k.name = r.region AND k.score > 0",
-      "error": "FULL JOIN requires a single equality ON condition",
-      "notes": "FULL JOIN takes a single equality ON condition; move the extra condition into a derived source."
+      "status": "supported",
+      "example": "SELECT r.region FROM rows r FULL JOIN dims d ON d.region = r.region AND d.label <> ''",
+      "notes": "A sole FULL JOIN accepts compound ON predicates and preserves unmatched rows from both sides."
     },
     {
       "id": "datetime.current-date",
@@ -1552,10 +1548,9 @@
     },
     {
       "id": "aggregate.array-agg",
-      "status": "unsupported",
-      "example": "SELECT region, array_agg(amount) AS amounts FROM rows GROUP BY region",
-      "error": "Unsupported function: array_agg",
-      "notes": "array_agg is not supported because arrays are not; json_agg (JSON_ARRAYAGG) collects a group into a JSON array instead."
+      "status": "supported",
+      "example": "SELECT region, array_agg(amount ORDER BY amount) AS amounts FROM rows GROUP BY region ORDER BY region",
+      "notes": "ARRAY_AGG supports DISTINCT and aggregate-local ORDER BY, includes NULL elements, and returns NULL for empty input. Arrays cross the JavaScript boundary as canonical JSON text. FILTER and window use are not supported."
     },
     {
       "id": "aggregate.ordered-set",
@@ -1568,14 +1563,13 @@
       "id": "type.array",
       "status": "supported",
       "example": "SELECT ARRAY[1, 2] AS pair",
-      "notes": "Constructors and array columns use canonical JSON text at the JavaScript boundary. Subscripts and array operators are not supported (see type.array-subscript, type.array-any, and array.concat)."
+      "notes": "Constructors and array columns use canonical JSON text at the JavaScript boundary. One-based scalar subscripts and ARRAY_AGG are supported. Array operators such as concatenation and ANY/ALL remain unsupported."
     },
     {
       "id": "type.array-subscript",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT (ARRAY[1, 2, 3])[1] AS first_element",
-      "error": "Array subscripts are not supported",
-      "notes": "PostgreSQL reads array elements with one-based subscripts and slices. Minnow arrays are opaque JSON text values; element access is refused at parse time."
+      "notes": "One-based scalar subscripts return NULL for an out-of-range position. Slices and multidimensional access are not supported."
     },
     {
       "id": "type.array-any",
@@ -1748,7 +1742,7 @@
       "status": "unsupported",
       "example": "SELECT INTERVAL '1 day' + INTERVAL '2 hours' AS total FROM rows",
       "error": "Date arithmetic requires a date or datetime value",
-      "notes": "Interval-valued arithmetic — interval + interval, timestamp - timestamp, date - date, date + integer, EXTRACT(EPOCH FROM interval), justify_days — is not supported. A date or datetime plus or minus an INTERVAL is; subtract two EXTRACT(EPOCH …) readings for a duration in seconds."
+      "notes": "Interval-valued arithmetic — interval + interval, timestamp - timestamp, date - date, date + integer, justify_days — is not supported. A date or datetime plus or minus an INTERVAL is; subtract two EXTRACT(EPOCH …) readings for a duration in seconds."
     },
     {
       "id": "expression.date-minus-date",
@@ -1828,10 +1822,9 @@
     },
     {
       "id": "function.unnest",
-      "status": "unsupported",
+      "status": "supported",
       "example": "SELECT x FROM unnest(ARRAY[3, 1, 2]) AS x",
-      "error": "Expected )",
-      "notes": "Set-returning functions (unnest, generate_series, regexp_split_to_table, jsonb_array_elements) are not supported as FROM sources; use a VALUES source, a recursive CTE for a series, or JSON_TABLE for a JSON array."
+      "notes": "UNNEST over an ARRAY constructor produces typed rows and supports WITH ORDINALITY and output column aliases. Table-correlated array inputs and arbitrary array expressions are not supported."
     },
     {
       "id": "function.generate-series",