@crvouga/postgres-mem 0.1.0

package/compat/sections/err.ts

@@ -0,0 +1,16 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const ERR_SECTION: CatalogSection = section("ERR", "Error parity", true, [
+  ["syn-01", "42601 syntax error category"],
+  ["tab-01", "42P01 undefined table"],
+  ["col-01", "42703 undefined column"],
+  ["fn-01", "42883 undefined function"],
+  ["div-01", "22012 division by zero"],
+  ["text-01", "22P02 invalid text representation"],
+  ["uniq-01", "23505 unique violation"],
+  ["null-01", "23502 not-null violation"],
+  ["check-01", "23514 check violation"],
+  ["range-01", "22003 numeric value out of range"],
+  ["state-01", "a failed statement leaves the session usable"],
+  ["state-02", "a constraint failure leaves the table writable"],
+]);

package/compat/sections/exp.ts

@@ -0,0 +1,53 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const EXP_SECTION: CatalogSection = section("EXP", "Expressions & operators", true, [
+  ["arith-01", "Integer division truncates toward zero"],
+  ["arith-02", "Modulo sign follows dividend"],
+  ["arith-03", "Integer division by zero errors"],
+  ["arith-04", "Modulo by zero errors"],
+  ["arith-05", "Numeric division by zero errors"],
+  ["arith-06", "Arithmetic across mixed types"],
+  ["arith-07", "Exponentiation operator ^"],
+  ["concat-01", "|| with NULL yields NULL"],
+  ["concat-02", "|| with non-text operands"],
+  ["concat-03", "integer || integer errors"],
+  ["null-01", "Comparisons with NULL yield NULL"],
+  ["dist-01", "IS DISTINCT FROM / IS NOT DISTINCT FROM"],
+  ["between-01", "BETWEEN and BETWEEN SYMMETRIC"],
+  ["between-02", "BETWEEN with NULL bounds"],
+  ["in-01", "IN lists with NULL"],
+  ["in-02", "IN subquery with NULL rows"],
+  [
+    "in-03",
+    "Row-value IN subquery",
+    D,
+    "memory rejects multi-column row-value IN (SELECT ...) with 'subquery has too many columns'; PostgreSQL evaluates it",
+    undefined,
+    "row-value-subquery-arity",
+  ],
+  ["case-01", "CASE with NULL condition takes ELSE"],
+  ["case-02", "CASE evaluates branches lazily"],
+  ["cond-01", "COALESCE"],
+  ["cond-02", "NULLIF"],
+  ["cond-03", "GREATEST and LEAST ignore NULLs"],
+  ["bool-01", "Three-valued AND/OR/NOT"],
+  ["bool-02", "IS TRUE / IS FALSE / IS UNKNOWN"],
+  ["like-01", "LIKE case sensitivity vs ILIKE"],
+  ["like-02", "LIKE ESCAPE and default backslash escape"],
+  ["like-03", "LIKE with NULL operands"],
+  ["similar-01", "SIMILAR TO patterns"],
+  ["regex-01", "POSIX regex ~ ~* !~ !~*"],
+  ["regex-02", "Regex classes and word boundaries"],
+  ["regex-03", "Invalid regex errors"],
+  ["arrsub-01", "Array subscripting and out-of-bounds NULL"],
+  ["arrsub-02", "Array slices and matrix subscripts"],
+  ["scalar-01", "Scalar subquery with zero rows is NULL"],
+  ["scalar-02", "Scalar subquery with many rows errors"],
+  ["cmp-01", "Text comparison ordering"],
+  ["cmp-02", "Cross-width numeric equality"],
+  ["unary-01", "Unary plus and minus"],
+  ["bit-01", "Bitwise operators on integers"],
+  ["any-01", "ANY and ALL over arrays"],
+]);

package/compat/sections/fun.ts

@@ -0,0 +1,58 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const FUN_SECTION: CatalogSection = section("FUN", "Built-in scalar functions", true, [
+  ["length-01", "length/char_length/octet_length/bit_length"],
+  ["case-01", "upper/lower/initcap"],
+  ["substr-01", "substr and substring forms"],
+  ["substr-02", "Negative substring length errors"],
+  ["trim-01", "trim/ltrim/rtrim/btrim with custom sets"],
+  ["pad-01", "lpad/rpad including truncation"],
+  ["replace-01", "replace and translate"],
+  ["split-01", "split_part including negative index"],
+  ["strpos-01", "strpos and position"],
+  ["leftright-01", "left/right including negative counts"],
+  ["repeat-01", "repeat and reverse"],
+  ["format-01", "format %s %I %L, positional and NULL args"],
+  ["concat-01", "concat and concat_ws NULL handling"],
+  ["regexp-01", "regexp_replace flags and backreferences"],
+  ["regexp-02", "regexp_matches as scalar"],
+  ["regexp-03", "regexp_split_to_array"],
+  ["regexp-04", "regexp_count/regexp_like/regexp_substr"],
+  ["abs-01", "abs across types"],
+  ["ceil-01", "ceil/ceiling/floor"],
+  ["round-01", "round numeric including 2-arg and ties"],
+  [
+    "round-02",
+    "round float8 ties",
+    D,
+    "memory rounds float8 ties away from zero (round(2.5::float8) = 3); PostgreSQL rounds half to even (= 2)",
+    undefined,
+    "round-half-away-from-zero",
+  ],
+  ["trunc-01", "trunc 1-arg and 2-arg"],
+  ["sign-01", "sign across types"],
+  ["moddiv-01", "mod and div sign rules"],
+  ["exp-01", "exp on float8 and numeric"],
+  ["ln-01", "ln on float8 and numeric"],
+  ["ln-02", "ln of negative errors"],
+  ["log-01", "log/log10 and 2-arg log"],
+  ["sqrt-01", "sqrt/cbrt on float8 and numeric"],
+  ["sqrt-02", "sqrt of negative errors"],
+  ["power-01", "power on float8 and numeric"],
+  ["trig-01", "Trigonometric functions"],
+  ["trig-02", "asin out of range errors"],
+  ["trig-03", "Degree-based trig sind/cosd/tand"],
+  ["pi-01", "pi/degrees/radians"],
+  ["wb-01", "width_bucket including out-of-range inputs"],
+  ["tochar-01", "to_char numeric templates"],
+  ["tochar-02", "to_char sign and FM modifiers"],
+  ["md5-01", "md5"],
+  ["encode-01", "encode hex/base64/escape"],
+  ["decode-01", "decode hex and base64"],
+  ["decode-02", "decode invalid hex errors"],
+  ["gcd-01", "gcd and lcm"],
+  ["fact-01", "factorial"],
+  ["nulls-01", "num_nonnulls and num_nulls"],
+]);

package/compat/sections/fzz.ts

@@ -0,0 +1,36 @@
+import { type CatalogSection, type ScenarioRow, section } from "../scenario-types.ts";
+
+const F = "fuzz" as const;
+const P = "property" as const;
+
+const rows: ScenarioRow[] = [
+  ["diff-01", "grammar-based differential fuzz", F, undefined, ["tests/fuzz/differential.test.ts"]],
+  ["expr-01", "expression/predicate fuzz", F, undefined, ["tests/fuzz/expressions.test.ts"]],
+  ["bind-01", "bind-vs-literal and cast fuzz", F, undefined, ["tests/fuzz/typing-binds.test.ts"]],
+  ["like-01", "LIKE/ILIKE and string-function fuzz", F, undefined, ["tests/fuzz/strings-like.test.ts"]],
+  ["date-01", "datetime arithmetic fuzz", F, undefined, ["tests/fuzz/datetime.test.ts"]],
+  ["jsn-01", "jsonb and array operator fuzz", F, undefined, ["tests/fuzz/json-arrays.test.ts"]],
+  ["dml-01", "DML sequence fuzz with state compare", F, undefined, ["tests/fuzz/dml.test.ts"]],
+  ["up-01", "ON CONFLICT upsert fuzz", F, undefined, ["tests/fuzz/upsert.test.ts"]],
+  ["con-01", "constraint violation outcome fuzz", F, undefined, ["tests/fuzz/constraints.test.ts"]],
+  ["fk-01", "FK action fuzz (CASCADE/SET NULL/NO ACTION)", F, undefined, ["tests/fuzz/foreign-keys.test.ts"]],
+  ["join-01", "join-type and predicate fuzz", F, undefined, ["tests/fuzz/joins.test.ts"]],
+  ["agg-01", "GROUP BY/HAVING/FILTER aggregate fuzz", F, undefined, ["tests/fuzz/aggregates.test.ts"]],
+  ["sub-01", "subquery and IN-with-NULL fuzz", F, undefined, ["tests/fuzz/subqueries.test.ts"]],
+  ["win-01", "window frame fuzz", F, undefined, ["tests/fuzz/windows.test.ts"]],
+  ["cte-01", "CTE chain and recursion fuzz", F, undefined, ["tests/fuzz/cte.test.ts"]],
+  ["txn-01", "transaction/savepoint sequence fuzz", F, undefined, ["tests/fuzz/transactions.test.ts"]],
+  ["seq-01", "sequence and serial counter fuzz", F, undefined, ["tests/fuzz/sequences-counters.test.ts"]],
+  ["tlp-01", "ternary logic partitioning metamorphic", F, undefined, ["tests/fuzz/metamorphic/tlp.test.ts"]],
+  ["norec-01", "NoREC metamorphic rewrite", F, undefined, ["tests/fuzz/metamorphic/norec.test.ts"]],
+  ["comb-01", "feature combination fuzz", F, undefined, ["tests/fuzz/combinations.test.ts"]],
+  ["dst-01", "stateful DST dump-after-each engine", F, undefined, ["tests/fuzz/stateful.test.ts"]],
+  ["mix-01", "mixed DDL/DML stateful simulation", F, undefined, ["tests/fuzz/mixed-stateful.test.ts"]],
+  ["robust-01", "PostgresError-only / snapshot bit-flip robustness", F, undefined, ["tests/fuzz/robustness.test.ts"]],
+  ["corpus-01", "corpus regression replay", F, undefined, ["tests/fuzz/corpus.test.ts"]],
+  ["seed-01", "default seed 0x5a17e0e1", P, undefined, ["tests/fuzz/config.ts"]],
+  ["replay-01", "POSTGRES_MEM_FUZZ_SEED / PATH replay", P, undefined, ["tests/fuzz/config.ts"]],
+  ["min-01", "DST minimizer and repro script", P, undefined, ["tests/fuzz/dst/minimize.ts"]],
+];
+
+export const FZZ_SECTION: CatalogSection = section("FZZ", "Differential fuzz & property harness", true, rows);

package/compat/sections/guc.ts

@@ -0,0 +1,27 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const GUC_SECTION: CatalogSection = section("GUC", "SET / SHOW session settings", true, [
+  ["set-01", "SET and SHOW application_name"],
+  ["set-02", "SET application_name TO form"],
+  ["set-03", "later SET overwrites the earlier value"],
+  ["reset-01", "RESET returns to the default"],
+  ["reset-02", "SET TO DEFAULT behaves like RESET"],
+  ["reset-03", "RESET ALL restores defaults"],
+  ["local-01", "SET LOCAL reverts after COMMIT"],
+  ["local-02", "SET LOCAL reverts after ROLLBACK"],
+  ["local-03", "SET LOCAL outside a transaction has no lasting effect"],
+  ["txn-01", "SET inside a rolled-back transaction reverts"],
+  ["txn-02", "SET inside a committed transaction persists"],
+  ["fn-01", "set_config sets a GUC and returns the new value"],
+  ["fn-02", "current_setting reads a value set by SET"],
+  ["fn-03", "current_setting missing_ok true returns NULL for unknown GUC"],
+  ["fn-04", "current_setting missing_ok false works for known GUCs"],
+  ["custom-01", "set_config on a custom two-part GUC name"],
+  ["custom-02", "custom GUC readable with missing_ok before and after set"],
+  ["path-01", "search_path readable through current_setting"],
+  ["tz-01", "SET timezone changes timestamptz rendering"],
+  ["tz-02", "SHOW timezone echoes the setting"],
+  ["ver-01", "SHOW server_version matches the oracle"],
+  ["err-01", "current_setting of an unknown GUC fails with 42704"],
+  ["err-02", "SHOW of an unknown GUC fails with 42704"],
+]);

package/compat/sections/joi.ts

@@ -0,0 +1,33 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const JOI_SECTION: CatalogSection = section("JOI", "Joins & lateral", true, [
+  ["inner-01", "INNER JOIN ON equality"],
+  ["inner-02", "join on expression"],
+  ["comma-01", "implicit comma join with WHERE"],
+  ["cross-01", "CROSS JOIN"],
+  ["left-01", "LEFT JOIN NULL padding"],
+  ["left-02", "extra filter in ON keeps unmatched left rows"],
+  ["left-03", "filter in WHERE turns LEFT JOIN into inner"],
+  ["right-01", "RIGHT JOIN NULL padding"],
+  ["full-01", "FULL JOIN pads both sides"],
+  ["using-01", "USING dedups join column in star"],
+  ["using-02", "qualified and bare join column after USING"],
+  ["natural-01", "NATURAL JOIN on common columns"],
+  ["natural-02", "NATURAL LEFT JOIN"],
+  ["natural-03", "NATURAL join with no common columns is a cross product"],
+  ["chain-01", "three-table join chain"],
+  ["paren-01", "parenthesized join tree"],
+  ["self-01", "self-join with aliases"],
+  ["mixed-01", "mixed INNER and LEFT joins"],
+  ["lat-01", "LATERAL generate_series"],
+  ["lat-02", "LATERAL unnest of an array column"],
+  ["lat-03", "LATERAL correlated subquery with LIMIT"],
+  ["lat-04", "LEFT JOIN LATERAL ON true keeps unmatched rows"],
+  ["semi-01", "semi-join via EXISTS"],
+  ["anti-01", "anti-join via NOT EXISTS"],
+  ["multi-01", "three-plus-table join with aggregate"],
+  ["expr-01", "join on range condition"],
+  ["outer-01", "aggregate over outer-join NULL padding"],
+  ["err-01", "ambiguous column in join errors"],
+  ["err-02", "USING column missing from one side errors"],
+]);

package/compat/sections/jsn.ts

@@ -0,0 +1,46 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const JSN_SECTION: CatalogSection = section("JSN", "JSON & JSONB", true, [
+  ["rt-01", "jsonb canonicalizes key order"],
+  ["rt-02", "jsonb deduplicates keys keeping the last"],
+  ["rt-03", "json preserves order duplicates whitespace"],
+  ["rt-04", "jsonb::text round trip"],
+  ["rt-05", "jsonb number canonicalization"],
+  ["rt-06", "json <-> jsonb conversions"],
+  ["rt-07", "jsonb scalars and json null vs SQL NULL"],
+  ["rt-08", "nested structures and unicode escapes"],
+  ["rt-09", "jsonb column round trips through storage"],
+  ["op-01", "-> field and array index access"],
+  ["op-02", "->> text access and negative index"],
+  ["op-03", "missing key or index yields NULL"],
+  ["op-04", "#> and #>> nested path access"],
+  ["op-05", "@> containment object array nested"],
+  ["op-06", "<@ contained by"],
+  ["op-07", "? ?| ?& existence operators"],
+  ["op-08", "|| concatenation of objects arrays scalars"],
+  ["op-09", "- deletion by key index and key array"],
+  ["op-10", "#- nested path deletion"],
+  ["eq-01", "jsonb equality is structural"],
+  ["fn-01", "jsonb_set replace add nested and array index"],
+  ["fn-02", "jsonb_insert at array positions"],
+  ["fn-03", "strip_nulls for json and jsonb"],
+  ["fn-04", "jsonb_pretty formatting"],
+  ["fn-05", "typeof for json and jsonb kinds"],
+  ["fn-06", "array_length for json and jsonb"],
+  ["fn-07", "jsonb_object_keys"],
+  ["fn-08", "each and each_text set-returning"],
+  ["fn-09", "array_elements and _text with ordinality"],
+  ["fn-10", "extract_path and extract_path_text"],
+  ["fn-11", "build_object and build_array json and jsonb"],
+  ["fn-12", "jsonb_object from a text array"],
+  ["fn-13", "to_json to_jsonb row_to_json"],
+  ["cast-01", "jsonb scalar casts to int and boolean"],
+  ["agg-01", "json_agg and jsonb_agg ordered"],
+  ["agg-02", "json_object_agg and jsonb_object_agg"],
+  ["agg-03", "json aggregates over empty input are NULL"],
+  ["where-01", "containment filters rows in WHERE"],
+  ["err-01", "invalid json text errors"],
+  ["err-02", "trailing garbage after valid json errors"],
+  ["err-03", "jsonb_array_length on an object errors"],
+  ["err-04", "empty string is not valid json"],
+]);

package/compat/sections/lim.ts

@@ -0,0 +1,13 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const LIM_SECTION: CatalogSection = section("LIM", "Limits & pathological inputs", true, [
+  ["depth-01", "deeply parenthesized expression"],
+  ["cmpd-01", "many UNION ALL terms"],
+  ["cols-01", "many columns per table"],
+  ["vals-01", "many VALUES rows"],
+  ["in-01", "large IN list"],
+  ["ident-01", "long identifiers"],
+  ["zero-01", "empty table and empty-string key"],
+  ["zero-02", "SELECT with no FROM"],
+  ["null-01", "all-NULL rows through aggregates"],
+]);

package/compat/sections/par.ts

@@ -0,0 +1,61 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const PAR_SECTION: CatalogSection = section("PAR", "Parser & grammar", true, [
+  ["prec-01", "Exponentiation associativity and unary minus"],
+  ["prec-02", "OR binds looser than AND"],
+  ["prec-03", "NOT binds looser than comparison"],
+  ["prec-04", "IS NULL binds looser than +"],
+  ["prec-05", "BETWEEN binds looser than +"],
+  ["prec-06", ":: binds tighter than unary minus"],
+  ["prec-07", "^ with negative exponent"],
+  ["case-01", "Simple CASE expression"],
+  ["case-02", "Searched CASE expression"],
+  ["case-03", "CASE without ELSE yields NULL"],
+  ["row-01", "Row constructor equality"],
+  ["row-02", "Row constructor ordering"],
+  [
+    "row-03",
+    "Row constructor size mismatch",
+    D,
+    "memory raises 21000 cardinality at execution; PostgreSQL raises 42601 syntax at parse time",
+    undefined,
+    "row-value-subquery-arity",
+  ],
+  ["arr-01", "ARRAY[...] constructor"],
+  ["arr-02", "Nested ARRAY constructor"],
+  ["arr-03", "ARRAY element type mismatch errors"],
+  ["cast-01", "CAST(x AS t) equals x::t"],
+  ["fetch-01", "FETCH FIRST n ROWS ONLY"],
+  ["fetch-02", "OFFSET with FETCH NEXT"],
+  ["fetch-03", "FETCH FIRST WITH TIES"],
+  ["limit-01", "LIMIT and OFFSET"],
+  ["sub-01", "Parenthesized subquery in FROM"],
+  ["exists-01", "EXISTS and NOT EXISTS"],
+  ["in-01", "IN and NOT IN value lists"],
+  ["multi-01", "Multi-statement exec script"],
+  ["syntax-01", "Unknown leading keyword errors"],
+  ["syntax-02", "Unbalanced parentheses error"],
+  ["syntax-03", "Dangling comma in select list errors"],
+  ["values-01", "Standalone VALUES statement"],
+  ["values-02", "VALUES as table expression with aliases"],
+  ["distinct-01", "SELECT DISTINCT"],
+  ["ord-01", "ORDER BY with NULLS FIRST/LAST"],
+  ["grp-01", "GROUP BY with HAVING"],
+  ["alias-01", "Optional AS in aliases"],
+  ["typedlit-01", "Typed literals date and timestamp"],
+  ["typedlit-02", "INTERVAL literal forms"],
+  ["typedlit-03", "Invalid typed literal errors"],
+  ["param-01", "Positional $n parameters"],
+  ["depth-01", "Deeply nested parentheses"],
+  ["reserved-01", "Reserved words misused as identifiers error"],
+  [
+    "neg-01",
+    "Nested unary minus on numeric literals",
+    D,
+    "memory folds repeated unary minus into the literal text and rejects it; PostgreSQL evaluates - -5 to 5",
+    undefined,
+    "unary-minus-folding",
+  ],
+]);

package/compat/sections/pre.ts

@@ -0,0 +1,26 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const PRE_SECTION: CatalogSection = section("PRE", "PREPARE / EXECUTE / DEALLOCATE", true, [
+  ["prep-01", "PREPARE with a typed parameter"],
+  ["prep-02", "PREPARE without declared types infers from usage"],
+  ["prep-03", "PREPARE with multiple typed parameters"],
+  ["prep-04", "text parameter concatenation"],
+  ["exec-01", "EXECUTE runs multiple times"],
+  ["exec-02", "prepared SELECT over a table"],
+  ["exec-03", "prepared statement sees rows inserted after PREPARE"],
+  ["dml-01", "prepared INSERT writes rows"],
+  ["dml-02", "prepared UPDATE and DELETE"],
+  ["txn-01", "EXECUTE inside a transaction commits"],
+  ["txn-02", "EXECUTE rolled back with the transaction"],
+  ["dealloc-01", "DEALLOCATE removes the prepared statement"],
+  ["dealloc-02", "re-PREPARE after DEALLOCATE with a new definition"],
+  ["dealloc-03", "DEALLOCATE PREPARE keyword form"],
+  ["dealloc-04", "DEALLOCATE ALL removes every prepared statement"],
+  ["err-01", "EXECUTE with too few arguments fails"],
+  ["err-02", "EXECUTE with too many arguments fails"],
+  ["err-03", "re-PREPARE of the same name fails with 42P05"],
+  ["err-04", "EXECUTE of an unknown prepared statement fails"],
+  ["err-05", "DEALLOCATE of an unknown prepared statement fails"],
+  ["err-06", "EXECUTE argument that cannot convert fails with 22P02"],
+  ["drop-01", "EXECUTE fails after the referenced table is dropped"],
+]);

package/compat/sections/sch.ts

@@ -0,0 +1,31 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const SCH_SECTION: CatalogSection = section("SCH", "Schemas and search_path", true, [
+  ["create-01", "CREATE SCHEMA and a table inside it"],
+  ["create-02", "CREATE SCHEMA IF NOT EXISTS is idempotent"],
+  ["create-03", "schema appears in pg_namespace"],
+  ["qual-01", "schema-qualified insert, update, select"],
+  ["qual-02", "schema-qualified delete"],
+  ["dup-01", "same table name in two schemas holds separate data"],
+  ["join-01", "join across schemas"],
+  ["seq-01", "sequence inside a schema"],
+  ["view-01", "view inside a schema"],
+  ["fk-01", "cross-schema foreign key enforced"],
+  ["drop-01", "DROP SCHEMA removes an empty schema"],
+  ["drop-02", "DROP SCHEMA without CASCADE fails when non-empty"],
+  ["drop-03", "DROP SCHEMA CASCADE removes contained tables"],
+  ["drop-04", "DROP SCHEMA CASCADE removes sequences and views"],
+  ["drop-05", "DROP SCHEMA IF EXISTS on a missing schema is a no-op"],
+  ["drop-06", "dropping one schema leaves the same-named table elsewhere"],
+  ["path-01", "search_path picks the first schema containing the table"],
+  ["path-02", "resolution falls through schemas missing the table"],
+  ["path-03", "CREATE TABLE goes to the first schema on the search_path"],
+  ["path-04", "current_schema reflects the first search_path entry"],
+  ["path-05", "qualified names bypass the search_path"],
+  ["path-06", "current_schemas lists the effective path"],
+  ["cat-01", "pg_catalog builtins visible regardless of search_path"],
+  ["cat-02", "pg_catalog tables visible regardless of search_path"],
+  ["alter-01", "ALTER TABLE SET SCHEMA moves the table"],
+  ["err-01", "CREATE TABLE in a missing schema fails with 3F000"],
+  ["err-02", "duplicate schema fails with 42P06"],
+]);

package/compat/sections/sel.ts

@@ -0,0 +1,43 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const SEL_SECTION: CatalogSection = section("SEL", "SELECT surface", true, [
+  ["proj-01", "star projection"],
+  ["proj-02", "qualified t.* projection"],
+  ["alias-01", "output alias usable in ORDER BY"],
+  ["alias-02", "output alias usable in GROUP BY"],
+  ["alias-03", "output alias not visible in WHERE"],
+  ["dist-01", "DISTINCT dedups rows and NULLs"],
+  ["diston-01", "DISTINCT ON picks first row per group"],
+  ["diston-02", "DISTINCT ON with multiple expressions"],
+  ["order-01", "ORDER BY mixed ASC and DESC"],
+  ["order-02", "ORDER BY NULLS FIRST and NULLS LAST"],
+  ["order-03", "ORDER BY expression"],
+  ["order-04", "ORDER BY ordinal position"],
+  ["order-05", "ORDER BY ordinal out of range errors"],
+  ["limit-01", "LIMIT with OFFSET"],
+  ["fetch-01", "OFFSET n ROWS FETCH NEXT n ROWS ONLY"],
+  ["fetch-02", "FETCH FIRST n ROWS WITH TIES"],
+  ["set-01", "UNION dedups across branches"],
+  ["set-02", "UNION ALL keeps duplicates"],
+  ["set-03", "INTERSECT"],
+  ["set-04", "EXCEPT"],
+  ["set-05", "set-op numeric type resolution"],
+  ["set-06", "ORDER BY and LIMIT apply to whole compound"],
+  ["set-07", "set-op column count mismatch errors"],
+  ["values-01", "VALUES as a FROM table with aliases"],
+  ["group-01", "GROUP BY expression"],
+  ["group-02", "GROUP BY with HAVING"],
+  ["group-03", "GROUPING SETS"],
+  ["group-04", "ROLLUP"],
+  ["group-05", "CUBE with grouping()"],
+  ["having-01", "HAVING without GROUP BY"],
+  ["sub-01", "scalar subquery in select list"],
+  ["sub-02", "IN subquery"],
+  ["sub-03", "correlated EXISTS subquery"],
+  ["sub-04", "ANY and ALL subquery comparisons"],
+  ["row-01", "row-value comparisons"],
+  ["row-02", "row-value filter on table columns"],
+  ["case-01", "CASE expression in projection"],
+  ["talias-01", "table alias with column aliases"],
+  ["corr-01", "correlated scalar subquery in projection"],
+]);

package/compat/sections/seq.ts

@@ -0,0 +1,31 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const SEQ_SECTION: CatalogSection = section("SEQ", "Sequences", true, [
+  ["create-01", "CREATE SEQUENCE defaults start at 1"],
+  ["create-02", "START WITH sets the first value"],
+  ["create-03", "INCREMENT BY controls the step"],
+  ["create-04", "negative INCREMENT counts down from -1"],
+  ["create-05", "MINVALUE and MAXVALUE bound the range"],
+  ["cycle-01", "CYCLE wraps to MINVALUE after MAXVALUE"],
+  ["cycle-02", "descending CYCLE wraps to MAXVALUE"],
+  ["curr-01", "currval reflects the last nextval"],
+  ["curr-02", "currval before nextval fails with 55000"],
+  ["setval-01", "two-argument setval moves the sequence"],
+  ["setval-02", "setval is_called false replays the value"],
+  ["setval-03", "setval is_called true skips the value"],
+  ["last-01", "lastval tracks the most recent nextval"],
+  ["last-02", "lastval before any nextval fails with 55000"],
+  ["serial-01", "serial column auto-increments"],
+  ["serial-02", "bigserial column is bigint typed"],
+  ["serial-03", "explicit value bypasses the serial default"],
+  ["serial-04", "serial backing sequence drops with the table"],
+  ["serial-05", "currval usable after a serial insert"],
+  ["ident-01", "GENERATED BY DEFAULT AS IDENTITY auto-increments"],
+  ["default-01", "nextval as a column DEFAULT"],
+  ["drop-01", "DROP SEQUENCE removes it from pg_class"],
+  ["drop-02", "DROP SEQUENCE of a missing sequence fails"],
+  ["exh-01", "ascending exhaustion fails with 2200H"],
+  ["exh-02", "descending exhaustion fails with 2200H"],
+  ["alter-01", "ALTER SEQUENCE RESTART resets the sequence"],
+  ["alter-02", "ALTER SEQUENCE INCREMENT BY changes the step"],
+]);

package/compat/sections/snp.ts

@@ -0,0 +1,21 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+const SNAP_NOTE = "custom PGMM codec, no oracle analog";
+const EXTRA = ["tests/contract/snapshots/"];
+const DIV = "pgmm-snapshot-codec";
+
+export const SNP_SECTION: CatalogSection = section("SNP", "Snapshot / restore", true, [
+  ["rt-01", "round-trip schema and rows", D, SNAP_NOTE, EXTRA, DIV],
+  ["rt-02", "round-trip all datum kinds", D, SNAP_NOTE, EXTRA, DIV],
+  ["rt-03", "round-trip sequence counters", D, SNAP_NOTE, EXTRA, DIV],
+  ["rt-04", "round-trip PRNG and clock", D, SNAP_NOTE, EXTRA, DIV],
+  ["rt-05", "round-trip enums domains views functions", D, SNAP_NOTE, EXTRA, DIV],
+  ["byte-01", "byte-identical snapshots for equivalent state", D, SNAP_NOTE, EXTRA, DIV],
+  ["hdr-01", "PGMM magic and LE u32 version", D, SNAP_NOTE, EXTRA, DIV],
+  ["hdr-02", "corrupt magic errors distinctly", D, SNAP_NOTE, EXTRA, DIV],
+  ["hdr-03", "truncated blob errors", D, SNAP_NOTE, EXTRA, DIV],
+  ["hdr-04", "future version raises snapshot_version", D, SNAP_NOTE, EXTRA, DIV],
+  ["txn-01", "restore during transaction errors", D, SNAP_NOTE, EXTRA, DIV],
+  ["rep-01", "restore replaces entire state", D, SNAP_NOTE, EXTRA, DIV],
+]);

package/compat/sections/tok.ts

@@ -0,0 +1,53 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const TOK_SECTION: CatalogSection = section("TOK", "Tokenizer & lexical layer", true, [
+  ["kw-01", "Keywords are case-insensitive"],
+  ["ident-01", "Quoted identifiers preserve case"],
+  ["ident-02", "Embedded quotes in quoted identifiers"],
+  ["ident-03", "Unquoted identifiers fold to lowercase"],
+  ["ident-04", "Quoted keywords usable as identifiers"],
+  ["ident-05", "Identifiers with $ and _"],
+  ["ident-06", "Unicode identifiers"],
+  ["ident-07", "Unknown quoted identifier is a column error"],
+  ["str-01", "Standard string '' escape"],
+  ["str-02", "String literal with embedded newline"],
+  ["str-03", "Empty string literal"],
+  ["str-04", "Newline-separated string literal concatenation"],
+  ["str-05", "Backslash is literal in standard strings"],
+  ["str-06", "Same-line adjacent string literals error"],
+  ["str-07", "Unterminated string literal errors"],
+  ["estr-01", "E-string tab and newline escapes"],
+  ["estr-02", "E-string backslash escape"],
+  ["estr-03", "E-string unicode escapes"],
+  ["estr-04", "E-string hex and octal escapes"],
+  ["dollar-01", "Dollar-quoted string $$..$$"],
+  ["dollar-02", "Tagged dollar quotes including mixed-case tags"],
+  ["dollar-03", "Multiline dollar-quoted string"],
+  ["num-01", "Integer literals"],
+  ["num-02", "Decimal literal forms"],
+  ["num-03", "Scientific notation"],
+  ["num-04", "Hexadecimal integer literals"],
+  ["num-05", "Underscore digit separators"],
+  ["num-06", "Binary and octal integer literals"],
+  ["bytea-01", "Bytea hex literal"],
+  ["cast-01", ":: cast operator"],
+  ["cmt-01", "Line comments -- to EOL"],
+  ["cmt-02", "Block comments /* */"],
+  ["cmt-03", "Nested block comments"],
+  [
+    "cmt-04",
+    "Comment-only script",
+    D,
+    "memory rejects a statement-free script as an empty statement; PostgreSQL accepts it",
+    undefined,
+    "empty-script-rejected",
+  ],
+  ["op-01", "JSON arrow operator tokens -> and ->>"],
+  ["op-02", "Containment operator token @>"],
+  ["op-03", "Comparison operator tokens <> != <= >="],
+  ["semi-01", "Trailing semicolon on a single query"],
+  ["ws-01", "Tab and CRLF whitespace between tokens"],
+  ["uesc-01", "U& unicode escape string"],
+]);

package/compat/sections/trg.ts

@@ -0,0 +1,57 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+const REPORT = ["tests/contract/_reports/session-system.md"];
+
+export const TRG_SECTION: CatalogSection = section("TRG", "Triggers", true, [
+  ["bi-01", "BEFORE INSERT trigger assigns a NEW column"],
+  ["bi-02", "BEFORE INSERT trigger computes from another NEW column"],
+  ["bi-03", "BEFORE INSERT returning NULL suppresses the row"],
+  ["bi-04", "IF ELSIF ELSE chain in a trigger body"],
+  ["when-01", "WHEN clause limits trigger firing"],
+  ["when-02", "WHEN clause comparing OLD and NEW on update"],
+  ["bu-01", "BEFORE UPDATE trigger reads OLD and writes NEW"],
+  ["bu-02", "BEFORE UPDATE returning NULL suppresses the update"],
+  ["bu-03", "BEFORE UPDATE trigger can override the assigned value"],
+  ["bd-01", "BEFORE DELETE returning NULL suppresses the delete"],
+  ["bd-02", "BEFORE DELETE returning OLD allows the delete"],
+  ["ai-01", "AFTER INSERT returning NULL does not suppress the row"],
+  ["multi-01", "one trigger function attached to INSERT and UPDATE"],
+  ["sel-01", "trigger fires for INSERT ... SELECT rows"],
+  ["chain-01", "two BEFORE INSERT triggers chain their effects"],
+  ["raise-01", "RAISE EXCEPTION in BEFORE INSERT blocks the insert"],
+  ["raise-02", "conditional RAISE EXCEPTION only fires for matching rows"],
+  ["raise-03", "rows below the RAISE threshold insert normally"],
+  ["raise-04", "trigger exception recovered with a savepoint"],
+  ["drop-01", "DROP TRIGGER stops the trigger from firing"],
+  ["drop-02", "DROP TRIGGER of a missing trigger fails"],
+  ["drop-03", "DROP TRIGGER IF EXISTS on a missing trigger is a no-op"],
+  ["life-01", "duplicate trigger name on the same table fails"],
+  ["life-02", "same trigger name on different tables is allowed"],
+  ["life-03", "dropping the table removes its triggers implicitly"],
+  ["event-01", "trigger only fires for its declared event"],
+  [
+    "order-01",
+    "multiple-trigger firing order is creation order, not alphabetical",
+    D,
+    "memory fires triggers in creation order; PostgreSQL fires them in name order",
+    REPORT,
+    "trigger-order-creation",
+  ],
+  [
+    "updof-01",
+    "UPDATE OF column lists are ignored",
+    D,
+    "memory fires a BEFORE UPDATE OF a trigger even when the UPDATE only touches other columns",
+    REPORT,
+    "trigger-update-of-ignored",
+  ],
+  [
+    "instead-01",
+    "INSTEAD OF triggers on views are unsupported",
+    D,
+    "CREATE TRIGGER ... INSTEAD OF on a view fails in memory; PostgreSQL supports it",
+    undefined,
+    "instead-of-triggers-unsupported",
+  ],
+]);