@minnowdb/core 0.6.4 → 0.6.6

package/dist/storage/toolkit/index.d.ts

@@ -26,4 +26,4 @@ export { readFully, writeFully, type SyncFileHandle } from "./sync-file.js";
 export { RecordCore, type PhysicalBlocks, type RecordCoreState } from "./record-core.js";
 export { MAX_WAL_FRAME_BYTES, WalWriter, iterateWalFrames, replayWalFrames, type ReplayedWalFrame, } from "./wal.js";
 export { ExtentPool, assertValidExtentMeta, assertValidPlacement, extentPath, validPlacement, type ExtentBatchMark, type ExtentFiles, type ExtentMeta, type ExtentPoolOptions, type Placement, } from "./extents.js";
-export { LOG_FORMAT_VERSION, decodeChunk, decodePostingChunk, decodeRecordJson, decodeSyncCheckpoint, encodeChunk, encodePostingChunk, encodeRecordJson, encodeSyncCheckpoint, } from "./wire.js";
+export { LOG_FORMAT_VERSION, decodeChunk, decodePostingChunk, decodeRecordJson, decodeSyncCheckpoint, encodeChunk, encodePostingChunk, encodeRecordJson, encodeSyncCheckpoint, type PostingChunkEntry, } from "./wire.js";

package/dist/storage/toolkit/record-core.d.ts

@@ -373,7 +373,6 @@ export declare function validateFtsPostingChunks(chunks: unknown, label: string)
 export declare function validateSegmentRuntimeRecord(value: unknown, label: string): SegmentRecord;
 export declare function validateAutoIncrementReservation(count: number, atLeast: bigint | undefined): void;
 export declare function validateBeginTransactionInput(input: BeginTransactionInput): void;
-export declare function validateLeaseExpiration(expiresAt: string): void;
 export declare function validateTempRunPage(page: TempRunPage): void;
 export declare function validateTempRunPageIdentity(ownerId: string, runId: string, pageIndex: number): void;
 export {};

package/dist/storage/toolkit/record-core.js

@@ -6382,13 +6382,6 @@ function validateTempOwnerRecord(record) {
         throw new RangeError("Temp owner record must be created at revision zero");
     }
 }
-export function validateLeaseExpiration(expiresAt) {
-    if (typeof expiresAt !== "string" ||
-        expiresAt.length === 0 ||
-        !Number.isFinite(Date.parse(expiresAt))) {
-        throw new TypeError("Lease expiration must be valid");
-    }
-}
 function isCanonicalTimestamp(value) {
     const timestamp = Date.parse(value);
     return Number.isFinite(timestamp) && dateIsoString(new Date(timestamp)) === value;

package/dist/testing/opfs-shim.d.ts

@@ -21,7 +21,7 @@
  * toolkit's `SyncFileHandle` surface, in plain vitest, with crashes and quota failures on tap.
  */
 export type WriteFault = (path: string, phase: "create" | "write" | "flush") => void;
-export type DeleteFault = (path: string) => void;
+type DeleteFault = (path: string) => void;
 export type TransferLimit = (path: string, operation: "read" | "write", requestedBytes: number, at: number) => number | undefined;
 export declare class MemoryOpfs {
     #private;
@@ -43,3 +43,4 @@ export declare class MemoryOpfs {
     /** Test-side in-place corruption: existing sync handles observe the changed byte. */
     corruptFileByte(path: string, offset: number): void;
 }
+export {};

package/dist/testing/simulator.js

@@ -572,6 +572,9 @@ function summarizeCollection(result) {
         retainedTransactions: result.retainedTransactionCount,
     };
 }
+// Stream-identical copy of `mulberry32` in ./seeds.ts. This module ships in the tarball and
+// seeds.ts does not (it reads MINNOW_SEED and the unpublished regression-seeds.json), so the
+// published simulator cannot import the canonical copy.
 function mulberry32(seed) {
     let state = seed >>> 0;
     return () => {

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

@@ -1,7 +1,7 @@
 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";
+export type WorkerOperation = "benchmark" | "cancelBenchmark" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
 export interface WorkerRequest<T = unknown> {
     version: typeof protocolVersion;
     requestId: string;

package/dist/worker-protocol/index.js

@@ -105,7 +105,6 @@ function isOperation(value) {
     return [
         "benchmark",
         "cancelBenchmark",
-        "memorySample",
         "datasetList",
         "datasetCreate",
         "datasetDelete",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "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",
@@ -125,6 +125,7 @@
     "!dist/storage/fixture-shape.*",
     "!dist/engine/storage-test-helpers.*",
     "!dist/testing/seeds.*",
+    "!dist/testing/oracle.*",
     "!dist/*.tsbuildinfo",
     "sql-feature-matrix.json",
     "postgres-feature-profile.json"

package/postgres-feature-profile.json

@@ -111,7 +111,7 @@
     {
       "id": "function.string-extended",
       "classification": "different",
-      "reason": "The bundled form includes INSTR; PostgreSQL spells that function strpos with reversed arguments."
+      "reason": "The bundled form includes INSTR; PostgreSQL has no INSTR and spells the same (string, substring) lookup STRPOS, with the arguments in the same order."
     },
     {
       "id": "function.trim-multi-character",
@@ -134,10 +134,15 @@
       "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": "literal.scientific",
+      "classification": "different",
+      "reason": "PostgreSQL types every scientific-notation constant NUMERIC and renders it as text. Minnow evaluates it exactly but returns a number whenever the value reads back identically from one, keeping ordinary constants number-typed at the JavaScript boundary; a constant that stays exact renders fully expanded, as PostgreSQL renders it."
+    },
     {
       "id": "type.exact-numeric",
       "classification": "different",
-      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings; PGlite's default decoder returns this NUMERIC value as a number."
+      "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."
     },
     {
       "id": "type.json-jsonb",
@@ -164,6 +169,16 @@
       "classification": "different",
       "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
     },
+    {
+      "id": "json.arrow",
+      "classification": "different",
+      "reason": "The JSON value agrees, but Minnow returns compact JSON text at the JavaScript boundary while PostgreSQL clients commonly decode the json result natively. Minnow's parameters carry JavaScript types, so an integer parameter key selects an array element directly where an untyped PostgreSQL placeholder resolves to the text-key operator and needs an explicit ::int cast. Minnow's JSON values also compare as their canonical text, so -> results are valid comparison operands where PostgreSQL has no json = json operator."
+    },
+    {
+      "id": "json.arrow-untyped",
+      "classification": "extension",
+      "reason": "PostgreSQL requires a json-typed document for -> and ->>; Minnow also accepts ordinary JSON text directly, as its SQL/JSON functions do."
+    },
     {
       "id": "json.object",
       "classification": "different",
@@ -172,7 +187,7 @@
     {
       "id": "json.array",
       "classification": "different",
-      "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
+      "reason": "Minnow defaults JSON_ARRAY to NULL ON NULL, so a NULL argument becomes a JSON null where PostgreSQL's ABSENT ON NULL default drops it; Minnow also returns compact JSON text while PostgreSQL's rendering includes spaces."
     },
     {
       "id": "trigger.create-after",

package/sql-feature-matrix.json

@@ -676,7 +676,7 @@
         "CREATE TABLE stats (region TEXT UNIQUE, total REAL)",
         "INSERT INTO stats (region, total) VALUES ('east', 0), ('west', 0)"
       ],
-      "notes": "UPDATE and DELETE trigger bodies run against keyed tables, reading current state each firing. Touching the same target row twice in one firing is rejected."
+      "notes": "UPDATE and DELETE trigger bodies run against keyed tables, reading current state each firing. One body statement touching the same target row for two triggering rows in one firing is rejected; separate body statements may each touch that row."
     },
     {
       "id": "trigger.drop",
@@ -700,7 +700,7 @@
       "id": "expression.concat",
       "status": "supported",
       "example": "SELECT region || '-' || label AS tag FROM dims",
-      "notes": "|| concatenates strings and propagates NULL; non-string operands are a type error."
+      "notes": "|| concatenates strings and propagates NULL; non-string operands are a type error. One operand must be ordinary text, matching PostgreSQL's operator resolution: array and JSONB || are structural concatenation (see array.concat and json.concat), and two non-text domain operands have no || operator. A domain value concatenated with text renders in its Minnow text form."
     },
     {
       "id": "expression.modulo",
@@ -730,7 +730,7 @@
       "id": "expression.coalesce",
       "status": "supported",
       "example": "SELECT COALESCE(region, 'unknown') AS region_label FROM rows",
-      "notes": "Arguments evaluate left to right; the first non-NULL value wins. All non-NULL arguments must share one type."
+      "notes": "Arguments evaluate left to right; the first non-NULL value wins. Arguments are not type-checked: mixed-type arguments are accepted and return the first non-NULL value as-is, where PostgreSQL requires a common type."
     },
     {
       "id": "expression.date-trunc",
@@ -958,7 +958,7 @@
       "id": "datetime.localtime",
       "status": "supported",
       "example": "SELECT LOCALTIME IS NOT NULL AS ticking",
-      "notes": "The engine has no TIME type, so LOCALTIME reads as an 'HH:MM:SS' string, like SQLite's CURRENT_TIME."
+      "notes": "LOCALTIME reads as an 'HH:MM:SS' string of the current UTC time, like SQLite's CURRENT_TIME — Minnow has no session time zone, where PostgreSQL renders the session-local wall clock."
     },
     {
       "id": "predicate.row-comparison",
@@ -985,6 +985,24 @@
       "status": "supported",
       "example": "SELECT 1_000 AS thousand"
     },
+    {
+      "id": "literal.exact-decimal",
+      "status": "supported",
+      "example": "SELECT 1.000000000000000000000000 / 3 = CAST('0.333333333333333333333333' AS NUMERIC) AS exact_thirds",
+      "notes": "Decimal constants keep their exact digits, as PostgreSQL's NUMERIC typing does. Arithmetic among constants is exact — 0.1 + 0.2 is 0.3 — and a quotient's scale follows the operands' written scales. A result that reads back identically from a JavaScript number is returned as a number; one the number boundary would visibly round is returned as an exact decimal string."
+    },
+    {
+      "id": "literal.big-integer",
+      "status": "supported",
+      "example": "SELECT 10000000000000000001 = CAST('10000000000000000001' AS NUMERIC) AS same",
+      "notes": "An integer constant beyond 2^53 stays exact instead of rounding or failing. A value Float64 cannot hold is returned as a decimal string, and writing one to an INTEGER or BIGINT column is rejected rather than silently rounded."
+    },
+    {
+      "id": "literal.scientific",
+      "status": "supported",
+      "example": "SELECT 2.5e-1 AS quarter",
+      "notes": "Scientific notation is a numeric constant, as in PostgreSQL. PostgreSQL renders every such constant as NUMERIC text; Minnow returns a number when the value reads back identically from one, and renders a constant that stays exact fully expanded, as PostgreSQL renders it."
+    },
     {
       "id": "limit.with-ties",
       "status": "supported",
@@ -1075,7 +1093,31 @@
       "id": "json.array",
       "status": "supported",
       "example": "SELECT JSON_ARRAY(1, NULL, 2) AS document",
-      "notes": "Defaults to NULL ON NULL. The explicit NULL/ABSENT clause is not supported. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
+      "notes": "Defaults to NULL ON NULL, unlike PostgreSQL's ABSENT ON NULL default for JSON_ARRAY. The explicit NULL/ABSENT clause is not supported. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
+    },
+    {
+      "id": "json.arrow",
+      "status": "supported",
+      "example": "SELECT CAST('{\"a\": {\"b\": [5, 6]}}' AS JSON) -> 'a' -> 'b' -> 1 AS element",
+      "notes": "PostgreSQL's -> member/element access, chainable and usable anywhere an expression is. A text key selects an object member; an integer key selects an array element. The result is a JSON value, so a selected string keeps its quotes and a selected JSON null stays the document null. Behaviour follows the json type: a document of the wrong shape for the key selects NULL, without jsonb's scalar-as-one-element-array reading. A document that is not JSON is an error, matching the operators' typed-json requirement."
+    },
+    {
+      "id": "json.arrow-text",
+      "status": "supported",
+      "example": "SELECT CAST('{\"items\": [\"x\", \"y\"]}' AS JSON) -> 'items' ->> 0 AS first_item",
+      "notes": "->> returns text: strings unquoted, other scalars as their JSON rendering, objects and arrays serialized as compact JSON text, and a selected JSON null as SQL NULL."
+    },
+    {
+      "id": "json.arrow-index",
+      "status": "supported",
+      "example": "SELECT CAST('[\"x\", \"y\", \"z\"]' AS JSON) ->> -1 AS last_item",
+      "notes": "Negative element positions count from the end of the array; positions out of range in either direction select NULL."
+    },
+    {
+      "id": "json.arrow-untyped",
+      "status": "supported",
+      "example": "SELECT '{\"a\": {\"b\": [\"x\", \"y\"]}}' -> 'a' -> 'b' ->> 1 AS second_item",
+      "notes": "Like Minnow's SQL/JSON functions, the arrows accept ordinary JSON text and stored JSON/JSONB values directly; PostgreSQL requires a json-typed document to resolve the operator."
     },
     {
       "id": "ddl.create-table-if-not-exists",
@@ -1114,7 +1156,7 @@
       "id": "type.exact-numeric",
       "status": "supported",
       "example": "SELECT CAST(1.25 AS DECIMAL(12, 2)) AS amount",
-      "notes": "Exact through storage, arithmetic, comparison, aggregates, and windows. Division retains 20 fractional digits."
+      "notes": "Exact through storage, arithmetic, comparison, aggregates, and windows. Division selects its result scale the way PostgreSQL does: at least sixteen significant digits, never fewer fractional digits than either operand, rounded half away from zero."
     },
     {
       "id": "type.json-jsonb",
@@ -1131,8 +1173,15 @@
     {
       "id": "type.interval",
       "status": "supported",
-      "example": "SELECT CAST('1 day' AS INTERVAL) AS span",
-      "notes": "Preserves separate month, day, and microsecond fields. Interval arithmetic is not yet exposed."
+      "example": "SELECT joined + INTERVAL '1 day' AS next_day FROM rows",
+      "notes": "Preserves separate month, day, and microsecond fields, and a date or datetime accepts + and - INTERVAL. Interval-valued arithmetic is not supported (see type.interval-arithmetic)."
+    },
+    {
+      "id": "type.interval-arithmetic",
+      "status": "unsupported",
+      "example": "SELECT INTERVAL '1 day' + INTERVAL '2 hours' AS total",
+      "error": "Date arithmetic requires a date or datetime value",
+      "notes": "PostgreSQL adds intervals into a combined interval and subtracts timestamps into an interval. Minnow's interval arithmetic only shifts a date or datetime by + or - INTERVAL, so an interval-valued result is refused."
     },
     {
       "id": "ddl.enum",
@@ -1239,7 +1288,14 @@
       "id": "json.table",
       "status": "supported",
       "example": "SELECT j.a FROM JSON_TABLE('{\"a\":1}', '$' COLUMNS (a INTEGER PATH '$.a')) AS j",
-      "notes": "Constant documents support $ and $[*] row paths. Correlated documents are not yet supported."
+      "notes": "Constant documents support $ and $[*] row paths. A document read from row data is refused (see json.table-correlated)."
+    },
+    {
+      "id": "json.table-correlated",
+      "status": "unsupported",
+      "example": "SELECT jt.v FROM (SELECT '[1,2]' AS document) AS d, JSON_TABLE(d.document, '$[*]' COLUMNS (v INTEGER PATH '$')) AS jt",
+      "error": "JSON_TABLE currently requires a constant document",
+      "notes": "PostgreSQL evaluates JSON_TABLE laterally against each source row's document. Minnow expands only constant documents, so a column-valued document is refused at compile time."
     },
     {
       "id": "predicate.similar-to",
@@ -1263,7 +1319,35 @@
       "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 yet supported."
+      "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)."
+    },
+    {
+      "id": "type.array-subscript",
+      "status": "unsupported",
+      "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."
+    },
+    {
+      "id": "type.array-any",
+      "status": "unsupported",
+      "example": "SELECT 2 = ANY(ARRAY[1, 2, 3]) AS found",
+      "error": "ANY/ALL take a subquery",
+      "notes": "PostgreSQL's ANY, ALL, and SOME accept an array operand as well as a subquery. Minnow implements only the subquery form, so the array variant is refused at compile time."
+    },
+    {
+      "id": "array.concat",
+      "status": "unsupported",
+      "example": "SELECT ARRAY[1, 2] || ARRAY[3] AS combined",
+      "error": "PostgreSQL array concatenation (||) is not supported",
+      "notes": "PostgreSQL's array || array and array || element are structural concatenation. Minnow refuses || whenever either operand is an array rather than inventing a text concatenation PostgreSQL does not have."
+    },
+    {
+      "id": "json.concat",
+      "status": "unsupported",
+      "example": "SELECT CAST('{\"a\":1}' AS JSONB) || CAST('{\"b\":2}' AS JSONB) AS merged",
+      "error": "PostgreSQL JSONB concatenation (||) is not supported",
+      "notes": "PostgreSQL's jsonb || jsonb merges documents structurally. Minnow refuses || whenever either operand is JSONB rather than inventing a text concatenation PostgreSQL does not have."
     },
     {
       "id": "type.time",
@@ -1294,7 +1378,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 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."
+      "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 a definition that would create a cycle is rejected when the view is defined. CREATE VIEW column-name lists are not supported."
     },
     {
       "id": "ddl.drop-view",