@minnowdb/core 0.6.0 → 0.6.2

package/dist/storage/types.js

@@ -12,6 +12,34 @@ export const storeNames = [
     "gc",
 ];
 export const MAX_MANIFEST_CHANGED_TABLE_IDS = 1_024;
+/**
+ * A deep copy for the plain record shapes this module validates — objects, arrays, and
+ * primitives, bigint included. Records cross this boundary on every catalog read and every
+ * compaction-job advance, and `structuredClone` here was a sixth of a settle phase's CPU; any
+ * value outside the plain shape falls back to `structuredClone` for that value, so the copy
+ * stays exact whatever arrives.
+ */
+function clonePlainRecord(value) {
+    return clonePlainValue(value);
+}
+function clonePlainValue(value) {
+    if (typeof value !== "object" || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        const copy = new Array(value.length);
+        for (let index = 0; index < value.length; index += 1)
+            copy[index] = clonePlainValue(value[index]);
+        return copy;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        return structuredClone(value);
+    const copy = {};
+    for (const key of Object.keys(value)) {
+        copy[key] = clonePlainValue(value[key]);
+    }
+    return copy;
+}
 export function canonicalManifestChangedTableIds(ids) {
     if (ids.length > MAX_MANIFEST_CHANGED_TABLE_IDS) {
         throw new RangeError(`Manifest changed-table IDs cannot exceed ${String(MAX_MANIFEST_CHANGED_TABLE_IDS)}`);
@@ -51,7 +79,7 @@ export function validateSqlDomain(domain, context) {
         }
         validateEnumValues(domain.values, domain.name);
     }
-    return structuredClone(domain);
+    return clonePlainRecord(domain);
 }
 export const MAX_TABLE_COLUMNS = 1_024;
 export const MAX_ENUM_VALUES = 4_096;
@@ -1789,7 +1817,7 @@ export function normalizeSegmentRecord(record) {
     if (record.partitionOrdinal === undefined) {
         if (level === 2)
             throw new TypeError("A level-two segment requires a partition ordinal");
-        return structuredClone(record);
+        return clonePlainRecord(record);
     }
     const partitionOrdinal = nonNegativeWholeNumber(record.partitionOrdinal, "Segment partition ordinal");
     if (record.level !== 2) {
@@ -1812,7 +1840,7 @@ export function normalizeSegmentRecord(record) {
             record.rowIdEndExclusive !== record.rowIdStart + BigInt(rowCount)) {
             throw new RangeError("A partitioned segment must have a contiguous positive row ID envelope");
         }
-        return structuredClone({ ...record, partitionOrdinal });
+        return clonePlainRecord({ ...record, partitionOrdinal });
     }
     // Keyed multi-range partition: a merged full-row base whose live rows keep their original
     // ids, described by positive, sorted, non-overlapping spans that sum to the row count.
@@ -1837,7 +1865,7 @@ export function normalizeSegmentRecord(record) {
     if (spanRows !== rowCount) {
         throw new RangeError("Partitioned segment spans must cover exactly the row count");
     }
-    return structuredClone({ ...record, partitionOrdinal });
+    return clonePlainRecord({ ...record, partitionOrdinal });
 }
 export function updateTransactionRecord(record, update) {
     const updated = {
@@ -2144,7 +2172,7 @@ export function normalizeGarbageCollectionJobRecord(record) {
             cursor.transactionIndex !== 0)) {
         throw new TypeError("A planned garbage collection job cannot contain progress");
     }
-    return structuredClone(normalized);
+    return clonePlainRecord(normalized);
 }
 export function advanceGarbageCollectionJobRecord(record, accounting) {
     const current = normalizeGarbageCollectionJobRecord(record);
@@ -2355,7 +2383,7 @@ export function normalizeCompactionJobRecord(record) {
     }
     validateCompactionRewrite(normalized);
     validateCompactionJobState(normalized);
-    return structuredClone(normalized);
+    return clonePlainRecord(normalized);
 }
 export function updateCompactionJobRecord(record, update) {
     const current = normalizeCompactionJobRecord(record);

package/dist/transactions/index.js

@@ -35,6 +35,9 @@ export class LeasedSnapshot extends Snapshot {
     now;
     #record;
     #released = false;
+    /** The record's ISO expiry, parsed once: expiry is checked before every batched block read. */
+    #expiresAtIso;
+    #expiresAtMs = Number.NaN;
     constructor(store, version, record, now) {
         super(store, version);
         this.now = now;
@@ -46,7 +49,12 @@ export class LeasedSnapshot extends Snapshot {
         return this.#record.id;
     }
     get expiresAt() {
-        return new Date(this.#record.expiresAt);
+        const iso = this.#record.expiresAt;
+        if (iso !== this.#expiresAtIso) {
+            this.#expiresAtIso = iso;
+            this.#expiresAtMs = Date.parse(iso);
+        }
+        return new Date(this.#expiresAtMs);
     }
     async getBlock(id) {
         this.#assertOpen();

package/package.json

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

@@ -129,6 +129,11 @@
       "classification": "different",
       "reason": "Minnow returns JSON text; PostgreSQL returns a native JSON value, and member order is unspecified without aggregate-local ORDER BY."
     },
+    {
+      "id": "subquery.correlated-json-aggregate",
+      "classification": "different",
+      "reason": "Both engines accept the correlated JSON aggregate and agree on its JSON value, but Minnow returns JSON text while PostgreSQL returns a native JSON value."
+    },
     {
       "id": "type.exact-numeric",
       "classification": "different",

package/sql-feature-matrix.json

@@ -257,8 +257,8 @@
     {
       "id": "mutation.returning",
       "status": "supported",
-      "example": "DELETE FROM keyed WHERE name = 'x' RETURNING name, score",
-      "notes": "RETURNING works on INSERT, UPDATE, and DELETE; inserts echo written values, updates return post-update values, deletes the rows as read."
+      "example": "DELETE FROM keyed WHERE name = 'x' RETURNING keyed.name, keyed.score",
+      "notes": "RETURNING works on INSERT, UPDATE, and DELETE; inserts echo written values, updates return post-update values, and deletes return the rows as read. Columns and target.* may be target-qualified."
     },
     {
       "id": "mutation.upsert",
@@ -317,7 +317,7 @@
       "id": "predicate.quantified",
       "status": "supported",
       "example": "SELECT region FROM rows WHERE amount > ALL (SELECT amount FROM dims)",
-      "notes": "ANY/SOME/ALL use full three-valued logic. Correlated forms are supported as top-level WHERE predicates. SQLite itself has no quantified comparisons."
+      "notes": "ANY/SOME/ALL use full three-valued logic, including when a correlated form is nested below OR, NOT, CASE, or a select expression. SQLite itself has no quantified comparisons."
     },
     {
       "id": "predicate.ilike",
@@ -400,7 +400,19 @@
       "id": "subquery.correlated-select",
       "status": "supported",
       "example": "SELECT r.region, (SELECT AVG(q.amount) FROM rows q WHERE q.region = r.region) AS regional FROM rows r",
-      "notes": "Correlated scalar aggregates decorrelate in the select list. In a grouped query, their outer references must be GROUP BY columns and the scalar cannot sit inside an outer aggregate."
+      "notes": "Correlated scalar aggregates and single-row projections decorrelate in the select list. In a grouped query, their outer references must be GROUP BY columns and the scalar cannot sit inside an outer aggregate."
+    },
+    {
+      "id": "subquery.correlated-select-limit",
+      "status": "supported",
+      "example": "SELECT r.region, (SELECT q.amount FROM rows q WHERE q.region = r.region ORDER BY q.amount DESC LIMIT 1) AS peak FROM rows r",
+      "notes": "ORDER BY, LIMIT, and OFFSET apply independently to each distinct outer probe. Zero rows yield NULL and more than one unbounded row raises a scalar-cardinality error."
+    },
+    {
+      "id": "subquery.correlated-json-aggregate",
+      "status": "supported",
+      "example": "SELECT r.region, (SELECT JSON_ARRAYAGG(JSON_OBJECT('amount' VALUE q.amount) ORDER BY q.amount) FROM rows q WHERE q.region = r.region) AS amounts FROM rows r",
+      "notes": "JSON aggregate expressions use the same set-at-a-time decorrelation as numeric aggregates and preserve their JSON result domain."
     },
     {
       "id": "subquery.correlated-select-grouped",
@@ -418,7 +430,7 @@
       "id": "subquery.correlated-exists-expression",
       "status": "supported",
       "example": "SELECT r.amount FROM rows r WHERE r.amount > 100 OR EXISTS (SELECT d.region FROM dims d WHERE d.region = r.region)",
-      "notes": "Correlated EXISTS and NOT EXISTS remain set-at-a-time when nested below OR, NOT, or CASE."
+      "notes": "Correlated EXISTS and NOT EXISTS remain set-at-a-time below OR, NOT, or CASE and across deeper correlated EXISTS, IN, NOT IN, or scalar blocks. Generated aliases are unique across the complete plan tree."
     },
     {
       "id": "subquery.correlated-non-equi",
@@ -438,6 +450,12 @@
       "example": "SELECT region FROM rows r WHERE region NOT IN (SELECT d.region FROM dims d WHERE d.region = r.region)",
       "notes": "Correlated NOT IN preserves empty-set and NULL semantics rather than treating it as a simple anti-join."
     },
+    {
+      "id": "subquery.correlated-membership-expression",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE r.amount = 3 OR r.region NOT IN (SELECT q.region FROM rows q WHERE q.amount < r.amount)",
+      "notes": "Correlated IN and NOT IN retain true, false, and unknown results below OR, NOT, CASE, and in select expressions."
+    },
     {
       "id": "subquery.correlated-not-in-non-equi",
       "status": "supported",
@@ -447,8 +465,8 @@
     {
       "id": "subquery.correlated-quantified",
       "status": "supported",
-      "example": "SELECT r.amount FROM rows r WHERE r.amount > ALL (SELECT q.amount FROM rows q WHERE q.region = r.region)",
-      "notes": "At top-level WHERE, correlated ANY lowers to a semi-join on true comparisons and ALL to an anti-join on false or unknown comparisons."
+      "example": "SELECT r.amount FROM rows r WHERE r.amount = 3 OR r.amount > ALL (SELECT q.amount FROM rows q WHERE q.region = r.region)",
+      "notes": "Top-level WHERE uses semi/anti joins. Nested expressions group true, false, unknown, and empty-set counts per distinct outer probe tuple."
     },
     {
       "id": "cte.recursive",
@@ -536,11 +554,46 @@
       "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."
     },
+    {
+      "id": "window.frame-range-offset",
+      "status": "unsupported",
+      "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."
+    },
+    {
+      "id": "window.distinct-aggregate",
+      "status": "unsupported",
+      "example": "SELECT SUM(DISTINCT amount) OVER (PARTITION BY region) AS total FROM rows",
+      "error": "DISTINCT window aggregates are not supported",
+      "notes": "An aggregate used as a window function cannot take DISTINCT; PostgreSQL rejects this form too. DISTINCT aggregates work in grouped aggregation, so aggregate in a grouped block and window over that."
+    },
+    {
+      "id": "window.outside-select",
+      "status": "unsupported",
+      "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."
+    },
     {
       "id": "join.right",
       "status": "supported",
       "example": "SELECT r.region FROM rows r RIGHT JOIN dims d ON d.region = r.region",
-      "notes": "Desugars to the mirrored LEFT JOIN; supported as the sole join of a block."
+      "notes": "Desugars to the mirrored LEFT JOIN; supported as the sole join of a block, and not beside SELECT *."
+    },
+    {
+      "id": "join.right-multi",
+      "status": "unsupported",
+      "example": "SELECT r.region FROM rows r JOIN dims d ON d.region = r.region RIGHT JOIN dims e ON e.region = r.region",
+      "error": "RIGHT JOIN is only supported as the sole join",
+      "notes": "RIGHT JOIN desugars by swapping the two sides of a LEFT JOIN, which needs the block to hold exactly one join. Rewrite the block so the preserved side is on the left of a LEFT JOIN."
+    },
+    {
+      "id": "join.right-wildcard",
+      "status": "unsupported",
+      "example": "SELECT * FROM rows r RIGHT JOIN dims d ON d.region = r.region",
+      "error": "RIGHT JOIN cannot be combined with SELECT *",
+      "notes": "The desugaring swaps the two sources, which would reorder a wildcard's output columns. Name the output columns explicitly, or write the mirrored LEFT JOIN."
     },
     {
       "id": "join.non-equi",
@@ -740,7 +793,14 @@
       "id": "join.full",
       "status": "supported",
       "example": "SELECT r.amount AS amount, d.label AS label FROM rows r FULL JOIN dims d ON d.region = r.region",
-      "notes": "Desugars into a union of two left joins, so it must be the sole join, with an equality ON and no grouping or DISTINCT yet."
+      "notes": "Desugars into a union of two left joins, so it must be the sole join, with an equality ON, named output columns rather than SELECT *, and no grouping, DISTINCT, or window functions yet."
+    },
+    {
+      "id": "join.full-grouped",
+      "status": "unsupported",
+      "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."
     },
     {
       "id": "order-by.ordinal",
@@ -1197,7 +1257,7 @@
       "id": "aggregate.json",
       "status": "supported",
       "example": "SELECT JSON_ARRAYAGG(JSON_OBJECT('region' VALUE region)) AS regions FROM rows",
-      "notes": "Supports DISTINCT, embeds JSON-producing inputs as documents, includes SQL NULL as JSON null, and returns NULL for empty input. FILTER, window use, aggregate-local ORDER BY, and explicit NULL/ABSENT clauses are not supported; input order is otherwise unspecified."
+      "notes": "Supports DISTINCT and aggregate-local ORDER BY, embeds JSON-producing inputs as documents, includes SQL NULL as JSON null, and returns NULL for empty input. FILTER, window use, and explicit NULL/ABSENT clauses are not supported; input order is unspecified without ORDER BY."
     },
     {
       "id": "type.array",
@@ -1254,6 +1314,14 @@
       "setup": ["CREATE TABLE parents (id INTEGER PRIMARY KEY, label TEXT NOT NULL)"],
       "example": "CREATE TABLE children (id INTEGER PRIMARY KEY, parent INTEGER REFERENCES parents(id) ON DELETE CASCADE)",
       "notes": "Scalar and composite references target the parent's matching primary-key columns. Writes validate against their transaction; NULL references are satisfied. ON DELETE supports RESTRICT, CASCADE, and SET NULL atomically. Primary keys are immutable, so ON UPDATE has no action."
+    },
+    {
+      "id": "ddl.foreign-key-set-default",
+      "status": "unsupported",
+      "setup": ["CREATE TABLE default_parents (id INTEGER PRIMARY KEY, label TEXT NOT NULL)"],
+      "example": "CREATE TABLE default_children (id INTEGER PRIMARY KEY, parent INTEGER REFERENCES default_parents(id) ON DELETE SET DEFAULT)",
+      "error": "SET DEFAULT is not supported; use SET NULL or CASCADE",
+      "notes": "SET DEFAULT would rewrite orphaned references to the column's default value at delete time; Minnow implements RESTRICT, CASCADE, and SET NULL. The statement is rejected at parse, before touching the catalog."
     }
   ]
 }