@minnowdb/core 0.6.4 → 0.6.5

package/dist/engine/database.js

@@ -8847,28 +8847,44 @@ export class MinnowDatabase {
         const inputs = await this.#prepareBlockInputs(block, snapshot, visibility, memory, realTables, typedSchemas, extraInputs, cacheResults, allowSpill, forceSpill, spillPageRows, signal);
         throwIfAborted(signal);
         const prepared = createPreparedColumnarQuery(block, inputs, memory.createChild(), ftsStats === undefined ? {} : { ftsStats });
+        // The columnar preparation only knows vector kinds, so a plain domain column projects with a
+        // null domain. Catalog-backed inference fills those in — at miss time, because executing the
+        // block registered its nested synthetic sources in typedSchemas — so a substituted scalar or
+        // IN subquery literal carries its domain to the outer result (T694).
+        const withCatalogColumnDomains = (result) => {
+            if (!result.columnDomains.includes(null))
+                return result;
+            try {
+                const inferred = inferResultColumnDomains(block, typedSchemas);
+                result.columnDomains = result.columnDomains.map((domain, index) => domain ?? inferred[index] ?? null);
+            }
+            catch {
+                // A shape this schema registry cannot type keeps its expression-level domains.
+            }
+            return result;
+        };
         try {
             if (!allowSpill || memory.usage.budgetBytes === Number.MAX_SAFE_INTEGER) {
                 const result = prepared.execute();
                 throwIfAborted(signal);
-                return result;
+                return withCatalogColumnDomains(result);
             }
             if (!forceSpill) {
                 try {
                     const result = prepared.execute();
                     throwIfAborted(signal);
-                    return result;
+                    return withCatalogColumnDomains(result);
                 }
                 catch (error) {
                     if (!(error instanceof QueryMemoryBudgetError))
                         throw error;
                 }
             }
-            return await prepared.executeAsync({
+            return withCatalogColumnDomains(await prepared.executeAsync({
                 spillStore: this.#leasedSpillStore(),
                 ...(spillPageRows === undefined ? {} : { spillPageRows }),
                 ...(signal === undefined ? {} : { signal }),
-            });
+            }));
         }
         finally {
             prepared.close();

package/dist/engine/optimizer.js

@@ -2181,7 +2181,8 @@ function foldExpression(expression) {
                             ? { kind: targetWord }
                             : expression.name === "JSON_QUERY" ||
                                 expression.name === "JSON_OBJECT" ||
-                                expression.name === "JSON_ARRAY"
+                                expression.name === "JSON_ARRAY" ||
+                                expression.name === "MINNOW_JSON_GET"
                                 ? { kind: "json" }
                                 : undefined;
                     return {

package/dist/engine/query.js

@@ -6,10 +6,10 @@ import { cachedQueryTerms, ftsBm25Row, FtsStatsAccumulator, ftsMatchTruth, rende
 import { QueryMemoryContext } from "./memory.js";
 import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
 import { stringArgument } from "./sql-semantics.js";
-import { jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath } from "./sql-json.js";
+import { jsonArrowStep, jsonAtPath, jsonConstructor, jsonIsValid, parseJsonPath, } from "./sql-json.js";
 import { optimizePlan } from "./optimizer.js";
 import { compareSqlValues as compareValues, compileLikePattern, compileSimilarPattern, encodeSqlEqualityValue, roundSqlNumber, } from "./sql-semantics.js";
-import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
+import { arrayDomainValue, boundedJsonText, collatedDomainValue, dateDomainValue, exactNumericBinary, exactNumericValue, externalSqlDomainColumnValue, externalSqlDomainValue, intervalDomainValue, isDateDomainValue, isExactNumeric, isSqlDomainValue, jsonDomainValue, normalizeSqlDomainValue, preservedJsonDomainValue, protectedSqlTextValue, timeDomainValue, uuidDomainValue, } from "./sql-domains.js";
 import { columnarTableFromRows, prepareVectorQuery, } from "./vector.js";
 /** Domain metadata for an execution path that has no catalog-backed type information. */
 export function unknownColumnDomains(columns) {
@@ -62,6 +62,8 @@ export const scalarFunctionNames = new Set([
     "JSON_ARRAY",
     "IS_JSON",
     "ARRAY",
+    "MINNOW_JSON_GET",
+    "MINNOW_JSON_GET_TEXT",
     "MINNOW_TUPLE_KEY",
     "MINNOW_COLLATE",
     "NEXTVAL",
@@ -167,16 +169,20 @@ function castValue(value, target) {
             return protectedSqlTextValue(dateIsoString(value));
     }
     if (target === "number" || target === "number-integer") {
+        // Externalize first, exactly as the string and datetime targets do: a NUMERIC (or other
+        // domain) value is an internally tagged string, and CAST(numeric_column AS DOUBLE
+        // PRECISION) must read its decimal text, not fail on the tag (T703).
+        const external = externalSqlDomainValue(value);
         let parsed;
-        if (typeof value === "number")
-            parsed = value;
-        else if (typeof value === "boolean")
-            parsed = value ? 1 : 0;
-        else if (typeof value === "string") {
-            const text = value.trim();
+        if (typeof external === "number")
+            parsed = external;
+        else if (typeof external === "boolean")
+            parsed = external ? 1 : 0;
+        else if (typeof external === "string") {
+            const text = external.trim();
             const candidate = text === "" ? Number.NaN : Number(text);
             if (!Number.isFinite(candidate)) {
-                throw new TypeError(`Cannot cast this string to a number: ${value}`);
+                throw new TypeError(`Cannot cast this string to a number: ${text}`);
             }
             parsed = candidate;
         }
@@ -201,12 +207,13 @@ function castValue(value, target) {
             throw new TypeError(`Only 0 and 1 cast to boolean, got ${String(value)}`);
         }
         if (typeof value === "string") {
-            const text = value.trim().toLowerCase();
+            const external = externalSqlDomainValue(value);
+            const text = typeof external === "string" ? external.trim().toLowerCase() : "";
             if (text === "true" || text === "t" || text === "1")
                 return true;
             if (text === "false" || text === "f" || text === "0")
                 return false;
-            throw new TypeError(`Cannot cast this string to a boolean: ${value}`);
+            throw new TypeError(`Cannot cast this string to a boolean: ${typeof external === "string" ? external : value}`);
         }
     }
     if (target === "datetime") {
@@ -396,6 +403,27 @@ export function scalarFunctionValue(name, values) {
             // JSON_QUERY returns JSON text, so a selected string keeps its quotes.
             return preservedJsonDomainValue(JSON.stringify(found.value));
         }
+        case "MINNOW_JSON_GET": {
+            if (values[1] === null || values[1] === undefined)
+                return null;
+            const found = jsonArrowStep(first, values[1], "->");
+            if (!found.found)
+                return null;
+            // -> returns a JSON value: a selected string keeps its quotes, a JSON null is the
+            // one-character document "null" rather than SQL NULL, exactly as PostgreSQL has it.
+            return preservedJsonDomainValue(JSON.stringify(found.value));
+        }
+        case "MINNOW_JSON_GET_TEXT": {
+            if (values[1] === null || values[1] === undefined)
+                return null;
+            const found = jsonArrowStep(first, values[1], "->>");
+            // ->> returns text: strings unquoted, other scalars as their JSON rendering, objects
+            // and arrays serialized, and a JSON null as SQL NULL.
+            if (!found.found || found.value === null || found.value === undefined)
+                return null;
+            const value = found.value;
+            return protectedSqlTextValue(typeof value === "string" ? value : JSON.stringify(value));
+        }
         case "LPAD":
         case "RPAD": {
             if (values[1] === null || values[1] === undefined)
@@ -1314,6 +1342,22 @@ export function evaluateJoinedRowExpression(expression, rows) {
 export function evaluateRowExpression(expression, alias, row) {
     return asQueryValue(evaluate(expression, { [alias]: row }));
 }
+/**
+ * Wraps one value from an executed subquery block as a substituted literal. Block results are
+ * internal: domain values keep their tags and protected text keeps its wrapper. The literal must
+ * say so — an unmarked string literal is re-protected as user text at evaluation, which both
+ * leaks the internal tag into the outer result and makes equality against internal column
+ * values never match (T694: `WHERE amount = (SELECT amount ...)` on a NUMERIC column returned
+ * no rows). Carrying the block's column domain also keeps the outer result's domain metadata.
+ */
+function substitutedResultLiteral(value, sqlDomain) {
+    return {
+        kind: "literal",
+        value: value ?? null,
+        ...(typeof value === "string" ? { internalSqlValue: true } : {}),
+        ...(sqlDomain === null || sqlDomain === undefined ? {} : { sqlDomain }),
+    };
+}
 /**
  * Clones a plan and returns its subquery sites in post-order: executing each step's block and
  * substituting its result leaves the returned plan free of subquery nodes. A scalar subquery must
@@ -1338,10 +1382,7 @@ export function subqueryResolutionSteps(plan) {
                     if (result.rows.length > 1) {
                         throw new TypeError(`A scalar subquery returned ${String(result.rows.length)} rows`);
                     }
-                    replace({
-                        kind: "literal",
-                        value: result.rows[0]?.[result.columns[0] ?? ""] ?? null,
-                    });
+                    replace(substitutedResultLiteral(result.rows[0]?.[result.columns[0] ?? ""], result.columnDomains[0]));
                 },
             });
             return;
@@ -1412,10 +1453,7 @@ export function subqueryResolutionSteps(plan) {
                         }
                         expression.right = {
                             kind: "list",
-                            items: result.rows.map((row) => ({
-                                kind: "literal",
-                                value: row[result.columns[0] ?? ""] ?? null,
-                            })),
+                            items: result.rows.map((row) => substitutedResultLiteral(row[result.columns[0] ?? ""], result.columnDomains[0])),
                         };
                     },
                 });
@@ -1458,10 +1496,7 @@ export function subqueryResolutionSteps(plan) {
                         }
                         predicate.right = {
                             kind: "list",
-                            items: result.rows.map((row) => ({
-                                kind: "literal",
-                                value: row[result.columns[0] ?? ""] ?? null,
-                            })),
+                            items: result.rows.map((row) => substitutedResultLiteral(row[result.columns[0] ?? ""], result.columnDomains[0])),
                         };
                     },
                 });
@@ -1886,7 +1921,8 @@ export function inferBlockSchema(plan, schemas) {
         if (expression.name === "JSON_ARRAYAGG" ||
             expression.name === "JSON_QUERY" ||
             expression.name === "JSON_OBJECT" ||
-            expression.name === "JSON_ARRAY") {
+            expression.name === "JSON_ARRAY" ||
+            expression.name === "MINNOW_JSON_GET") {
             return { kind: "json" };
         }
         if (expression.name === "GEN_RANDOM_UUID")
@@ -2025,6 +2061,8 @@ export function inferBlockSchema(plan, schemas) {
             expression.name === "JSON_OBJECT" ||
             expression.name === "JSON_ARRAY" ||
             expression.name === "ARRAY" ||
+            expression.name === "MINNOW_JSON_GET" ||
+            expression.name === "MINNOW_JSON_GET_TEXT" ||
             expression.name === "MINNOW_TUPLE_KEY" ||
             expression.name === "MINNOW_COLLATE" ||
             expression.name === "GEN_RANDOM_UUID") {
@@ -4478,9 +4516,6 @@ function asQueryValue(value) {
         return null;
     throw new TypeError("Query produced an unsupported value");
 }
-function asExternalQueryValue(value) {
-    return asQueryValue(externalSqlDomainValue(value));
-}
 const alreadyExternalResults = new WeakSet();
 function markExternalizationState(result, outputNeedsExternalization) {
     if (outputNeedsExternalization === false)
@@ -4505,11 +4540,12 @@ export function externalizeQueryResult(result) {
         // Ordinary primitive results are already public values. Most queries never touch one of the
         // tagged PostgreSQL domains, so keep their row objects and avoid rebuilding a large result
         // set merely to discover that every value is unchanged.
-        for (const name of result.columns) {
+        for (let position = 0; position < result.columns.length; position += 1) {
+            const name = result.columns[position] ?? "";
             const value = row[name];
             if (value !== undefined && !isSqlDomainValue(value))
                 continue;
-            const external = asExternalQueryValue(value);
+            const external = asQueryValue(externalSqlDomainColumnValue(value, result.columnDomains[position]));
             if (external === value)
                 continue;
             if (output === row)
@@ -6896,17 +6932,36 @@ class Parser {
                 continue;
             }
             const operator = this.#peek().text;
-            // || binds loosest, matching PostgreSQL: concatenation applies to whole arithmetic terms.
+            // || and the JSON arrows share PostgreSQL's loosest "any other operator" level, applying
+            // left-to-right to whole arithmetic terms: `'a' || d ->> 'k'` is `('a' || d) ->> 'k'`.
             const precedence = operator === "*" || operator === "/" || operator === "%"
                 ? 20
                 : operator === "+" || operator === "-"
                     ? 10
-                    : operator === "||"
+                    : operator === "||" || operator === "->" || operator === "->>"
                         ? 5
                         : -1;
             if (precedence < minimumPrecedence)
                 break;
             this.#index += 1;
+            if (operator === "->" || operator === "->>") {
+                const key = this.#additive(precedence + 1);
+                // A key fixed at compile time fails here rather than per row, like SQL/JSON paths.
+                if (key.kind === "literal" && typeof key.value === "number") {
+                    if (!Number.isInteger(key.value)) {
+                        throw new TypeError(`${operator} array positions are integers`);
+                    }
+                }
+                else if (key.kind === "literal" && typeof key.value === "boolean") {
+                    throw new TypeError(`${operator} keys are member names or array positions`);
+                }
+                left = {
+                    kind: "call",
+                    name: operator === "->" ? "MINNOW_JSON_GET" : "MINNOW_JSON_GET_TEXT",
+                    arguments: [left, key],
+                };
+                continue;
+            }
             // `placed_at + INTERVAL '1 month'`. An interval is not a value any column can hold, so it
             // never becomes an expression of its own: it is read here, where the thing it applies to is
             // already in hand, and folds into the date arithmetic DATE_ADD performs.
@@ -7380,7 +7435,9 @@ class Parser {
             const name = (upper === "ANY_VALUE" ? "MIN" : (functionSpellings.get(upper) ?? upper));
             if (name === "MINNOW_TUPLE_KEY" ||
                 name === "MINNOW_COLLATE" ||
-                name === "MINNOW_SINGLE_VALUE") {
+                name === "MINNOW_SINGLE_VALUE" ||
+                name === "MINNOW_JSON_GET" ||
+                name === "MINNOW_JSON_GET_TEXT") {
                 throw new TypeError(`Unsupported function: ${identifier}`);
             }
             if (!aggregateNames.has(name) && !scalarFunctionNames.has(name))
@@ -9022,7 +9079,12 @@ function tokenize(sql) {
             index += 1;
             continue;
         }
-        if ([">=", "<=", "!=", "<>", "||"].includes(pair)) {
+        if (pair === "->" && sql[index + 2] === ">") {
+            push({ kind: "operator", text: "->>", start: index, end: index + 3 });
+            index += 3;
+            continue;
+        }
+        if ([">=", "<=", "!=", "<>", "||", "->"].includes(pair)) {
             push({ kind: "operator", text: pair, start: index, end: index + 2 });
             index += 2;
             continue;

package/dist/engine/sql-domains.d.ts

@@ -38,5 +38,14 @@ export declare function enumDomainCompare(left: unknown, right: unknown): number
 export declare function normalizeSqlDomainValue(domain: SqlDomain, value: unknown): string | null;
 export declare function collatedDomainValue(value: unknown, collation: unknown): string | null;
 export declare function collatedDomainCompare(left: unknown, right: unknown): number | undefined;
+/**
+ * Renders one result value at the JavaScript boundary using its column's logical domain.
+ * A NUMERIC column with a declared scale displays PostgreSQL-style at exactly that scale:
+ * the physical encoding is canonical (trailing fractional zeros stripped), so the declared
+ * scale is restored by padding — never rounding — and a value carrying more fractional
+ * digits than the declaration keeps every digit it has. Every other domain, and every value
+ * without one, renders exactly as externalSqlDomainValue.
+ */
+export declare function externalSqlDomainColumnValue(value: unknown, domain: SqlDomain | null | undefined): unknown;
 export declare function externalSqlDomainValue(value: unknown): unknown;
 export declare function isSqlDomainValue(value: unknown): value is string;

package/dist/engine/sql-domains.js

@@ -621,6 +621,29 @@ function collatorFor(locale, displayName) {
     collators.set(locale, created);
     return created;
 }
+/**
+ * Renders one result value at the JavaScript boundary using its column's logical domain.
+ * A NUMERIC column with a declared scale displays PostgreSQL-style at exactly that scale:
+ * the physical encoding is canonical (trailing fractional zeros stripped), so the declared
+ * scale is restored by padding — never rounding — and a value carrying more fractional
+ * digits than the declaration keeps every digit it has. Every other domain, and every value
+ * without one, renders exactly as externalSqlDomainValue.
+ */
+export function externalSqlDomainColumnValue(value, domain) {
+    if (domain?.kind === "numeric" &&
+        domain.scale !== undefined &&
+        domain.scale > 0 &&
+        typeof value === "string" &&
+        value.startsWith(NUMERIC)) {
+        const text = value.slice(NUMERIC.length);
+        const dot = text.indexOf(".");
+        const fractionDigits = dot === -1 ? 0 : text.length - dot - 1;
+        if (fractionDigits >= domain.scale)
+            return text;
+        return (dot === -1 ? `${text}.` : text) + "0".repeat(domain.scale - fractionDigits);
+    }
+    return externalSqlDomainValue(value);
+}
 export function externalSqlDomainValue(value) {
     if (typeof value !== "string")
         return value;

package/dist/engine/sql-json.d.ts

@@ -15,6 +15,18 @@ export declare function jsonAtPath(document: unknown, path: unknown, caller: str
     found: boolean;
     value?: unknown;
 };
+/**
+ * One step of PostgreSQL's `->`/`->>` access. A text key selects an object member; an integer
+ * key selects an array element, counting from the end when negative. The behaviour follows
+ * PostgreSQL's `json` type: a document of the wrong shape for the key selects nothing (NULL)
+ * rather than jsonb's scalar-as-one-element-array reading. Unlike the SQL/JSON functions, whose
+ * standard ON ERROR default swallows malformed documents, PostgreSQL's operators only exist on
+ * values already parsed as json, so a document that is not JSON is an error here.
+ */
+export declare function jsonArrowStep(document: unknown, key: unknown, caller: string): {
+    found: boolean;
+    value?: unknown;
+};
 /** Whether a value is JSON text of the requested shape (T825). */
 export declare function jsonIsValid(document: unknown, kind: string): boolean;
 /** A SQL value as its JSON counterpart: datetimes serialize as ISO text, like every cast. */

package/dist/engine/sql-json.js

@@ -75,6 +75,46 @@ export function jsonAtPath(document, path, caller) {
     }
     return { found: true, value: current };
 }
+/**
+ * One step of PostgreSQL's `->`/`->>` access. A text key selects an object member; an integer
+ * key selects an array element, counting from the end when negative. The behaviour follows
+ * PostgreSQL's `json` type: a document of the wrong shape for the key selects nothing (NULL)
+ * rather than jsonb's scalar-as-one-element-array reading. Unlike the SQL/JSON functions, whose
+ * standard ON ERROR default swallows malformed documents, PostgreSQL's operators only exist on
+ * values already parsed as json, so a document that is not JSON is an error here.
+ */
+export function jsonArrowStep(document, key, caller) {
+    const source = boundedJsonDocument(document, caller);
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        throw new TypeError(`${caller} requires a JSON document`);
+    }
+    const step = externalSqlDomainValue(key);
+    if (typeof step === "number") {
+        if (!Number.isInteger(step)) {
+            throw new TypeError(`${caller} array positions are integers`);
+        }
+        if (!Array.isArray(parsed))
+            return { found: false };
+        const index = step < 0 ? parsed.length + step : step;
+        if (index < 0 || index >= parsed.length)
+            return { found: false };
+        return { found: true, value: parsed[index] };
+    }
+    if (typeof step === "string") {
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return { found: false };
+        }
+        const members = parsed;
+        if (!Object.hasOwn(members, step))
+            return { found: false };
+        return { found: true, value: members[step] };
+    }
+    throw new TypeError(`${caller} keys are member names or array positions`);
+}
 /** Whether a value is JSON text of the requested shape (T825). */
 export function jsonIsValid(document, kind) {
     document = externalSqlDomainValue(document);

package/dist/plan/model.d.ts

@@ -18,6 +18,10 @@ export type AggregateName = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX" | "JSON_ARRA
 /** 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" | "IS_JSON" | "ARRAY"
+/** Parser-produced `->` JSON member/element access returning a JSON value. */
+ | "MINNOW_JSON_GET"
+/** Parser-produced `->>` JSON member/element access returning text. */
+ | "MINNOW_JSON_GET_TEXT"
 /** Optimizer-only, prefix-free equality key for hashable multi-column decorrelation. */
  | "MINNOW_TUPLE_KEY"
 /** Parser-produced wrapper carrying one explicit collation through ordering/comparison. */

package/package.json

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

@@ -137,7 +137,7 @@
     {
       "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; PGlite's default decoder returns this NUMERIC value as a number. 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. A non-terminating AVG quotient renders at Minnow's internal precision, which keeps more fractional digits than PostgreSQL's rounding; the value agrees to every digit PostgreSQL renders."
     },
     {
       "id": "type.json-jsonb",
@@ -164,6 +164,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",

package/sql-feature-matrix.json

@@ -1077,6 +1077,30 @@
       "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."
     },
+    {
+      "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",
       "status": "supported",