@minnowdb/core 0.5.0 → 0.6.1

package/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 2;
+export declare const protocolVersion: 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type WorkerOperation = "benchmark" | "cancelBenchmark" | "memorySample" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
@@ -46,6 +46,11 @@ export type RpcRequest = {
     handleId: string | null;
     method: string;
     args: unknown[];
+} | {
+    version: typeof protocolVersion;
+    /** The request whose work should stop. Cancellation has no response frame of its own. */
+    requestId: string;
+    kind: "rpc-cancel";
 };
 export type RpcResponse = {
     version: typeof protocolVersion;

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-export const protocolVersion = 2;
+export const protocolVersion = 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export function parseRequest(value) {
@@ -64,8 +64,11 @@ export function parseRpcRequest(value) {
     if (typeof value !== "object" || value === null)
         return null;
     const candidate = value;
-    if (candidate.kind !== "rpc-init" && candidate.kind !== "rpc-call")
+    if (candidate.kind !== "rpc-init" &&
+        candidate.kind !== "rpc-call" &&
+        candidate.kind !== "rpc-cancel") {
         return null;
+    }
     if (candidate.version !== protocolVersion)
         throw new Error("Unsupported protocol version");
     if (typeof candidate.requestId !== "string" || candidate.requestId.length === 0) {

package/package.json

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

@@ -1,5 +1,5 @@
 {
-  "version": 4,
+  "version": 5,
   "description": "Executable PostgreSQL compatibility examples for MinnowDatabase. postgres-feature-profile.json records differences, extensions, and embedded exclusions.",
   "features": [
     {
@@ -20,7 +20,8 @@
     {
       "id": "select.distinct",
       "status": "supported",
-      "example": "SELECT DISTINCT region FROM rows"
+      "example": "SELECT DISTINCT region FROM rows",
+      "notes": "Plain projections and SELECT DISTINCT * are supported. DISTINCT combined with grouping, HAVING, or aggregate/window expressions is rejected."
     },
     {
       "id": "select.scalar-subquery",
@@ -127,7 +128,7 @@
       "id": "group-by.rollup",
       "status": "supported",
       "example": "SELECT region, SUM(amount) AS total FROM rows GROUP BY ROLLUP(region)",
-      "notes": "ROLLUP/CUBE/GROUPING SETS desugar into a UNION ALL of grouped blocks. The GROUPING() marker is deliberately unsupported, so rollup NULLs and data NULLs are indistinguishable. SQLite itself has none of these."
+      "notes": "ROLLUP/CUBE/GROUPING SETS desugar into a UNION ALL of grouped blocks. GROUPING() distinguishes rolled-up columns from data NULLs. SQLite itself has none of these."
     },
     {
       "id": "group-by.grouping-sets",
@@ -245,7 +246,7 @@
       "id": "mutation.update-keyed",
       "status": "supported",
       "example": "UPDATE keyed SET score = score + 1 WHERE score > 0",
-      "notes": "Requires a unique-key table; read-then-mutate, not serializable."
+      "notes": "Requires a unique-key table. A standalone statement reads and publishes inside one retryable write scope; an explicit transaction stages it with the transaction's other statements."
     },
     {
       "id": "mutation.delete-keyed",
@@ -256,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",
@@ -316,7 +317,7 @@
       "id": "predicate.quantified",
       "status": "supported",
       "example": "SELECT region FROM rows WHERE amount > ALL (SELECT amount FROM dims)",
-      "notes": "ANY/SOME/ALL with full three-valued logic; correlated forms are rejected. 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",
@@ -387,30 +388,85 @@
       "id": "subquery.correlated",
       "status": "supported",
       "example": "SELECT region FROM rows r WHERE amount > (SELECT AVG(amount) FROM rows q WHERE q.region = r.region)",
-      "notes": "Equality-correlated subqueries decorrelate into derived-table joins at compile time; both executors run plain joins."
+      "notes": "Correlated subqueries decorrelate into derived-table joins at compile time; both executors run plain joins."
     },
     {
       "id": "subquery.correlated-exists",
       "status": "supported",
       "example": "SELECT amount FROM rows r WHERE EXISTS (SELECT region FROM dims d WHERE d.region = r.region)",
-      "notes": "EXISTS joins the subquery's distinct correlation keys; NOT EXISTS becomes a left join checked with IS NULL."
+      "notes": "Top-level EXISTS and NOT EXISTS lower to semi-joins and anti-joins. Nested boolean forms use hidden per-probe match flags."
     },
     {
       "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 too, outside grouped queries."
+      "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",
+      "status": "supported",
+      "example": "SELECT r.region, COUNT(*) AS c, (SELECT AVG(q.amount) FROM rows q WHERE q.region = r.region) AS regional FROM rows r GROUP BY r.region",
+      "notes": "The decorrelated value is functionally determined by the outer grouping keys and is carried as an internal group key."
+    },
+    {
+      "id": "subquery.correlated-scalar-non-equi",
+      "status": "supported",
+      "example": "SELECT r.amount, (SELECT COUNT(*) FROM rows q WHERE q.amount < r.amount) AS lower_count FROM rows r",
+      "notes": "Non-equality scalar aggregates group inner rows once per distinct outer probe tuple, then join the result back by equality."
+    },
+    {
+      "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 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",
       "status": "supported",
       "example": "SELECT r.amount FROM rows r WHERE EXISTS (SELECT q.amount FROM rows q WHERE q.amount < r.amount)",
-      "notes": "Non-equality EXISTS and NOT EXISTS correlations lower to semi-joins and anti-joins; correlated scalar aggregates and IN remain equality-only."
+      "notes": "Non-equality EXISTS and NOT EXISTS correlations lower to semi-joins and anti-joins. Scalar aggregates use distinct outer probes."
+    },
+    {
+      "id": "subquery.correlated-in-non-equi",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE r.region IN (SELECT q.region FROM rows q WHERE q.amount < r.amount)",
+      "notes": "A range-correlated IN predicate lowers to a semi-join carrying both its correlation and membership comparisons."
     },
     {
       "id": "subquery.correlated-not-in",
       "status": "supported",
-      "example": "SELECT region FROM rows r WHERE region NOT IN (SELECT d.region FROM dims d WHERE d.region = r.region)"
+      "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",
+      "example": "SELECT r.amount FROM rows r WHERE 'north' NOT IN (SELECT q.region FROM rows q WHERE q.amount < r.amount)",
+      "notes": "Range correlation uses an anti-join for exact matches plus per-probe total and non-NULL counts."
+    },
+    {
+      "id": "subquery.correlated-quantified",
+      "status": "supported",
+      "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",
@@ -456,13 +512,13 @@
       "id": "aggregate.filter",
       "status": "supported",
       "example": "SELECT region, COUNT(*) FILTER (WHERE amount > 5) AS big FROM rows GROUP BY region",
-      "notes": "Desugars into a CASE inside the aggregate, so it works with every aggregate and DISTINCT."
+      "notes": "Desugars into a CASE inside COUNT/SUM/AVG/MIN/MAX and preserves DISTINCT. JSON_ARRAYAGG does not support FILTER."
     },
     {
       "id": "window.aggregate-over",
       "status": "supported",
       "example": "SELECT SUM(amount) OVER (PARTITION BY region) AS total FROM rows",
-      "notes": "Default frame only: whole partition without OVER ordering, running with peers when ordered."
+      "notes": "Without explicit framing, the default is the whole partition when unordered and a peer-aware running frame when ordered. ROWS, RANGE, GROUPS, and exclusions are tracked separately below."
     },
     {
       "id": "window.in-expression",
@@ -569,7 +625,7 @@
       "id": "trigger.create-after",
       "status": "supported",
       "example": "CREATE TRIGGER keyed_audit AFTER INSERT ON keyed BEGIN INSERT INTO rows (region, amount) VALUES (NEW.name, NEW.score); END",
-      "notes": "AFTER and BEFORE row triggers on INSERT/UPDATE/DELETE, executed atomically inside the triggering commit with NEW/OLD references. Bodies: INSERT ... VALUES into keyless tables; UPDATE/DELETE against keyed tables. One cascade level is allowed; deeper chains error at write time."
+      "notes": "AFTER and BEFORE row triggers on INSERT/UPDATE/DELETE execute atomically with NEW/OLD references. Bodies support parameter-free INSERT ... VALUES into keyless tables and UPDATE/DELETE against keyed tables; ON CONFLICT and RETURNING are rejected. One cascade level is allowed."
     },
     {
       "id": "trigger.create-before",
@@ -970,8 +1026,8 @@
     {
       "id": "json.object",
       "status": "supported",
-      "example": "SELECT JSON_OBJECT('a' VALUE 1, 'missing' VALUE NULL) AS document",
-      "notes": "Defaults to NULL ON NULL and WITHOUT UNIQUE KEYS. NULL keys are rejected. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
+      "example": "SELECT JSON_OBJECT('a' VALUE 1, 'detail' VALUE JSON_OBJECT('name' VALUE 'Acme')) AS document",
+      "notes": "Defaults to NULL ON NULL and WITHOUT UNIQUE KEYS. NULL keys are rejected. JSON-producing arguments embed as documents rather than escaped strings; ordinary text remains a string. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
     },
     {
       "id": "json.array",
@@ -990,6 +1046,12 @@
       "example": "CREATE TABLE defaulted (id INTEGER PRIMARY KEY, tier TEXT DEFAULT 'basic')",
       "notes": "DEFAULT accepts a variable-free scalar expression. Omission or SQL DEFAULT invokes it; explicit NULL follows the column's independent nullability."
     },
+    {
+      "id": "ddl.generated-column",
+      "status": "supported",
+      "example": "CREATE TABLE generated_value (base INTEGER, doubled INTEGER GENERATED ALWAYS AS (base * 2) STORED)",
+      "notes": "Stored generated columns recompute on every write and may be indexed, but cannot be caller-assigned or used as Minnow's row-addressing primary/unique key. Expressions are immutable and row-local."
+    },
     {
       "id": "ddl.create-table-key-clause",
       "status": "supported",
@@ -1117,7 +1179,13 @@
       "id": "from.lateral",
       "status": "supported",
       "example": "SELECT x.amount FROM rows r, LATERAL (SELECT amount FROM dims WHERE dims.region = r.region) x",
-      "notes": "Equality-correlated derived sources become set-at-a-time joins. Correlated grouping, ordering, and LIMIT remain unsupported."
+      "notes": "Equality and range-correlated derived sources become set-at-a-time joins. Correlated grouping, ordering, and LIMIT remain unsupported."
+    },
+    {
+      "id": "from.lateral-non-equi",
+      "status": "supported",
+      "example": "SELECT x.amount FROM rows r, LATERAL (SELECT q.amount FROM rows q WHERE q.amount < r.amount) x",
+      "notes": "Non-equality correlation lowers to an ordinary general join rather than executing the derived source once per outer row."
     },
     {
       "id": "aggregate.string-agg",
@@ -1146,8 +1214,8 @@
     {
       "id": "aggregate.json",
       "status": "supported",
-      "example": "SELECT JSON_ARRAYAGG(region) AS regions FROM rows",
-      "notes": "Supports DISTINCT, 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."
+      "example": "SELECT JSON_ARRAYAGG(JSON_OBJECT('region' VALUE region)) AS regions FROM rows",
+      "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",
@@ -1184,7 +1252,7 @@
       "id": "ddl.create-view",
       "status": "supported",
       "example": "CREATE VIEW west AS SELECT region, amount FROM rows WHERE region = 'west'",
-      "notes": "The catalog stores the query text and the schema inferred from it, so a view answers the same questions a table does and reads expand it into the query it stands for — anywhere a read runs, including inside a write scope. A view is never a write target. CREATE OR REPLACE redefines one; a view stacked on it follows the new definition, and a cycle two redefinitions close is caught on the next read rather than recursed."
+      "notes": "The catalog stores the query text and inferred schema, so reads expand a view anywhere a table can be read, including inside a write scope. A view is never a write target. CREATE OR REPLACE redefines one; dependent views follow it and cycles are rejected on read. CREATE VIEW column-name lists are not supported."
     },
     {
       "id": "ddl.drop-view",