PostgreSQL compatibility

SELECT ALL names the default: every row, duplicates kept. ALL is also accepted inside an aggregate, as in COUNT(ALL amount).

PostgreSQL's DISTINCT ON (expressions) keeps the first row of each group in ORDER BY order. It lowers to ROW_NUMBER() OVER (PARTITION BY expressions ORDER BY …) = 1 over the block, so ORDER BY may name output aliases and columns the select list omits, and LIMIT and OFFSET apply to the kept rows.

FOR UPDATE, FOR NO KEY UPDATE, FOR SHARE, and FOR KEY SHARE, with OF, NOWAIT, or SKIP LOCKED, are accepted and ignored: row locks coordinate concurrent sessions, and a single-session engine has none to coordinate.

TABLE name is the standard's spelling of SELECT * FROM name.

E'…' strings take C-style backslash escapes (\\n, \\t, \\xHH, \\uHHHH, octal), $tag$…$tag$ strings are taken verbatim, and 5. and .5 spell 5.0 and 0.5, as in PostgreSQL.

~~, !~~, ~~*, and !~~* are PostgreSQL's operator spellings of LIKE, NOT LIKE, ILIKE, and NOT ILIKE.

A column label needs no AS, as in PostgreSQL and SQLite. The label is any identifier that no clause or operator keyword can claim; a quoted identifier is always a label.

Plain projections and SELECT DISTINCT * are supported. DISTINCT combined with grouping, HAVING, or aggregate/window expressions is rejected.

PostgreSQL: Division by zero returns NULL instead of raising PostgreSQL's error. Integer division itself follows PostgreSQL: two integer operands truncate toward zero.

Over a double, precision truncates to an integer and clamps to 0..30, and halfway values round away from zero, matching SQLite. Over an exact NUMERIC the result is PostgreSQL's numeric ROUND: exact, half away from zero, a negative digit count rounds left of the decimal point, and a literal digit count is the result's display scale.

PostgreSQL: Minnow accepts ROUND(double precision, digits); PostgreSQL requires numeric for the two-argument form.

TIMESTAMP 'y-m-d h:m:s' with the time optional. A literal without a zone is UTC, as every datetime in a Minnow database is.

Values bind by 1-based number and may repeat; the compiled plan is cached on the SQL text and re-bound per execution.

Each ? takes the next value in order. A statement uses either ? or $n placeholders, never both; PostgreSQL itself has no ? form.

PostgreSQL: PostgreSQL uses $n parameters. Minnow also accepts ? as adapter-friendly shorthand.

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.

Both the wildcard and the ordering reference may use a table name or alias, quoted or unquoted. The conformance corpus crosses those spellings and compares them with SQLite and PostgreSQL.

[NOT] MATERIALIZED is PostgreSQL's planner hint on a CTE; the block is planned the same way either way.

A CTE names its own output columns. A recursive CTE takes the names before its step member, which refers to the working set by them.

Through execute(); query() stays read-only.

When the column list is omitted, VALUES must supply every table column in declaration order.

DEFAULT VALUES inserts one row using catalog defaults. DEFAULT is also accepted in an individual VALUES slot.

Statement-time, random, UUID, and sequence calls in VALUES are evaluated at execution rather than frozen in the compiled-statement cache. Every CURRENT_* call in one statement shares one clock.

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.

Requires a unique-key table.

UPDATE … FROM joins extra sources — tables, views, or derived tables — to the target as PostgreSQL does; the assignments and predicates may read them. A target row matched by several source rows is updated once, from its first match.

DELETE … USING joins extra sources to the target as PostgreSQL does; a target row matched by several source rows is deleted once.

TRUNCATE [TABLE] [ONLY] name [RESTART IDENTITY | CONTINUE IDENTITY] [RESTRICT] removes every row of one table, the same as an unfiltered DELETE, so like DELETE it needs a table with a unique key. Several tables in one statement and CASCADE are refused; truncate each table separately.

PostgreSQL: TRUNCATE reports the number of rows it removed, where PostgreSQL's command tag carries no count. The resulting table state is identical.

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.

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.

PostgreSQL-compatible ON CONFLICT form. The conflict target is the unique key and assigned values may read the target row or EXCLUDED proposal.

PostgreSQL: ON CONFLICT ... DO UPDATE follows PostgreSQL syntax.

Rows whose key already exists at the statement's snapshot are skipped. Each proposed row is considered in order, so later duplicates of a key retained earlier in the same statement are skipped too.

PostgreSQL: ON CONFLICT ... DO NOTHING follows PostgreSQL syntax.

Minnow's concise whole-row upsert spelling replaces every non-key column and also has exact semantics for a key-only table.

PostgreSQL: DO REPLACE is Minnow shorthand for replacing every non-key value from EXCLUDED.

Assigning a subset of target columns changes only those columns; unassigned columns keep their stored values. Assignment targets need not appear in the INSERT column list. Mixed update/insert batches publish atomically or roll back together.

PostgreSQL: A partial SET list with EXCLUDED follows PostgreSQL syntax.

% matches any run and _ matches one Unicode codepoint.

Null-safe: NULL is not distinct from NULL.

IS [NOT] TRUE/FALSE/UNKNOWN never return UNKNOWN; they desugar to null-safe comparisons.

ESCAPE makes the next pattern character literal, wildcards included.

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.

Case-insensitive LIKE, a PostgreSQL extension; SQLite's LIKE is case-insensitive by default instead.

PostgreSQL: ILIKE follows PostgreSQL syntax and case-insensitive matching semantics.

PostgreSQL: MATCH is Minnow's index-transparent full-text predicate rather than a PostgreSQL operator.

PostgreSQL: MATCH(*) searches every text column and is a Minnow full-text extension.

Search text binds like any other value, so search-as-you-type can reuse one planned statement.

PostgreSQL: Parameterized MATCH uses Minnow's index-transparent full-text predicate.

PostgreSQL: BM25 exposes Minnow's full-text score; PostgreSQL uses its own text-search types and ranking functions.

SUBSTRING(text FROM 'pattern') is PostgreSQL's POSIX-regex form: the first match, or its first parenthesized group; a number after FROM is the ordinary start position. TO_HEX renders an integer in hexadecimal; QUOTE_LITERAL and QUOTE_IDENT quote a value or a name for use in SQL text. Matching is leftmost-longest and bounded; the regex operator profile lists unsupported syntax.

SYMMETRIC accepts the bounds in either order.

Both uncorrelated and correlated EXISTS are supported. Correlated forms are decorrelated into joins rather than executed once per outer row.

Correlated subqueries decorrelate into derived-table joins at compile time; both executors run plain joins.

Top-level EXISTS and NOT EXISTS lower to semi-joins and anti-joins. Nested boolean forms use hidden per-probe match flags.

Correlated scalar aggregates and single-row projections decorrelate in the select list. Every qualified outer column used by the inner predicates or projection becomes part of the distinct probe tuple. In a grouped query, outer references must be GROUP BY columns and the scalar cannot sit inside an outer aggregate.

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.

JSON aggregate expressions use the same set-at-a-time decorrelation as numeric aggregates and preserve their JSON result domain.

PostgreSQL: 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.

The decorrelated value is functionally determined by the outer grouping keys and is carried as an internal group key.

Non-equality scalar aggregates group inner rows once per distinct outer probe tuple, then join the result back by equality.

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.

Non-equality EXISTS and NOT EXISTS correlations lower to semi-joins and anti-joins. Scalar aggregates use distinct outer probes.

A range-correlated IN predicate lowers to a semi-join carrying both its correlation and membership comparisons.

Correlated NOT IN preserves empty-set and NULL semantics rather than treating it as a simple anti-join.

Correlated IN and NOT IN retain true, false, and unknown results below OR, NOT, CASE, and in select expressions.

Range correlation uses an anti-join for exact matches plus per-probe total and non-NULL counts.

Top-level WHERE uses semi/anti joins. Nested expressions group true, false, unknown, and empty-set counts per distinct outer probe tuple.

Linear delta recursion with UNION or UNION ALL, capped at 10,000 iterations and 1,000,000 rows. Plain WITH still rejects self-references.

WITH precedes INSERT/UPDATE/DELETE; the CTEs are visible to the statement's queries and subqueries.

INTERSECT binds tighter than UNION and EXCEPT, matching PostgreSQL.

Bag semantics; SQLite itself has no INTERSECT ALL.

Bag semantics; SQLite itself has no EXCEPT ALL.

Desugars into a CASE inside COUNT/SUM/AVG/MIN/MAX and preserves DISTINCT. JSON_ARRAYAGG does not support FILTER.

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.

A window is an expression: the arithmetic around it is evaluated after the window has run, over the column it produced.

Windows run after GROUP BY and HAVING, matching PostgreSQL, so they rank groups and their OVER clause reads the group's aggregates.

FIRST_VALUE/LAST_VALUE respect the frame; matching PostgreSQL, the default frame ends at the current peer group.

ROWS frames use row distances; RANGE frames use peers or numeric ordering-value distances; GROUPS frames use peer-group distances. Exclusions are supported.

Numeric RANGE offsets measure ordering-value distance and require one numeric ORDER BY expression. Temporal interval offsets are not supported.

Window functions work in SELECT and ORDER BY. WHERE, GROUP BY, and HAVING cannot contain windows.

Desugars to the mirrored LEFT JOIN; supported as the sole join of a block, and not beside SELECT *.

Executes as a nested-loop join (probe x build); equalities keep the hash path.

Expands bare or qualified wildcards to exactly their selected source columns before DISTINCT grouping is planned.

OFFSET is accepted directly after LIMIT.

VALUES works standalone, as a set-operation member, and as a derived table with AS alias(col, ...) renaming; columns default to column1..columnN.

LIMIT and OFFSET take placeholders; the plan re-binds per execution like any parameter.

PostgreSQL's FETCH clause is accepted as a spelling of LIMIT; SQLite itself only speaks LIMIT.

OFFSET no longer requires LIMIT. SQLite itself needs LIMIT -1 OFFSET n.

Common PostgreSQL type names map onto Minnow's four stored value kinds (widths parse and are ignored); one PRIMARY KEY or UNIQUE column becomes the row-addressing key. ALTER TABLE ADD/DROP COLUMN and DROP TABLE are tracked separately.

PostgreSQL's internal type names (int2, int4, int8, float4, float8, bool) and its multi-word spellings (character varying, timestamp with time zone, timestamp without time zone, time with time zone) map onto the same storage as INTEGER, BIGINT, DOUBLE PRECISION, BOOLEAN, VARCHAR, and TIMESTAMPTZ. pg_dump and migration tools emit these spellings.

TEMP, TEMPORARY, UNLOGGED, GLOBAL, and LOCAL are accepted and ignored: every table lives in the one database with one durability, so the modifiers document intent and change nothing.

CONSTRAINT name before a column's CHECK or REFERENCES names that constraint, as it does at table level; the name of a column's PRIMARY KEY, UNIQUE, or NOT NULL is informational.

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.

PostgreSQL: Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function.

BEFORE bodies stage ahead of the primary write but publish in the same atomic commit, so timing is a portability feature: atomicity and visibility are identical to AFTER.

PostgreSQL: Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function.

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.

PostgreSQL: Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function.

PostgreSQL: PostgreSQL requires DROP TRIGGER name ON table; Minnow's trigger names are database-wide.

|| 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.

Division follows PostgreSQL's typing. Two integer operands — INTEGER, BIGINT, or SMALLINT columns, integer constants, COUNT, integer CASTs, and integer arithmetic or aggregates over them — divide as integers, truncating toward zero: 7 / 2 is 3 and -7 / 2 is -3. A double, NUMERIC, or decimal constant operand makes the quotient fractional: 7.0 / 2 is 3.5. A bound parameter takes the type of its integer partner, so id / $1 truncates when $1 is bound to an integer.

An untyped string constant beside a number in + - * / % is read as a number, as PostgreSQL types the unknown literal by its partner. Text that is not a number is still an error.

Division and remainder by zero are NULL, matching SQLite.

PostgreSQL: Minnow permits % on double precision values; PostgreSQL has no % operator for double precision.

Integer casts round exact NUMERIC ties away from zero and floating-point ties to even. Integer text accepts signed decimal digits. Postfix :: and CAST use the same rules.

Double-quoted identifiers are never keywords and keep their exact spelling.

Without NULLS FIRST/LAST the default follows PostgreSQL: NULLs last ascending, first descending.

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.

Units: year, quarter, month, week (Monday start), day, hour, minute, second. Truncation is in UTC; the engine has no session time zone.

PostgreSQL: DATE_TRUNC follows PostgreSQL syntax; Minnow evaluates datetimes in UTC because it has no session time zone.

INTERVAL added to or subtracted from a datetime. Months are calendar arithmetic, so 31 January plus a month clamps to the end of February.

SUBSTRING is accepted as a spelling of SUBSTR; LENGTH and SUBSTR count characters, not UTF-16 units.

GREATEST/LEAST ignore NULL arguments, matching PostgreSQL.

PostgreSQL: Minnow's numeric functions accept integer, exact, and double-precision arguments interchangeably, where PostgreSQL's distinct integer, numeric, and double-precision overloads do not.

PostgreSQL: The bundled form includes INSTR; PostgreSQL has no INSTR and spells the same (string, substring) lookup STRPOS, with the arguments in the same order.

Fields: year, quarter, month, week (ISO), day, hour, minute, second, epoch, dow — all in UTC. SQLite spells this strftime.

COUNT/SUM/AVG/MIN/MAX accept DISTINCT. Each one keeps its own set of values, so several can appear in one select, beside ordinary aggregates, inside expressions, and in HAVING.

Multi-key conditions execute as a nested-loop join; single equalities keep the hash path.

Desugars into a union of two left joins, so it must be the sole join, with an equality ON, named output columns rather than SELECT *, and no grouping, DISTINCT, or window functions yet.

The sole FULL JOIN composes with grouping, DISTINCT, wildcards, and window functions by applying these operations after both unmatched sides are included.

Ordinals resolve after schema-bound wildcard expansion when needed; out-of-range ordinals are an error.

LAG/LEAD take a constant offset (default 1) and default value (default NULL), and require ORDER BY inside OVER.

The SELECT runs at one snapshot and materializes before the batch write. Bare and qualified wildcard select lists are supported and their expanded width is checked against the target columns.

One pass over the source decides each row's branch, and the branches apply as batched writes inside a single write scope — atomic, and firing the same triggers the equivalent INSERT, UPDATE, and DELETE would. The match must equate the target's unique key with a source value, which is how rows are addressed. Matching PostgreSQL, two source rows cannot act on one target row. MATCHED BY SOURCE, MATCHED BY TARGET, and RETURNING are not supported.

Holds the same scope `write()` opens between statements instead of around a callback: writes stage into it, reads see what it staged, and COMMIT publishes them together. Schema changes are refused inside one, because the catalog commits outside the scope and a rollback could not take them back. A transaction left untouched past the idle bound rolls itself back, so an abandoned BEGIN cannot hold storage forever.

END and END TRANSACTION commit, as COMMIT does.

ABORT rolls back, as ROLLBACK does.

SET [SESSION | LOCAL] name TO value, SET TRANSACTION …, and RESET name are accepted and ignored: an embedded single-session engine has no search path, timeouts, encodings, or isolation levels to configure, and drivers and migration tools issue these on every connection. SET TIME ZONE accepts only UTC, because every datetime is an instant in UTC; another zone is refused rather than silently ignored.

SHOW returns the engine's fixed answer for the settings drivers and tools read on connection — search_path, server_version, timezone, transaction_isolation, client_encoding, and the like — as one row. An unknown setting is an error, as in PostgreSQL.

Counts the UTF-8 encoding's bytes.

The position window is intersected with the string, so a start below 1 shortens the result instead of shifting it.

Minnow removes a multi-character trim string as a repeated unit; PostgreSQL reads the argument as a set of characters instead.

PostgreSQL: Minnow removes the trim string as a repeated unit; PostgreSQL treats its characters as a set.

Output names follow the rule a bare * uses: the column's own name from one source, alias-qualified from several. Expansion happens before shape-dependent planning, so qualified wildcards compose with DISTINCT, windows, set operations, CTE/derived column lists, ORDER BY expressions and ordinals, and INSERT SELECT.

Wildcard columns are schema-bound before window lowering. The generated conformance corpus also crosses wildcards with DISTINCT, set operations, column lists, and ORDER BY expressions and ordinals.

A parenthesized join group is accepted as the first source or as the operand of a comma, CROSS JOIN, or INNER JOIN, whose ON condition then filters the product. A group cannot take an alias, and LEFT, RIGHT, FULL, NATURAL, or USING joins onto a group are rejected: the flat join chain cannot treat the group as one side.

Unlike PostgreSQL, joined columns stay one per side: `SELECT *` returns both and an unqualified reference to a join column is ambiguous. Qualify it, or name the side you want.

The shared columns are compared but not merged, so an unqualified reference to one is ambiguous — qualify it. NATURAL RIGHT JOIN is rejected, because the right-join mirror rewrites the sources the shared-column search reads.

A sole FULL JOIN accepts compound ON predicates and preserves unmatched rows from both sides.

Resolved once per execution, so every row of a statement sees one instant; results that read the clock never memoize.

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.

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.

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.

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.

PostgreSQL: 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.

The limit cannot be pushed into a scan, so these plans run unlimited and the ordered result is trimmed.

A bitmask over the arguments, most significant first.

Which row of the group answers is implementation-dependent; this engine returns the minimum.

PostgreSQL: PostgreSQL may choose any non-null group member; Minnow documents the minimum. This cross-engine profile checks acceptance rather than row equality, while the native browser behavior probe asserts Minnow's minimum.

Built from COUNT and SUM rather than a dedicated accumulator: the variance is E(x2) - E(x)2. Bare VARIANCE and STDDEV are the sample forms, as in PostgreSQL.

json_agg and jsonb_agg are PostgreSQL's spellings of JSON_ARRAYAGG, with the same ORDER BY inside the call. jsonb and json produce the same document text.

json_build_object, jsonb_build_object, json_build_array, and jsonb_build_array are PostgreSQL's spellings of JSON_OBJECT and JSON_ARRAY.

to_json and to_jsonb render one SQL value as a JSON document: a number as itself, text as a JSON string, a boolean as true or false, NULL as the document null, and a JSON value as itself.

A table alias used as a value is the row as a JSON object with the source's columns in order, as PostgreSQL treats it — the shape json_agg(agg) and to_json(obj) take in Kysely's jsonArrayFrom and jsonObjectFrom. Datetime members render as ISO 8601 with a Z suffix.

Accepts JSON text and stored JSON/JSONB values. Paths support $, member steps, and array subscripts.

PostgreSQL: The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces.

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.

PostgreSQL: The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces.

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.

PostgreSQL: 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.

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.

PostgreSQL: 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.

->> 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.

Negative element positions count from the end of the array; positions out of range in either direction select NULL.

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.

PostgreSQL: PostgreSQL requires a json-typed document for -> and ->>; Minnow also accepts ordinary JSON text directly, as its SQL/JSON functions do.

DEFAULT accepts a variable-free scalar expression. Omission or SQL DEFAULT invokes it; explicit NULL follows the column's independent nullability.

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.

Existing rows have no value for the new column, so it is always nullable.

Exact through storage, arithmetic, comparison, aggregates, windows, and ROUND, TRUNC, ABS, FLOOR, CEIL, MOD, and SIGN. Addition, subtraction, remainder, and multiplication carry PostgreSQL's display scale (the larger operand scale, or their sum for a product); 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. A plain-number fallback beside NUMERIC values, as in COALESCE(amount, 0), renders at its own scale.

PostgreSQL: 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.

JSON validates and preserves key order; JSONB canonicalizes object keys. Results use JSON text.

PostgreSQL: Minnow returns canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly decode JSONB to a native object.

Validated and normalized to canonical lowercase text.

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).

PostgreSQL: Minnow returns a canonical months/days/microseconds string; PostgreSQL clients use their own interval representation and formatting.

Enum columns validate members and compare in declaration order. ALTER TYPE is not supported.

PostgreSQL-compatible CREATE INDEX syntax over durable scalar and composite indexes. Leftmost equality and IN prefixes plus the next range column prune candidates; every predicate is rechecked.

PostgreSQL: CREATE INDEX follows PostgreSQL syntax.

Index names are catalog-global. IF EXISTS is also supported.

PostgreSQL: DROP INDEX follows PostgreSQL syntax.

Composite keys use a prefix-free, type-preserving tuple encoding with ASC or DESC per component. Planning follows the SQL leftmost-prefix rule.

PostgreSQL: Composite CREATE INDEX follows PostgreSQL syntax.

UNIQUE membership is enforced atomically across inserts, updates, deletes, upserts, triggers, write scopes, snapshots, and concurrent tabs. Matching PostgreSQL, any NULL component does not conflict.

PostgreSQL: CREATE UNIQUE INDEX follows PostgreSQL syntax.

Each table-level or column-level UNIQUE constraint is enforced independently.

Composite keys use a hidden scalar row locator; primary-key components are immutable.

A metadata-only drop refuses unique keys, checks, foreign keys, triggers, views, and the last column. Stored column blocks remain until compaction rewrites their segments; persisted full-text data for the column is removed atomically with the catalog update. RESTRICT is the default and CASCADE is rejected.

Assignments may read the stored target row, the proposed EXCLUDED row, parameters, constants, CASE, and scalar functions. All conflicting updates and fresh inserts execute in one write scope; one statement cannot affect the same existing key twice. Aggregates, windows, subqueries, and conflict-key reassignment are rejected.

PostgreSQL: Minnow resolves an unqualified target column in DO UPDATE; PostgreSQL treats score beside EXCLUDED.score as ambiguous unless the target is qualified.

A false conflict predicate leaves the existing row unchanged.

SAVEPOINT, ROLLBACK TO, and RELEASE operate on staged transaction state.

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.

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.

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.

Non-equality correlation lowers to an ordinary general join rather than executing the derived source once per outer row.

DISTINCT, aggregate-local ORDER BY, and bounded spill execution are supported.

Constant documents support $ and $[*] row paths. A document read from row data is refused (see json.table-correlated).

Whole-string SQL wildcard and regular-expression semantics.

C, POSIX, and host Intl locale names are accepted. Collated ordering does not use a plain string index.

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.

PostgreSQL: Minnow returns JSON text; PostgreSQL returns a native JSON value, and member order is unspecified without aggregate-local ORDER BY.

ARRAY_AGG supports DISTINCT and aggregate-local ORDER BY, includes NULL elements, and returns NULL for empty input. Arrays cross the JavaScript boundary as canonical JSON text. FILTER and window use are not supported.

PostgreSQL: Minnow returns arrays as canonical JSON text at the JavaScript boundary; PostgreSQL clients return native arrays. ARRAY_AGG supports DISTINCT and ordering, but not FILTER or window use.

Constructors and array columns use canonical JSON text at the JavaScript boundary. One-based scalar subscripts and ARRAY_AGG are supported. Array operators such as concatenation and ANY/ALL remain unsupported.

PostgreSQL: Minnow returns arrays as canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly return native arrays.

One-based scalar subscripts return NULL for an out-of-range position. Slices and multidimensional access are not supported.

A time of day without a time zone, returned as canonical text.

A calendar date without a time zone, returned as canonical YYYY-MM-DD text.

PostgreSQL: Minnow returns zoneless DATE values as canonical YYYY-MM-DD text while PostgreSQL clients commonly materialize them as midnight Date objects.

NEXTVAL and session-local CURRVAL are supported. Sequence options and ALTER SEQUENCE are not.

Takes the table's rows, catalog record, full-text index, and triggers. The blocks are retired through the commit rather than deleted, so a reader pinned to an older version keeps resolving them and the lease-aware collector reclaims them later. Refused while a view reads the table or another table's trigger writes to it — both would be left pointing at something that is not there. DROP TABLE CASCADE is refused too: nothing cascades, because there are no dependent objects to reach.

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.

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.

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.

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.

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.

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.

PostgreSQL's boolean input spellings t, true, 1, f, false, and 0 read as booleans beside a boolean column.

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.

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. Positional arguments advance the next implicit argument position. Missing arguments, malformed directives, and width/alignment directives throw.

PostgreSQL's ~, ~*, !~, and !~* use a bounded interpreter with leftmost-longest matching. Grouping, alternation, greedy repetition, anchors, and ASCII POSIX character classes are supported; locale-dependent non-ASCII class membership differs. Pattern backreferences, lookaround, inline flags, and non-greedy quantifiers are refused. Pattern matching is subject to the SQL work and state limits. Operator precedence matches PostgreSQL.

Flags g (every match), i (case-insensitive), and n (newline-sensitive); \1 back-references and \& in the replacement follow PostgreSQL. Pattern syntax and work limits follow the regex operator profile; c overrides case-insensitive matching when it appears after i.

PostgreSQL's ^ is exponentiation, binding above * and / and associating to the left: 2 ^ 3 ^ 2 is 64.

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.

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.

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.

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.

PostgreSQL: 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.

Fields that do not form a real date or timestamp are an error.

PostgreSQL: 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.

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.

PostgreSQL: 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.

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.

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.

UNNEST over an ARRAY constructor produces typed rows and supports WITH ORDINALITY and output column aliases. Table-correlated array inputs and arbitrary array expressions are not supported.

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.

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.

A grouped column may be spelled bare in the select list and qualified in GROUP BY, or the reverse, and both spellings may appear in one expression. With several sources a bare name is the column of the one source that has it, resolved from the schemas at execution.

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.

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.

LIMIT 0 returns no rows and still reports the result's column shape, the way clients read a query's columns without fetching data.

LIMIT ALL is PostgreSQL's spelling of no limit, alone or before OFFSET, on a block or a set operation. SQLite has no LIMIT ALL.

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.

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.

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.

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.

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.

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.

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.

The alias resolves in the predicates and RETURNING exactly as a table alias does in SELECT.

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.

A scalar subquery in VALUES is evaluated when the statement runs, at its snapshot, like the statement clock and sequence calls.

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.

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.

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.

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.

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.

Scalar and composite references target the parent's matching primary-key columns. Writes validate against their transaction; NULL references are satisfied. ON DELETE supports RESTRICT, CASCADE, and SET NULL atomically. Primary keys are immutable, so ON UPDATE has no action.

Leftmost-longest alternation and ASCII POSIX character classes follow the bounded regex profile.

Ordered-set aggregates (percentile_cont, percentile_disc, mode) and corr are not supported; a window over ROW_NUMBER() and COUNT() OVER () computes a median.

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.

information_schema, pg_catalog, and sqlite_master are not supported; the catalog is read through the API (listTables, describe).

ADD COLUMN IF NOT EXISTS is not supported; check the catalog first or let the duplicate-column error stand.

ADD CONSTRAINT and DROP CONSTRAINT are not supported; constraints are declared in CREATE TABLE.

ALTER COLUMN forms are not supported; see ddl.alter-table-rename.

ALTER TABLE RENAME COLUMN, RENAME TO, ALTER COLUMN TYPE / SET DEFAULT / SET NOT NULL / DROP NOT NULL, ADD CONSTRAINT, and DROP CONSTRAINT are not supported as SQL. ALTER TABLE ADD COLUMN and DROP COLUMN are. The schema DSL's migrate() renames columns and widens nullability through the catalog.

ALTER TYPE and DROP TYPE are not supported; CREATE TYPE … AS ENUM is, and the schema DSL widens enum values through migrate().

BYTEA columns and bytea literals, casts, and functions (encode, decode, sha256) are not supported; store binary data as base64 or hex TEXT.

CREATE TABLE … (LIKE other) is not supported; spell the columns out, or CREATE TABLE AS SELECT for a data copy.

DEFERRABLE constraints are not supported; every constraint is checked at the statement.

CREATE DOMAIN is not supported; put the CHECK on the column.

DROP TABLE takes one table per statement.

EXCLUDE constraints are not supported.

Expression indexes are not supported; index a stored generated column instead.

ON UPDATE actions are not supported because primary-key values cannot be updated; ON DELETE CASCADE, SET NULL, RESTRICT, and NO ACTION are.

SET DEFAULT would rewrite orphaned references to the column's default value at delete time; Minnow implements RESTRICT, CASCADE, and SET NULL. The statement is rejected at parse, before touching the catalog.

CREATE FUNCTION and CREATE TRIGGER … EXECUTE FUNCTION are not supported; triggers take an inline BEGIN … END body of INSERT, UPDATE, and DELETE statements.

Materialized views are not supported; CREATE TABLE AS SELECT stores a snapshot.

Partial indexes (WHERE), expression indexes, INCLUDE columns, USING method, and CONCURRENTLY are not supported; an index is over one or more plain columns.

Schemas are not supported: there is one namespace, and a schema-qualified name (public.users) is refused.

Schema-qualified names are not supported; there is one namespace.

setval, currval, and ALTER SEQUENCE are not supported; nextval and CREATE SEQUENCE are.

SERIAL and GENERATED … AS IDENTITY are supported on the primary key only; a sequence-fed non-key column is refused.

A column list on CREATE VIEW and WITH CHECK OPTION are not supported; alias the columns in the view's SELECT.

AT TIME ZONE and timezone() are not supported: every datetime is an instant in UTC, and rendering in another zone belongs to the application.

The bitwise operators &, |, #, ~, <<, and >> and the prefix operators |/ and @ are not supported.

date - date and timestamp - timestamp are not supported; see expression.interval-values.

Interval-valued arithmetic — interval + interval, timestamp - timestamp, date - date, date + integer, justify_days — is not supported. A date or datetime plus or minus an INTERVAL is; subtract two EXTRACT(EPOCH …) readings for a duration in seconds.

A row constructor as a value is not supported; row comparisons ((a, b) = (1, 2), (a, b) IN (…)) are.

generate_series is not supported; a recursive CTE produces a series.

regexp_match, regexp_matches, regexp_split_to_array, and regexp_split_to_table return arrays or sets, which are not supported; SUBSTRING(text FROM 'pattern'), REGEXP_REPLACE, and the ~ operators cover single matches.

version(), current_user, session_user, current_schema, pg_typeof, and setseed describe a server this engine is not; SHOW server_version answers the version question.

RIGHT JOIN desugars by swapping the two sides of a LEFT JOIN, which needs the block to hold exactly one join. Rewrite the block so the preserved side is on the left of a LEFT JOIN.

The desugaring swaps the two sources, which would reorder a wildcard's output columns. Name the output columns explicitly, or write the mirrored LEFT JOIN.

PostgreSQL's jsonb || jsonb merges documents structurally. Minnow refuses || whenever either operand is JSONB rather than inventing a text concatenation PostgreSQL does not have.

The @>, <@, ?, ?|, and ?& operators are not supported; compare members with ->> or test presence with JSON_EXISTS.

jsonb_typeof and jsonb_array_length are not supported; JSON_EXISTS, JSON_VALUE, and JSON_QUERY answer most of the same questions.

jsonb_set, jsonb_insert, jsonb_strip_nulls, and json_extract_path_text are not supported; rebuild the document with JSON_OBJECT / json_build_object and read members with -> and ->>.

json_object_agg / jsonb_object_agg are not supported; json_agg of json_build_object pairs is the usual substitute.

The #> and #>> path operators are not supported; chain -> and ->> or use JSON_VALUE with a path.

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.

Bit-string literals and the BIT types are not supported.

A data-modifying statement inside WITH is not supported; run the write, then the read.

Deliberate: mutation segments address rows by unique key, so tables without one cannot be updated or deleted through any API.

The row-value assignment SET (a, b) = (…) is not supported; assign each column.

SET column = DEFAULT and the row-value form SET (a, b) = (…) are not supported; assign the value explicitly.

ON CONFLICT targets the table's primary or row-addressing unique key; a secondary UNIQUE column, a constraint name (ON CONSTRAINT), or a partial-index predicate cannot be the target.

Pattern backreferences are refused explicitly; numbered backreferences remain supported in REGEXP_REPLACE replacement text.

Lookaround and inline regex flags are refused. Use the supported function flags or rewrite the predicate.

Non-greedy regex quantifiers are refused. Supported matching chooses the leftmost, longest result.

An embedded, single-user database in the page has no principals to grant to.

PostgreSQL: An embedded database has no server roles, owners, or GRANT boundary.

TABLESAMPLE is not supported; ORDER BY RANDOM() LIMIT n samples rows.

EXPLAIN is not supported as SQL; the explain() API renders the plan for a query.

One statement per execute() call; a script is split at its semicolons by the caller.

VACUUM, ANALYZE, COMMENT ON, LISTEN, NOTIFY, and DISCARD are server commands with no meaning here; maintenance runs automatically and is driven from the API.

ARRAY(subquery) is not supported; a scalar subquery with json_agg builds the same list as a JSON document.

Schema statements are refused inside BEGIN … COMMIT: the catalog commits outside the scope, so a rollback could not take them back. Run DDL outside a transaction; migration tools that wrap migrations in one need that step split out.

Every transaction reads one snapshot and commits atomically, which satisfies READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ, so those levels are accepted in SET TRANSACTION and BEGIN. SERIALIZABLE promises more than that and is refused rather than silently downgraded.

PostgreSQL: Every transaction reads one snapshot and commits atomically, which satisfies READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ, so those levels are accepted and ignored. SERIALIZABLE promises more than one snapshot can, and is refused rather than silently downgraded.

LOCK TABLE is not supported; a single-session engine has no other session to lock against.

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.

= ANY(array) is not supported; use IN (…) with a list or a subquery.

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.

An aggregate used as a window function cannot take DISTINCT; PostgreSQL rejects this form too. DISTINCT aggregates work in grouped aggregation, so aggregate in a grouped block and window over that.