@minnowdb/core 0.6.9 → 0.7.0

package/dist/plan/model.d.ts

@@ -25,7 +25,9 @@ export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD
 /** Optimizer-only, prefix-free equality key for hashable multi-column decorrelation. */
  | "MINNOW_TUPLE_KEY"
 /** Parser-produced wrapper carrying one explicit collation through ordering/comparison. */
- | "MINNOW_COLLATE" | "NEXTVAL" | "CURRVAL" | "RANDOM" | "GEN_RANDOM_UUID";
+ | "MINNOW_COLLATE" | "NEXTVAL" | "CURRVAL" | "RANDOM" | "GEN_RANDOM_UUID"
+/** Table-driven PostgreSQL string, math, datetime, regex, and formatting functions. */
+ | "CONCAT" | "CONCAT_WS" | "LEFT" | "RIGHT" | "REVERSE" | "REPEAT" | "INITCAP" | "SPLIT_PART" | "STRPOS" | "STARTS_WITH" | "TRANSLATE" | "ASCII" | "CHR" | "BTRIM" | "MD5" | "FORMAT" | "REGEXP_REPLACE" | "MINNOW_REGEX_MATCH" | "EXP" | "LN" | "LOG" | "LOG10" | "SIGN" | "TRUNC" | "PI" | "CBRT" | "DIV" | "WIDTH_BUCKET" | "SIN" | "COS" | "TAN" | "ASIN" | "ACOS" | "ATAN" | "ATAN2" | "DEGREES" | "RADIANS" | "TO_CHAR" | "TO_DATE" | "TO_TIMESTAMP" | "MAKE_DATE" | "MAKE_TIMESTAMP" | "AGE";
 /** Exact BM25 corpus statistics attached to a cloned scoring node before execution. */
 export interface FtsStats {
     /** Every row of the corpus, including all-null documents. */

package/dist/storage/types.js

@@ -1397,26 +1397,39 @@ export function collectFtsCandidates(chunkLists, terms, maxRowIds = MAX_FTS_CAND
     }
     const sets = terms.map(() => new Set());
     let retainedRowIds = 0;
+    // Every chunk is strictly sorted by term (the write path refuses anything else), so each
+    // query seeks to its first possible posting by binary search and walks forward only while
+    // postings can still match: an exact term touches one posting, a prefix or range its run.
     for (const postings of chunkLists) {
-        for (const posting of postings) {
-            for (let index = 0; index < terms.length; index += 1) {
-                const term = terms[index];
-                if (term === undefined)
-                    continue;
-                const matches = ftsPostingQueryMatches(posting.term, term);
-                if (!matches)
-                    continue;
-                const set = sets[index];
-                if (set !== undefined) {
-                    for (const rowId of posting.rowIds) {
-                        if (set.has(rowId))
-                            continue;
-                        if (retainedRowIds === maxRowIds) {
-                            return { rowIdsByTerm: terms.map(() => []), overflow: true };
-                        }
-                        set.add(rowId);
-                        retainedRowIds += 1;
+        for (let index = 0; index < terms.length; index += 1) {
+            const term = terms[index];
+            const set = sets[index];
+            if (term === undefined || set === undefined)
+                continue;
+            const seek = "term" in term ? term.term : term.lower;
+            let position = seek === undefined ? 0 : lowerBoundPosting(postings, seek);
+            // An exclusive lower bound starts one past its own term, which the seek lands on.
+            if (!("term" in term) &&
+                term.lowerInclusive === false &&
+                postings[position]?.term === term.lower) {
+                position += 1;
+            }
+            for (; position < postings.length; position += 1) {
+                const posting = postings[position];
+                if (posting === undefined)
+                    break;
+                if (!ftsPostingQueryMatches(posting.term, term)) {
+                    // Past the seek point, the first miss ends the run for every query shape.
+                    break;
+                }
+                for (const rowId of posting.rowIds) {
+                    if (set.has(rowId))
+                        continue;
+                    if (retainedRowIds === maxRowIds) {
+                        return { rowIdsByTerm: terms.map(() => []), overflow: true };
                     }
+                    set.add(rowId);
+                    retainedRowIds += 1;
                 }
             }
         }
@@ -1426,6 +1439,19 @@ export function collectFtsCandidates(chunkLists, terms, maxRowIds = MAX_FTS_CAND
         overflow: false,
     };
 }
+/** Index of the first posting whose term is not below `term` in a term-sorted chunk. */
+function lowerBoundPosting(postings, term) {
+    let low = 0;
+    let high = postings.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if ((postings[middle]?.term ?? "") < term)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
 /** Validates the snapshot bound of one full-text read; -1 selects the base view alone. */
 export function validateFtsReadVersion(upToVersion) {
     if (!Number.isSafeInteger(upToVersion) || upToVersion < -1) {

package/package.json

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

@@ -93,11 +93,6 @@
       "classification": "different",
       "reason": "Minnow permits % on its number type; PostgreSQL has no % operator for double precision."
     },
-    {
-      "id": "expression.cast",
-      "classification": "different",
-      "reason": "Casting an approximate number to INTEGER truncates in Minnow; PostgreSQL rounds."
-    },
     {
       "id": "expression.date-trunc",
       "classification": "compatible",
@@ -159,6 +154,21 @@
       "classification": "different",
       "reason": "Minnow returns arrays as canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly return native arrays."
     },
+    {
+      "id": "function.to-date-timestamp",
+      "classification": "different",
+      "reason": "TO_DATE returns a zoneless DATE rendered as YYYY-MM-DD text at the JavaScript boundary, where PostgreSQL clients commonly materialize a midnight Date; TO_TIMESTAMP values agree."
+    },
+    {
+      "id": "function.make-date",
+      "classification": "different",
+      "reason": "MAKE_DATE returns a zoneless DATE rendered as YYYY-MM-DD text at the JavaScript boundary, where PostgreSQL clients commonly materialize a midnight Date; MAKE_TIMESTAMP values agree."
+    },
+    {
+      "id": "function.age",
+      "classification": "different",
+      "reason": "AGE computes PostgreSQL's calendar difference but returns Minnow's canonical months/days/usecs interval text rather than PostgreSQL's '1 mon 14 days 12:00:00' rendering."
+    },
     {
       "id": "type.date",
       "classification": "different",

package/sql-feature-matrix.json

@@ -275,6 +275,12 @@
       "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.returning-expression",
+      "status": "supported",
+      "example": "UPDATE keyed SET score = score + 1 WHERE name = 'x' RETURNING name, score * 2 AS doubled, UPPER(name) AS label",
+      "notes": "Any scalar expression may appear in RETURNING, with SELECT semantics over the affected row: the post-image for INSERT and UPDATE, the removed row for DELETE. Aggregates are refused."
+    },
     {
       "id": "mutation.upsert",
       "status": "supported",
@@ -727,7 +733,7 @@
       "id": "expression.cast",
       "status": "supported",
       "example": "SELECT CAST(amount AS INTEGER) AS whole, CAST(amount AS TEXT) AS label FROM rows",
-      "notes": "Common PostgreSQL type names map to the four stored value kinds; integer targets truncate toward zero, unlike PostgreSQL's rounding, and non-numeric strings fail rather than becoming 0."
+      "notes": "Common PostgreSQL type names map to the four stored value kinds; integer targets round to the nearest integer with ties to even, PostgreSQL's float8 cast (SQLite truncates), and non-numeric strings fail rather than becoming 0. The postfix spelling amount::INTEGER is the same cast."
     },
     {
       "id": "identifier.quoted",
@@ -1291,7 +1297,19 @@
       "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 and range-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. Grouping, aggregates, and per-row ORDER BY ... LIMIT are supported for equality correlations; a range correlation keeps the plain join."
+    },
+    {
+      "id": "from.lateral-aggregate",
+      "status": "supported",
+      "example": "SELECT r.amount, x.n, x.best FROM rows r JOIN LATERAL (SELECT COUNT(*) AS n, MAX(d.label) AS best FROM dims d WHERE d.region = r.region) x ON TRUE ORDER BY r.amount",
+      "notes": "A global aggregate yields one row per outer row even with no matching inner rows: COUNT reads 0, other aggregates NULL, as PostgreSQL returns. GROUP BY and HAVING inside the lateral query gain the correlation key."
+    },
+    {
+      "id": "from.lateral-limit",
+      "status": "supported",
+      "example": "SELECT r.amount, x.label FROM rows r LEFT JOIN LATERAL (SELECT d.label FROM dims d WHERE d.region = r.region ORDER BY d.label DESC LIMIT 1) x ON TRUE ORDER BY r.amount",
+      "notes": "ORDER BY ... LIMIT/OFFSET inside an equality-correlated lateral query ranks rows per outer row (ROW_NUMBER partitioned by the key, RANK for WITH TIES) instead of running the query once per row."
     },
     {
       "id": "from.lateral-non-equi",
@@ -1413,6 +1431,238 @@
       "example": "CREATE TABLE checked (a INTEGER NOT NULL CHECK (a > 0), CONSTRAINT small CHECK (a < 100))",
       "notes": "A row condition over the table's own columns, evaluated by the writer on every path that writes a row — insert, upsert, and update, which is checked against its post-image. A constraint fails only when it evaluates to false, so SQL's unknown passes: NULL satisfies CHECK (a > 0) unless the column is also NOT NULL."
     },
+    {
+      "id": "expression.cast-postfix",
+      "status": "supported",
+      "example": "SELECT amount::INTEGER AS whole, -amount::INTEGER * 2 AS scaled FROM rows",
+      "notes": "PostgreSQL's postfix cast spelling, the same conversion as CAST(x AS type). It binds tighter than every binary and unary operator, so -amount::INTEGER negates the cast value."
+    },
+    {
+      "id": "expression.concat-typed",
+      "status": "supported",
+      "example": "SELECT 'order-' || amount || '/' || active AS tag FROM rows",
+      "notes": "PostgreSQL's text || anynonarray: one operand is text and a number, boolean, or timestamp on the other side renders as text. Two non-text operands (1 || 2) have no || operator, in PostgreSQL or here."
+    },
+    {
+      "id": "where.datetime-text",
+      "status": "supported",
+      "example": "SELECT region FROM rows WHERE joined >= '2026-01-01' AND joined < '2026-02-01 00:00:00'",
+      "notes": "A string constant beside a datetime column reads as a timestamp, a zoneless spelling in UTC, as PostgreSQL types an untyped literal by its context. Catalog-backed plans coerce before execution so zone-map pruning and the keyed point read still apply; both executors read the same way at comparison time. Text that is not a timestamp stays a type error."
+    },
+    {
+      "id": "where.number-text",
+      "status": "supported",
+      "example": "SELECT region FROM rows WHERE amount = '10' OR amount IN ('3', '6')",
+      "notes": "A numeric string beside a number column reads as a number, including in IN lists and bound parameters. A text column compared with a number literal is still rejected, as it is in PostgreSQL."
+    },
+    {
+      "id": "where.boolean-text",
+      "status": "supported",
+      "example": "SELECT region FROM rows WHERE active = 't' AND active <> 'false'",
+      "notes": "PostgreSQL's boolean input spellings t, true, 1, f, false, and 0 read as booleans beside a boolean column."
+    },
+    {
+      "id": "function.string-postgres",
+      "status": "supported",
+      "example": "SELECT CONCAT(region, '-', amount) AS tag, CONCAT_WS('/', region, NULL, 'x') AS joined, LEFT(region, 2) AS l, RIGHT(region, 2) AS r, REVERSE(region) AS rev, REPEAT('ab', 2) AS rep, INITCAP('hello world') AS cap, SPLIT_PART('a-b-c', '-', 2) AS part, STRPOS(region, 'st') AS at, STARTS_WITH(region, 'we') AS starts, TRANSLATE(region, 'we', 'WE') AS tr, ASCII(region) AS code, CHR(65) AS letter, BTRIM('xxhixx', 'x') AS trimmed FROM rows WHERE region IS NOT NULL",
+      "notes": "PostgreSQL's everyday string functions. CONCAT and CONCAT_WS skip NULL arguments and render numbers, booleans, and timestamps as text; LEFT and RIGHT take negative counts; SPLIT_PART counts from the end for a negative field; BTRIM removes any character of its set, as PostgreSQL does."
+    },
+    {
+      "id": "function.md5-format",
+      "status": "supported",
+      "example": "SELECT MD5(region) AS digest, FORMAT('%s has %s items (%I, %L)', region, amount, 'a b', 'it''s') AS message FROM rows WHERE region IS NOT NULL",
+      "notes": "MD5 hashes the UTF-8 bytes to 32 lowercase hex digits. FORMAT supports %s, %I (quoted identifier), %L (quoted literal), %% and positional %n$s; other conversion letters are rejected."
+    },
+    {
+      "id": "predicate.regex",
+      "status": "supported",
+      "example": "SELECT region FROM rows WHERE region ~ '^w' AND region !~* 'EAST$' AND region ~* 'W.ST'",
+      "notes": "PostgreSQL's ~, ~*, !~, and !~* run as JavaScript regular expressions, which agree with advanced regular expressions on everyday syntax. They sit at PostgreSQL's operator level, so `label ~ 'a' || 'b'` matches against the concatenation."
+    },
+    {
+      "id": "function.regexp-replace",
+      "status": "supported",
+      "example": "SELECT REGEXP_REPLACE(region, 'e+', 'E') AS first, REGEXP_REPLACE(region, '[aeiou]', '_', 'g') AS all_vowels, REGEXP_REPLACE('abc', '(a)(b)', '\\2\\1') AS swapped FROM rows WHERE region IS NOT NULL",
+      "notes": "Flags g (every match), i (case-insensitive), and n (newline-sensitive); \\1 back-references and \\& in the replacement follow PostgreSQL."
+    },
+    {
+      "id": "expression.power-operator",
+      "status": "supported",
+      "example": "SELECT 2 ^ 10 AS kib, 2 ^ 3 ^ 2 AS left_assoc, -2 ^ 2 AS negated, 2 * 3 ^ 2 AS mixed",
+      "notes": "PostgreSQL's ^ is exponentiation, binding above * and / and associating to the left: 2 ^ 3 ^ 2 is 64."
+    },
+    {
+      "id": "function.math-extended",
+      "status": "supported",
+      "example": "SELECT EXP(1) AS e, LN(amount) AS ln, LOG(amount) AS log10, LOG(2, 8) AS log2, LOG10(1000) AS thousand, SIGN(amount - 5) AS sign, TRUNC(CAST(amount AS NUMERIC) / 3, 2) AS trunc, PI() AS pi, CBRT(27) AS cbrt, DIV(CAST(amount AS NUMERIC), 3) AS quotient, WIDTH_BUCKET(amount, 0, 10, 5) AS bucket, DEGREES(PI()) AS half_turn, ROUND(SIN(RADIANS(90))) AS sine FROM rows",
+      "notes": "LOG(x) is base 10 and LOG(b, x) an explicit base, as in PostgreSQL. LN, LOG, and LOG10 reject non-positive input; DIV truncates toward zero; the trigonometric family (SIN, COS, TAN, ASIN, ACOS, ATAN, ATAN2, DEGREES, RADIANS) is included."
+    },
+    {
+      "id": "function.to-char-datetime",
+      "status": "supported",
+      "example": "SELECT TO_CHAR(joined, 'YYYY-MM-DD HH24:MI:SS') AS iso, TO_CHAR(joined, 'FMDay, DD FMMonth YYYY') AS spoken, TO_CHAR(joined, 'HH12:MI AM') AS clock, TO_CHAR(joined, 'IW DDD Q') AS calendar FROM rows WHERE joined IS NOT NULL",
+      "notes": "The datetime template fields YYYY, YY, MM, DD, DDD, D, Q, IW, J, HH24, HH12, HH, MI, SS, MS, US, AM/PM, Month/Mon/Day/Dy in every case, TZ (always UTC), FM to drop padding, and double-quoted literal text. Every datetime is an instant in UTC."
+    },
+    {
+      "id": "function.to-char-numeric",
+      "status": "supported",
+      "example": "SELECT TO_CHAR(amount, '999.99') AS padded, TO_CHAR(amount, 'FM999.00') AS trimmed, TO_CHAR(-amount, '9999.9') AS negative, TO_CHAR(amount, '00009') AS zeros, TO_CHAR(amount * 1000, '9,999,999.99') AS grouped, TO_CHAR(amount, 'S999.99') AS signed FROM rows",
+      "notes": "The numeric template elements 9, 0, the decimal point, group separators, FM, S, and MI, with PostgreSQL's padding and sign placement. Other elements (EEEE, RN, V, PL, L, TH) are rejected rather than rendered wrongly."
+    },
+    {
+      "id": "function.to-date-timestamp",
+      "status": "supported",
+      "example": "SELECT TO_DATE('02/01/2026', 'DD/MM/YYYY') AS day, TO_TIMESTAMP('2026-01-02 03:04 PM', 'YYYY-MM-DD HH12:MI AM') AS at, TO_TIMESTAMP(1767322800) AS epoch",
+      "notes": "Reads text against the same template fields TO_CHAR writes; a one-argument TO_TIMESTAMP converts seconds since the epoch. TO_DATE returns a DATE value, rendered as YYYY-MM-DD at the JavaScript boundary."
+    },
+    {
+      "id": "function.make-date",
+      "status": "supported",
+      "example": "SELECT MAKE_DATE(2026, 1, 2) AS day, MAKE_TIMESTAMP(2026, 1, 2, 3, 4, 5.5) AS at",
+      "notes": "Fields that do not form a real date or timestamp are an error."
+    },
+    {
+      "id": "function.age",
+      "status": "supported",
+      "example": "SELECT AGE(TIMESTAMP '2026-03-15 12:00:00', joined) AS since, AGE(joined) AS so_far FROM rows WHERE joined IS NOT NULL",
+      "notes": "The calendar difference PostgreSQL's AGE reports (years and months, then days borrowed from the earlier date's month, then time); AGE(x) measures from the statement's CURRENT_DATE. The result is Minnow's canonical interval text."
+    },
+    {
+      "id": "where.calendar-equality",
+      "status": "supported",
+      "example": "SELECT amount FROM rows WHERE DATE_TRUNC('month', joined) = TIMESTAMP '2026-01-01 00:00:00' OR EXTRACT(YEAR FROM joined) = 2026 ORDER BY amount",
+      "notes": "DATE_TRUNC('unit', col) = ts and EXTRACT(YEAR FROM col) = n are planned as ranges on the column (col >= start AND col < start + 1 unit), so they skip blocks by value range and run on the raw datetime kernel; an unaligned timestamp is a constant false."
+    },
+    {
+      "id": "function.date-part",
+      "status": "supported",
+      "example": "SELECT DATE_PART('year', joined) AS y, EXTRACT(DOY FROM joined) AS doy, EXTRACT(ISODOW FROM joined) AS isodow, EXTRACT(ISOYEAR FROM joined) AS isoyear, EXTRACT(DECADE FROM joined) AS decade, EXTRACT(MILLISECONDS FROM joined) AS ms, EXTRACT(YEAR FROM DATE '2026-03-04') AS from_date FROM rows WHERE joined IS NOT NULL",
+      "notes": "DATE_PART('field', value) is EXTRACT(field FROM value). The fields year, quarter, month, week, day, hour, minute, second, epoch, dow, doy, isodow, isoyear, decade, century, millennium, milliseconds, and microseconds, over timestamps and DATE values, in UTC."
+    },
+    {
+      "id": "group-by.ordinal",
+      "status": "supported",
+      "example": "SELECT UPPER(region) AS place, COUNT(*) AS c FROM rows GROUP BY 1 ORDER BY place",
+      "notes": "An integer GROUP BY item is a select-list ordinal, resolved to that select expression before grouping, as PostgreSQL resolves it. An ordinal naming an aggregate or window column is rejected."
+    },
+    {
+      "id": "group-by.alias",
+      "status": "supported",
+      "example": "SELECT COALESCE(region, 'none') AS place, COUNT(*) AS c FROM rows GROUP BY place ORDER BY place",
+      "notes": "A bare GROUP BY name that is an output alias stands for the aliased expression. A name that is both an alias and a source column keeps its source-column meaning, which is also what PostgreSQL does."
+    },
+    {
+      "id": "group-by.expression-over-key",
+      "status": "supported",
+      "example": "SELECT FLOOR(amount / 5) * 5 AS bucket, COUNT(*) AS c FROM rows GROUP BY FLOOR(amount / 5) ORDER BY bucket",
+      "notes": "A selected expression whose column references all sit inside grouping expressions is grouped, PostgreSQL's rule. COALESCE(region, 'all') over GROUP BY ROLLUP (region) labels the total row the same way."
+    },
+    {
+      "id": "order-by.qualified-selected-column",
+      "status": "supported",
+      "example": "SELECT region, amount FROM rows AS r ORDER BY r.amount DESC",
+      "notes": "A sort key qualified by one of the block's own source aliases resolves to the same column selected unqualified. The qualifier must name a real source, and exactly one selected column must match."
+    },
+    {
+      "id": "limit.zero",
+      "status": "supported",
+      "example": "SELECT region FROM rows ORDER BY amount LIMIT 0",
+      "notes": "LIMIT 0 returns no rows and still reports the result's column shape, the way clients read a query's columns without fetching data."
+    },
+    {
+      "id": "set.trailing-order",
+      "status": "supported",
+      "example": "SELECT amount AS n FROM rows WHERE amount > 5 UNION SELECT amount FROM dims UNION ALL SELECT 100 ORDER BY n DESC LIMIT 4",
+      "notes": "A trailing ORDER BY, LIMIT, or OFFSET applies to the whole set operation and names the first member's output columns, including an alias only that member declares and columns an aggregate member does not group by."
+    },
+    {
+      "id": "select.values-ordered",
+      "status": "supported",
+      "example": "VALUES (2, 'two'), (1, 'one') ORDER BY 1 LIMIT 1",
+      "notes": "A VALUES list is a set operation of one-row selects, so it takes the same trailing ORDER BY, LIMIT, and OFFSET, with ordinals naming its column1, column2, ... outputs."
+    },
+    {
+      "id": "datetime.now",
+      "status": "supported",
+      "example": "SELECT NOW() > TIMESTAMP '2000-01-01 00:00:00' AS elapsed",
+      "notes": "PostgreSQL's now() is the statement's clock reading, the same instant CURRENT_TIMESTAMP names, resolved once per statement in every row and in mutation defaults."
+    },
+    {
+      "id": "mutation.insert-do-nothing-any-key",
+      "status": "supported",
+      "example": "INSERT INTO keyed (name, score) VALUES ('x', 9), ('z', 1) ON CONFLICT DO NOTHING",
+      "notes": "A DO NOTHING without a conflict target skips rows that collide on the table's unique key, the spelling Kysely's onConflict((oc) => oc.doNothing()) emits. DO UPDATE still names its target."
+    },
+    {
+      "id": "select.wildcard-with-expressions",
+      "status": "supported",
+      "example": "SELECT *, amount * 2 AS doubled, region IS NULL AS unplaced FROM rows ORDER BY doubled DESC",
+      "notes": "A bare or qualified wildcard may stand beside other select items, before or after them; each expands from the input schema at binding, as PostgreSQL expands it."
+    },
+    {
+      "id": "select.distinct-grouped",
+      "status": "supported",
+      "example": "SELECT DISTINCT active, COUNT(*) AS c FROM rows GROUP BY region, active ORDER BY active, c",
+      "notes": "DISTINCT over a grouped, aggregated, HAVING-filtered, or windowed block takes the distinct rows of that block's output, which runs inside a derived table; ORDER BY and LIMIT apply to the distinct rows."
+    },
+    {
+      "id": "mutation.update-alias",
+      "status": "supported",
+      "example": "UPDATE keyed AS k SET score = k.score + 1 WHERE k.name = 'x' RETURNING k.name, k.score",
+      "notes": "PostgreSQL's mutation alias, with or without AS; assignments, predicates, and RETURNING may qualify by it. DELETE FROM keyed AS k WHERE k.score < 0 takes the same alias."
+    },
+    {
+      "id": "mutation.delete-alias",
+      "status": "supported",
+      "example": "DELETE FROM keyed AS k WHERE k.score < 0 RETURNING k.name",
+      "notes": "The alias resolves in the predicates and RETURNING exactly as a table alias does in SELECT."
+    },
+    {
+      "id": "mutation.update-subquery-assignment",
+      "status": "supported",
+      "example": "UPDATE keyed SET bonus = (SELECT MAX(score) FROM keyed) + (SELECT COUNT(*) FROM keyed k WHERE k.score > keyed.score) WHERE name = 'x'",
+      "notes": "A scalar subquery in SET, correlated or not, reads the pre-update rows through the ordinary query pipeline: an uncorrelated subquery resolves once at the statement's snapshot, a correlated one is decorrelated like a SELECT item. Aggregates and window functions outside a subquery stay rejected."
+    },
+    {
+      "id": "mutation.insert-subquery-value",
+      "status": "supported",
+      "example": "INSERT INTO keyed (name, score) VALUES ('q', (SELECT MAX(score) + 1 FROM keyed))",
+      "notes": "A scalar subquery in VALUES is evaluated when the statement runs, at its snapshot, like the statement clock and sequence calls."
+    },
+    {
+      "id": "mutation.insert-select-on-conflict",
+      "status": "supported",
+      "example": "INSERT INTO keyed (name, score) SELECT name, score + 100 FROM keyed WHERE score > 0 ON CONFLICT (name) DO UPDATE SET score = EXCLUDED.score",
+      "notes": "ON CONFLICT applies to the rows a query source produces exactly as to a VALUES list, DO NOTHING (with or without a target) and DO UPDATE alike."
+    },
+    {
+      "id": "mutation.insert-select-compound",
+      "status": "supported",
+      "example": "INSERT INTO keyed (name, score) WITH top AS (SELECT name FROM keyed WHERE score > 0) SELECT name || '2', 2 FROM top UNION ALL SELECT 'u', 3",
+      "notes": "Any query expression feeds INSERT: a WITH, a set operation, or a parenthesized member; the produced column count is checked against the column list when the rows materialize."
+    },
+    {
+      "id": "ddl.serial",
+      "status": "supported",
+      "example": "CREATE TABLE ticketed (id SERIAL PRIMARY KEY, label TEXT)",
+      "notes": "SERIAL, BIGSERIAL, and SMALLSERIAL are integer columns fed by the table's auto-increment counter, the same default the schema DSL's autoIncrement() declares; the column is NOT NULL, and an explicit value is accepted without advancing the counter, as a PostgreSQL sequence behaves. The counter belongs to the table's unique key, so a serial column must be the primary key."
+    },
+    {
+      "id": "ddl.identity",
+      "status": "supported",
+      "example": "CREATE TABLE identified (id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 1) PRIMARY KEY, label TEXT)",
+      "notes": "GENERATED ALWAYS AS IDENTITY and GENERATED BY DEFAULT AS IDENTITY read as the auto-increment default; sequence options in parentheses are accepted and ignored, and the counter starts at 1. SQLite's INTEGER PRIMARY KEY AUTOINCREMENT spelling is accepted the same way."
+    },
+    {
+      "id": "ddl.alter-table-add-column-default",
+      "status": "supported",
+      "setup": [
+        "CREATE TABLE filled (id INTEGER PRIMARY KEY)",
+        "INSERT INTO filled VALUES (1), (2)"
+      ],
+      "example": "ALTER TABLE filled ADD COLUMN tier TEXT NOT NULL DEFAULT 'basic'",
+      "notes": "A constant DEFAULT fills the rows already stored, as PostgreSQL does, which is what allows the added column to be NOT NULL; an expression default such as NOW() fills only the rows written afterwards, so a NOT NULL column with one is still refused."
+    },
     {
       "id": "ddl.foreign-key",
       "status": "supported",