@minnowdb/core 0.6.1 → 0.6.3

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.1",
+  "version": "0.6.3",
   "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/sql-feature-matrix.json

@@ -554,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",
@@ -758,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",
@@ -1272,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."
     }
   ]
 }