diff --git a/AGENT_CHAT.md b/AGENT_CHAT.md index 8e620d8f..9c0ca954 100644 --- a/AGENT_CHAT.md +++ b/AGENT_CHAT.md @@ -1,5 +1,9 @@ # RedlineDB Agent Chat +## 2026-09-25T09:00Z docs/parity-record + +Claim: canonical checkout `/home/ubuntu/redlineDB`, branch `docs/parity-record` from `origin/main` `d5d1c57bbab97bf43d0b74cdfd0a660aa4bfe6b2`. The Postgres skip list and `docs/beyond-postgres-skips.md` now say the 265-case gate already passes, including the 88 entries that were still marked deferred. No SQL change. No generated README block edit. No worktree. + ## 2026-09-25T01:20Z fix/index-wal-before-page Claim: canonical checkout `/home/ubuntu/redlineDB`, branch `fix/index-wal-before-page` from `origin/main` `28196cdf31eebc1f466920aa0f2b6200d85e8720`. A non-splitting leaf insert stages the new page privately, appends the WAL record, then installs that page and its LSN under one frame lock. A crash at `index::insert` leaves the leaf unchanged. No worktree. diff --git a/docs/beyond-postgres-skips.md b/docs/beyond-postgres-skips.md index 2d0ac2ef..e5a24289 100644 --- a/docs/beyond-postgres-skips.md +++ b/docs/beyond-postgres-skips.md @@ -1,221 +1,70 @@ -# Beyond-Postgres skip-list policy - -This document explains which beyond-SQLite cases in the corpus we deliberately -do NOT attempt to close against RedlineDB, and why. - -The full skip set lives in [`metadata/beyond_sqlite/skip-list.toml`](../metadata/beyond_sqlite/skip-list.toml). -The list of cases we DO intend to close lives at -`/home/ubuntu/redlineDB/target/redline-testing/closable-beyond-pg.txt` after each -target-vs-reference triage pass. - -## When to add a skip entry - -Add a `[[skip]]` entry ONLY when one or more of the following is true: - -1. **No SQLite-shape analog.** The case requires a feature that has no - reasonable mapping into SQLite-shaped surfaces — e.g. first-class array - types, `LOCK TABLE` semantics, role-based `GRANT`, `LISTEN/NOTIFY` - pub/sub, `CREATE SUBSCRIPTION` replication, `CREATE PROCEDURE` with own - block-level state. -2. **Would require a new top-level surface.** Implementing it would require - adding a new top-level type, a new privilege/session model, or a new - system-catalog surface that does not fit a `sqlite_master`-style - introspection model. -3. **No acceptable lower-fidelity port.** There is no acceptable - lower-fidelity portable shape that would still pass the case (e.g. - storing UUIDs as TEXT is fine; storing MONEY as TEXT defeats typed - arithmetic). - -Cases that are stdout-diff-only (e.g. boolean `t/f` vs `1/0`, decimal -precision rendering, JSONB key reordering) are **NOT** skips. Those are -closable via either normalizer extensions on the testing side or rendering -parity in redlinedb. - -## Skip-set sizing - -Current beyond-SQLite shard size: 265 cases. - -Total corpus target at full build-out (sqlite_parity + beyond_sqlite + -generated_matrix): ~2,710 cases. - -| Quantity | Count | % of 265 beyond | % of 2,710 corpus | -|---|---:|---:|---:| -| Beyond-SQLite cases | 265 | 100% | 9.8% | -| Self-compare passes (psql) | 253 | 95.5% | 9.3% | -| Self-compare skips | 12 | 4.5% | 0.4% | -| Target-vs-reference passes | 20 | 7.5% | 0.7% | -| Target-vs-reference failures | 233 | 87.9% | 8.6% | -| -- skipped as PG-only (this policy) | **114** | **43.0%** | **4.2%** | -| -- triaged closable in pure Rust | 119 | 44.9% | 4.4% | - -**Cap.** A previous draft of this policy proposed a 30-entry cap. After -triaging all 233 beyond-SQLite failures, that cap is too tight: the -fundamental PG-only feature surfaces (matviews, stored procedures, logical -replication, LISTEN/NOTIFY, advisory locks) alone contribute 75 deliberately -deferred cases. Raising the cap to **150 entries** keeps us inside the -1%-5% band against the 2,710 target while leaving ~36 entries of headroom for -future beyond-PG additions (e.g. partitioning, FDWs, row-level security) -that have not yet been added to the corpus. - -## Per-category rationale - -### BEYOND_LISTEN_NOTIFY -- 14 skipped (of 14 failed) - -All 14 LISTEN/NOTIFY cases skip. LISTEN/NOTIFY is a session-bound async pub/sub -IPC primitive. Implementing it would require a connection-scoped event queue, a -multi-session signaling layer, and a NOTIFY catalog surface that does not fit -SQLite-shape introspection. Adjacent cases that combine NOTIFY with PL/pgSQL -functions or triggers are also deferred because they depend on the (also -deferred) stored-procedures surface. - -### BEYOND_STORED_PROCEDURES -- 19 skipped (of 19 failed) - -All 19 stored-procedure cases skip. `CREATE FUNCTION` / `CREATE PROCEDURE` / -`CALL` / PL/pgSQL require a `pg_proc`-style catalog, a SQL-bodied function -executor, AND a full PL/pgSQL interpreter (DECLARE blocks, control flow, -EXCEPTION blocks, `RETURN NEXT`/`RETURN QUERY`). SQLite has user-defined -functions only via the host API (not via SQL DDL) and has no procedural -language at the SQL level. The compound surface area is too large to absorb -into a SQLite-shaped engine and is therefore deliberately deferred as a single -scope cut. - -### BEYOND_REPLICATION_CDC -- 13 skipped (of 13 failed) - -All 13 replication/CDC cases skip. This category exercises Postgres -logical-replication infrastructure (`CREATE PUBLICATION`/`SUBSCRIPTION`, -`pg_replication_slots`, `pg_stat_replication`), WAL LSN inspection -(`pg_current_wal_lsn`, `pg_wal_lsn_diff`), and replication GUCs (`wal_level`, -`session_replication_role`). All require a server topology — multi-backend -processes, WAL streaming, replication slot management — that does not fit -RedlineDB's single-process embedded model. - -### BEYOND_MATERIALIZED_VIEWS -- 20 skipped (of 20 failed) - -All 20 materialized-view cases skip. `CREATE/REFRESH/DROP MATERIALIZED VIEW` -requires a new storage surface that caches query results separately from -regular tables AND from `VIEW` definitions. SQLite has only `VIEW` -(always-recomputed); the materialized variant would require new catalog rows, -new physical storage, a refresh protocol, and snapshot isolation from base -relations. The `REFRESH CONCURRENTLY` variant additionally requires the -unique-index-driven row-diff merge. Deferred as a single integrated surface. - -### BEYOND_MVCC_LOCKING -- 9 skipped (of 10 failed) - -9 of 10 MVCC/locking cases skip. The row-level lock matrix (FOR KEY SHARE / -SHARE / NO KEY UPDATE / UPDATE), `pg_locks`, advisory locks (`pg_advisory_lock` -/ `pg_try_advisory_lock`), `LOCK TABLE` explicit relation locks, and -backend/xact introspection (`pg_backend_pid`, `txid_current`, -`pg_current_xact_id`) all require Postgres's heavyweight lock manager and -per-backend identity surface, none of which fit SQLite's implicit -RESERVED/PENDING/EXCLUSIVE lock progression. One case in the category -(`SET_TRANSACTION_ISOLATION_LEVELS`) is treated as closable because the SQL -shape parses cleanly and only the executor binding is missing. - -### BEYOND_COLLATIONS_ILIKE -- 8 skipped (of 25 failed) - -8 of 25 collation cases skip. The deep skips are the `citext` extension (3 -cases: first-class case-insensitive text type, requires an extension loader -plus pg_type entry), named ICU collations like `"en-x-icu"` and `"und-x-icu"` -(3 cases: SQLite has only `BINARY`/`NOCASE`/`RTRIM` plus host-registered -collations), and `CREATE COLLATION ... deterministic = false` (2 cases: -nondeterministic equality breaks SQLite's reflexive byte-equality assumption). -The remaining 17 cases (ILIKE rendering, `LOWER`/`UPPER` on multibyte, regex -match operators, `SIMILAR TO`, `POSITION`, `octet_length`) are returned as -closable in pure Rust. - -### BEYOND_RICH_TYPES -- 6 skipped (of 28 failed) - -6 of 28 rich-type cases skip. The deep skips are ENUM and DOMAIN (require -`pg_type` catalog), range types (`int4range` with `@>` and `&&`), MONEY -(locale-sensitive currency rendering), and the geometric type family (POINT, -LINE, BOX, distance operator `<->`). All require new top-level types that do -not fit the SQLite TEXT/INTEGER/REAL/BLOB/NULL storage classes. The remaining -22 cases (booleans as `t`/`f`, decimal precision via TEXT storage, UUID as -TEXT/BLOB, intervals/timestamptz as text, arrays as JSON-shaped TEXT, JSONB -roundtrip) are returned as closable — most via normalizer extensions or -rendering parity changes in redlinedb. - -### BEYOND_MIGRATION_ERGONOMICS -- 6 skipped (of 17 failed) - -6 of 17 migration-ergonomics cases skip. The skips target ALTER TABLE knobs -that operate on Postgres-specific physical layout concepts: INHERIT/NO -INHERIT (table inheritance), SET UNLOGGED/LOGGED (per-table WAL -participation), SET STATISTICS (per-column ANALYZE target), SET STORAGE -(per-column TOAST strategy), SET (autovacuum_enabled), OWNER TO + SET -WITHOUT CLUSTER (role/owner model + CLUSTER heap rewrite). The remaining 11 -cases (ALTER COLUMN TYPE USING, SET/DROP DEFAULT, DROP NOT NULL, ADD/DROP -CONSTRAINT, ADD/DROP IDENTITY, RENAME CONSTRAINT, RENAME INDEX) are core -schema evolution that is returned as closable. - -### BEYOND_SCHEMAS_SEQUENCES -- 4 skipped (of 18 failed) - -4 of 18 schema/sequence cases skip. The skips are the per-session search_path -stack (3 cases: SET search_path, current_schema(), SET search_path TO '') and -CREATE SCHEMA AUTHORIZATION (1 case: requires Postgres role/owner model). -SQLite has ATTACH DATABASE for cross-namespace access but no per-session -search_path; implementing would require a new session-settings surface plus a -dynamic resolver. The remaining 14 cases (CREATE/DROP SCHEMA, schema-qualified -table/sequence references, CREATE SEQUENCE, nextval/currval/setval, identity -columns) are returned as closable. - -### BEYOND_VECTOR_ADVANCED_INDEXES -- 15 skipped (of 17 failed) - -15 of 17 advanced-index cases skip. RedlineDB DOES have its own vector indexes -(HNSW, DiskANN, IVFFlat) — these are tracked under the closable list when -expressed in portable shape. Skipped here are PG-specific access methods -(BRIN — heap-page-shaped, Hash — no SQLite AM analog, GIN/GiST/SP-GiST on -range/point — depend on PG-only types) and the FTS family -(`to_tsvector`/`to_tsquery`/`ts_rank` requires snowball dictionaries and a -ts_config registry), plus the trigram/btree-helper extensions (pg_trgm, -btree_gin, btree_gist). The two cases returned as closable are -`INDEX_UNIQUE_PARTIAL` and `INDEX_EXPR_AND_INCLUDE`, which exercise B-tree -CREATE INDEX features that redlinedb already supports. - -### BEYOND_PORTABILITY_SYNTAX -- 0 skipped (of 32 failed) - -All 32 portability-syntax cases are returned as closable. This category -covers parser-level work that has a portable SQL standard form: MERGE -(SQLite 3.39+ also has it), LATERAL joins, data-modifying CTEs, DISTINCT ON, -named windows, FETCH FIRST/NEXT ROWS, GROUPING SETS / ROLLUP / CUBE, ARRAY -literals at parser level, ON CONFLICT WHERE, GENERATED AS IDENTITY. None of -these require a new top-level surface; they require parser productions and -plan-node wiring. - -### BEYOND_JSONB_INDEXING -- 0 skipped (of 20 failed) - -All 20 JSONB cases are returned as closable. JSONB containment (`@>`/`<@`), -key-existence (`?`/`?|`/`?&`), path operators (`->`/`->>`/`#>`/`#>>`), -mutation (`jsonb_set`/`jsonb_insert`/`jsonb_strip_nulls`/`jsonb_pretty`), and -removal (`-`/`#-`) are pure-Rust JSON-traversal work over the existing JSONB -storage. The `@@` jsonpath operator and `jsonb_path_exists`/`jsonb_path_query` -need a jsonpath parser, also pure Rust. Several cases just need parser wiring -for `?` / `?|` / `?&` operators (they currently parse-error). - -## Closable work tracks - -The 119 closable failures are listed in -`/home/ubuntu/redlineDB/target/redline-testing/closable-beyond-pg.txt` so -future agents can pick up specific tracks. The natural parallel tracks are: - -1. **BEYOND_PORTABILITY_SYNTAX (32)** -- parser-level work: MERGE, LATERAL, - data-modifying CTEs, DISTINCT ON, named windows, FETCH FIRST/NEXT ROWS, - GROUPING SETS / ROLLUP / CUBE, ARRAY literals, ON CONFLICT WHERE, GENERATED - AS IDENTITY (sequence-backed). -2. **BEYOND_RICH_TYPES (22)** -- normalizer extensions and rendering parity: - booleans as `t`/`f`, decimal precision, UUID/interval/timestamptz/jsonb - roundtrip, array shape. -3. **BEYOND_JSONB_INDEXING (20)** -- JSON traversal operators and functions - in pure Rust over existing JSONB storage; jsonpath parser for `@@`. -4. **BEYOND_COLLATIONS_ILIKE (17)** -- ILIKE rendering, multibyte - LOWER/UPPER, regex match operators (`~`/`~*`/`!~`/`!~*`), `SIMILAR TO`, - `POSITION`, `octet_length`. -5. **BEYOND_SCHEMAS_SEQUENCES (14)** -- CREATE/DROP SCHEMA, schema-qualified - references, CREATE SEQUENCE, nextval/currval/setval, GENERATED AS IDENTITY - round-trip. -6. **BEYOND_MIGRATION_ERGONOMICS (11)** -- ALTER COLUMN TYPE USING, - SET/DROP DEFAULT, DROP NOT NULL, ADD/DROP CONSTRAINT, RENAME CONSTRAINT, - RENAME INDEX, ADD/DROP IDENTITY. -7. **BEYOND_VECTOR_ADVANCED_INDEXES (2)** -- INDEX_UNIQUE_PARTIAL, - INDEX_EXPR_AND_INCLUDE. -8. **BEYOND_MVCC_LOCKING (1)** -- SET_TRANSACTION_ISOLATION_LEVELS executor - binding. +# Beyond-Postgres record + +The execution gate and this document now say the same thing. + +The beyond-SQLite corpus is 265 cases, every one `ordered_rows`, compared with +PostgreSQL 16.15 through the SQL shell. On `d5d1c57bb` the regression file +`metadata/beyond_sqlite/postgres-regression.json` has an empty `failed_cases` +list. The README block reports **265 / 265 passed, 0 failed, 0 skipped**. +Hosted `parity (redline-testing-official)` on that tree was green. + +A pass is both engines exiting 0, or one of the 12 declared rejections whose +stderr the corpus names. A skip is not a pass. The gate re-derives that rule +in `subrepos/redline-testing/src/beyond_sqlite/gate/cases.rs`. The skip list +does not remove a case from the run. + +## Declared rejections + +These scripts stay failures. Both engines exit non-zero and the target stderr +contains the listed text. + +| Case | Text | +| --- | --- | +| 20021 | `invalid input value for enum color: "purple"` | +| 20023 | `value for domain positive_int2 violates check constraint "positive_int2_check"` | +| 20103 | `syntax error at or near "BY"` | +| 20111 | `SELECT DISTINCT ON expressions must match initial ORDER BY expressions` | +| 20136, 20247 | `cannot insert a non-DEFAULT value into column "id"` | +| 20203 | `NOT NULL constraint failed` | +| 20308 | `ERROR: boom` | +| 20340 | `extension "vector" is not available` | +| 20418, 20429 | `logical decoding requires wal_level >= logical` | +| 20438 | `syntax error at or near "ALL"` | + +## Skip list + +`metadata/beyond_sqlite/skip-list.toml` has 117 entries. All 117 are +`target_release = "closed"`. A closed entry stays in the file so the old +rationale remains, and it leaves the deferred denominator +(`skip_list.rs`: deferred means any value other than `closed`). + +88 of those entries were still marked `deferred` after the corpus scripts had +started passing. That included `LISTEN`, `CREATE MATERIALIZED VIEW`, `citext` +equality, enum use, `INHERIT`, `search_path`, and a `BRIN` count. The gate +executed them. Closing the entry records that the **corpus script** passes. +It does not claim the PostgreSQL wire protocol, roles, or the rest of the +manual page. + +The same file is copied at: + +- `subrepos/redline-testing/metadata/beyond_sqlite/skip-list.toml` (the runner compiles this copy) +- `subrepos/redline/metadata/beyond_sqlite/skip-list.toml` + +Those three copies stay identical. + +## What this is not + +PostgreSQL wire, TLS, roles, and SQLSTATE are unverified. `CREATE EXTENSION +vector`, logical decoding, `MERGE … WHEN NOT MATCHED BY SOURCE`, and +`LISTEN ALL` stay errors, as the table above says. SQLite format 3 is not the +runtime database. + +## Historical triage + +An earlier pass, against `target/redline-testing/beyond_pg_baseline.jsonl`, +triaged 233 failures: about 114 were written into this skip list and about +119 were called closable in pure Rust. The category sections that used to +live here ("14 skipped of 14 failed", and the same shape for procedures, +replication, materialized views, locks, collations, types, migration, +schemas, and indexes) described that triage. They are not the current score. +The current score is 265 / 265 with the 12 rejections above. diff --git a/docs/sqlite-parity.md b/docs/sqlite-parity.md index 2378fbe2..958b442a 100644 --- a/docs/sqlite-parity.md +++ b/docs/sqlite-parity.md @@ -62,12 +62,12 @@ Status values are deliberately narrow: |---|---|---|---|---| | Basic `SELECT` projection/filter/order | pass | `crates/sql/tests/smoke_select.rs`, `crates/sql/tests/differential_lab.rs` | sql-parser-planner-executor | Covered for scalar values and simple predicates. | | `INSERT`, `UPDATE`, `DELETE` basics | pass | `crates/sql/tests/smoke_dml.rs`, `crates/bench/compat/**` | sql-parser-planner-executor | Cross-engine SQLLogicTest corpus covers representative DML. | -| `CREATE TABLE`, `DROP TABLE` basics | partial | `crates/bench/compat/**`, `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Basic create/drop behavior is covered; SQLite metadata compatibility is not complete. | +| `CREATE TABLE`, `DROP TABLE` basics | partial | `crates/bench/compat/**`, `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and covers basic create/drop. This row stays partial because SQLite metadata compatibility is not complete. | | `CREATE TABLE AS SELECT` | pass | `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | CTAS names, declared types, row order, `IF NOT EXISTS` short-circuiting, and rollback on source-query failure are covered against `rusqlite`. | | `CREATE INDEX`, `DROP INDEX` basics | pass | `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Basic B-tree-backed indexes only. | -| `ALTER TABLE RENAME TABLE/COLUMN` | partial | `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Rename table/column behavior is covered; add/drop-column variants remain partial. | +| `ALTER TABLE RENAME TABLE/COLUMN` | partial | `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and covers rename of tables and columns. This row stays partial because add/drop-column variants are outside that covered subset. | | `RETURNING` expressions | pass | `crates/sql/tests/parity_coverage.rs` | sql-parser-planner-executor | Insert/update expressions covered. | -| UPSERT `ON CONFLICT DO UPDATE` representative path | partial | `crates/bench/compat/orm/migration.sqlt`, `crates/sql/tests/phase10_sqlc_conflict_matrix.rs` | sql-parser-planner-executor | Representative path is covered; full SQLite conflict matrix is still incomplete. | +| UPSERT `ON CONFLICT DO UPDATE` representative path | partial | `crates/bench/compat/orm/migration.sqlt`, `crates/sql/tests/phase10_sqlc_conflict_matrix.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and covers the representative `ON CONFLICT DO UPDATE` path. This row stays partial because the full SQLite conflict matrix is outside that covered subset. | | Savepoints | pass | `crates/sql/tests/parity_coverage.rs`, `crates/sql/tests/phase10_sqlb.rs` | sql-parser-planner-executor | Nested savepoint behavior has focused coverage. | | Joins and left joins | pass | `crates/sql/tests/parity_coverage.rs`, `crates/sql/tests/smoke_select.rs`, `crates/sql/tests/differential_lab.rs`, `crates/bench/compat/orm/queries.sqlt` | sql-parser-planner-executor | Explicit join forms are covered. NATURAL JOIN and USING merged-column output semantics are implemented (W9-T9, `72b4107`); corpus cases 10445/10451/10466 pass. Cross joins, self-joins, and multi-way joins have coverage via `differential_lab`. | | Row-value `IN` subqueries | pass | `crates/sql/tests/parity_coverage.rs`, `crates/sql/tests/differential_lab.rs` | sql-parser-planner-executor | Representative row-value `IN`/`NOT IN` covered. | @@ -75,13 +75,13 @@ Status values are deliberately narrow: | CTEs (`WITH`, recursive and non-recursive) | pass | `crates/sql/tests/parity_cte.rs` | sql-parser-planner-executor | A3: non-recursive + recursive (UNION / UNION ALL) materialized into thread-local row store; accepts `AS MATERIALIZED` / `AS NOT MATERIALIZED` as no-op hints and supports JOIN against CTE via synthetic TableDef. Iteration cap 10_000. | | Compound `SELECT` (`UNION`, `INTERSECT`, `EXCEPT`) | pass | `crates/sql/tests/parity_compound_select.rs`, `crates/sql/tests/parity_order_by_ordinal.rs` | sql-parser-planner-executor | A2: UNION / UNION ALL / INTERSECT / EXCEPT all wired through the parser and exec layers; column-arity and type-class mismatches return diagnostic errors that match SQLite's error class. Parameterized compound branches and trailing wrapper `ORDER BY` / `LIMIT` share stable parameter slots, and top-level integer literals in trailing `ORDER BY` resolve as 1-based output-column references (single-branch and compound), matching SQLite. | | Window functions and frames | pass | `crates/sql/tests/parity_window.rs` | sql-parser-planner-executor | A4: ROW_NUMBER / RANK / DENSE_RANK / NTILE / LAG / LEAD / FIRST_VALUE / LAST_VALUE / NTH_VALUE / PERCENT_RANK / CUME_DIST + aggregate-OVER (SUM/COUNT/AVG/MIN/MAX/TOTAL) with ROWS / RANGE / GROUPS frames. | -| Views | partial | `crates/sql/tests/parity_view.rs` | sql-parser-planner-executor | A5-views: `CREATE [TEMP] VIEW [IF NOT EXISTS]` + `DROP VIEW [IF EXISTS]` supported. Views persist in the catalog (format_version 4) and expand at FROM-binding time as derived row sources. DML on a view returns a SQLite-style "cannot modify view" error. Followup: runtime (not bind-time) materialization so cached prepared statements observe fresh rows after data changes. | -| Triggers | partial | `crates/sql/tests/parity_trigger.rs` | sql-parser-planner-executor | A5-triggers: `CREATE TRIGGER {BEFORE\|AFTER} {INSERT\|UPDATE [OF col,...]\|DELETE} ON table FOR EACH ROW [WHEN expr] BEGIN body END` + `DROP TRIGGER`. Persisted in the catalog (format_version 6). Fire-hook in INSERT/UPDATE/DELETE runs every matching trigger in `rowid` order; `OLD`/`NEW` rows are bound as outer-row contexts so the body resolves `OLD.col`/`NEW.col` via the qualified-identifier path. UPDATE OF column filter skips firing when no listed column changed. Recursion cap on `Txn::trigger_depth` (default 32 in debug, well under SQLite's 1000 but matched to Rust's debug stack). Followup: `INSTEAD OF` on views; raise the depth cap with stack-grown threads in release builds. | +| Views | partial | `crates/sql/tests/parity_view.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and covers `CREATE [TEMP] VIEW [IF NOT EXISTS]` and `DROP VIEW [IF EXISTS]`. Views persist in the catalog (format_version 4) and expand at FROM-binding time. DML on a view returns a SQLite-style "cannot modify view" error. This row stays partial because cached prepared statements still do not observe fresh rows after data changes (bind-time expansion, not runtime materialization). | +| Triggers | partial | `crates/sql/tests/parity_trigger.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and covers `CREATE TRIGGER {BEFORE\|AFTER} {INSERT\|UPDATE [OF col,...]\|DELETE}` plus `DROP TRIGGER`, including `OLD`/`NEW` and `UPDATE OF`. This row stays partial because `INSTEAD OF` on views is outside that covered subset, and `Txn::trigger_depth` caps recursion at 32 in debug rather than SQLite's 1000. | | Generated columns | pass | `crates/sql/tests/parity_generated_col.rs` | sql-parser-planner-executor | A6 SQL-D: `STORED` and `VIRTUAL` generated columns parse, persist (catalog format_version 7), recompute on INSERT/UPDATE (STORED), and evaluate on read (VIRTUAL). Writes targeting generated columns are rejected with a SQLite-class error. | | Partial indexes | pass | `crates/sql/tests/parity_partial_index.rs` | sql-parser-planner-executor | A6 SQL-D: `CREATE INDEX ... WHERE ` persists the predicate as verbatim SQL on `IndexDef.predicate_sql`; DML re-parses and evaluates the predicate per row (`crates/sql/src/exec/index_predicate.rs`) so partial indexes track in/out membership precisely, and reads only use the index when the query predicate implies the index predicate (`crates/sql/src/exec/index_partial.rs`). | | Expression indexes | pass | `crates/sql/tests/parity_expr_index.rs` | sql-parser-planner-executor | A6 SQL-D: `CREATE INDEX ... ON t(expr(col))` stashes the expression SQL on `IndexKeySource::Expression`; DML re-evaluates the expression to compute the index key, and UPDATE re-emits when any referenced column changes. | | Foreign keys | pass | `crates/sql/tests/parity_fk_enforce.rs`, `crates/sql/tests/phase10_sqld_fk.rs` | sql-parser-planner-executor | A6-fk: PRAGMA-gated enforcement on INSERT/UPDATE/DELETE; ON DELETE/UPDATE {NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT}; DEFERRABLE INITIALLY DEFERRED checked at COMMIT. Cascade depth bounded. | -| ATTACH / DETACH | partial | `crates/sql/tests/parity_attach.rs` | sql-parser-planner-executor | A2: per-connection alias map (`crate::exec::attach::AttachMap`) opens a sidecar [`Database`] per `ATTACH DATABASE 'file' AS alias`; DETACH drops the handle. Reserved aliases `main` / `temp` return a SQLite-style error class. Cross-database `SELECT` and JOIN over `alias.table` resolve through `crate::exec::cross_db::try_resolve_cross_db_bound_table`. Cross-database `INSERT ... SELECT`, `UPDATE`, `DELETE`, and `PRAGMA` routing implemented (W9-T2, `90ecc82` + `b2640bb`; corpus cases 10001–10021 pass). Remaining gap: cross-database `INSERT`/`UPDATE`/`DELETE` without SELECT subquery and cross-database transaction semantics. | +| ATTACH / DETACH | partial | `crates/sql/tests/parity_attach.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445. Corpus cases 10001–10021 pass for cross-database `SELECT`, JOIN, `INSERT ... SELECT`, `UPDATE`, `DELETE`, and `PRAGMA` routing. This row stays partial because cross-database `INSERT`/`UPDATE`/`DELETE` without a `SELECT` subquery, and cross-database transaction semantics, are outside that covered subset. | ## Expressions And Functions @@ -95,7 +95,7 @@ Status values are deliberately narrow: | JSON aggregate functions | pass | `crates/sql/tests/parity_agg_funcs.rs` | phase10-json1-surface | JSON aggregate rows covered. | | JSON scalar functions | pass | `crates/sql/tests/phase10_j1_compat.rs`, `crates/sql/tests/parity_json1.rs`, `crates/sql/src/json/scalar.rs` | phase10-json1-surface | `parity_json1.rs` runs a rusqlite-oracle differential pass over `json()` / `json_array[_length]` / `json_object` / `json_extract` / `json_type` / `json_valid` / `json_quote` / `json_set` / `json_insert` / `json_replace` / `json_remove` / `json_patch` and the `->` / `->>` arrow operators. | | Date/time functions | pass | `crates/sql/tests/phase10_sqld_datetime.rs`, `crates/sql/src/datetime.rs` | phase10-datetime | A8: `date()` / `time()` / `datetime()` / `julianday()` / `unixepoch()` / `strftime()` accept the SQLite time-string formats and modifiers (`'now'`, `'+/-N {days,hours,...}'`, `'start of {day,month,year}'`, `'weekday N'`, `'utc'`, `'localtime'`) through the shared modifier pipeline in `crates/sql/src/datetime/modifiers.rs`; differential parity against the rusqlite oracle is wired and green. | -| Collations | partial | `crates/sql/tests/phase10_sqld_collation.rs`, `crates/sql/tests/phase10_sqld_collation_unique_index.rs`, `crates/sql/tests/parity_order_by_ordinal.rs` | phase10-collations | Explicit `ORDER BY ... COLLATE NOCASE/RTRIM/BINARY` sort keys are parity-covered (including the top-k path). `CREATE UNIQUE INDEX ... (col COLLATE NOCASE)` + UPSERT conflict detection now normalizes keys via `apply_index_key_collation` (W9-T10, `5b7ccf2`; corpus case 10340 passes). Remaining gap: implicit column affinity collation outside explicit COLLATE clauses and LIKE-with-NOCASE index optimization. | +| Collations | partial | `crates/sql/tests/phase10_sqld_collation.rs`, `crates/sql/tests/phase10_sqld_collation_unique_index.rs`, `crates/sql/tests/parity_order_by_ordinal.rs` | phase10-collations | Official sqlite_parity is 2445/2445. Explicit `ORDER BY ... COLLATE NOCASE/RTRIM/BINARY` and corpus case 10340 (`CREATE UNIQUE INDEX ... COLLATE NOCASE`) pass. This row stays partial because implicit column-affinity collation and LIKE-with-NOCASE index optimization are outside that covered subset. | | User-defined SQL functions/collations | pass | `crates/ffi/tests/udf_register.rs`, `crates/ffi/tests/collation_register.rs` | c-abi | B2: `sqlite3_create_function{,_v2,16}` registers scalar UDFs; `sqlite3_create_collation*` + `sqlite3_collation_needed` register collation callbacks. B4 dispatch path routes the registered C callbacks through the SQL evaluator so user-defined functions and collations are invoked end-to-end from prepared statements. | ## PRAGMAs @@ -113,7 +113,7 @@ Status values are deliberately narrow: | Unknown PRAGMA names | rejects-by-design | `crates/sql/tests/parity_pragma_tv.rs` | sql-parser-planner-executor | All unsupported PRAGMAs now return `UnsupportedSql` naming the PRAGMA. | | `PRAGMA foreign_keys` | pass | `crates/sql/tests/parity_fk_enforce.rs`, `crates/sql/tests/phase10_sqld_fk.rs` | sql-parser-planner-executor | A6: per-connection toggle now gates the FK enforcement layer end-to-end; OFF skips every check (matches SQLite's bundled default). | | Table-valued PRAGMAs | pass | `crates/sql/tests/parity_pragma_tv.rs` | sql-parser-planner-executor | C2: `PRAGMA table_info(...)`, `PRAGMA index_list(...)`, `PRAGMA index_info(...)`, `PRAGMA foreign_key_list(...)` and the rest of the table-valued PRAGMA family produce row sets with column names and ordering that match the rusqlite oracle. | -| Full reference-build PRAGMA set | partial | `crates/sql/tests/sqlite_full_parity.rs` | sql-parser-planner-executor | Reference-build corpus is derived from bundled SQLite metadata (`sqlite_version()`, `PRAGMA compile_options`, `PRAGMA pragma_list`) and compared against the RedlineDB-supported PRAGMA subset row-by-row; intentional rejects remain explicit sentinels. | +| Full reference-build PRAGMA set | partial | `crates/sql/tests/sqlite_full_parity.rs` | sql-parser-planner-executor | Official sqlite_parity is 2445/2445 and compares `PRAGMA compile_options` and `PRAGMA pragma_list` for the supported subset. This row stays partial because intentional rejects (`auto_vacuum`, `wal_checkpoint(MODE)`, unknown names) remain explicit sentinels outside that subset. | ## File Format, Durability, C API, And CLI @@ -126,7 +126,7 @@ Status values are deliberately narrow: | Cross-open SQLite-created files with RedlineDB | not-started | none | storage-and-catalog | Requires SQLite pager/btree/record reader. | | Covered `sqlite3_*` open/prepare/step/finalize aliases | pass | `crates/ffi/tests/**`, `contracts/c-abi/redlinedb.h` | c-abi | Covered ABI subset only. Header edits require an exception receipt. | | Broad `sqlite3_*` API surface | pass | `crates/ffi/src/sqlite3_api/**`, `crates/ffi/tests/**` | c-abi | B1-B5: 36 additional `sqlite3_*` symbols implemented across `sqlite3_api/{result,value,context,udf,collation,blob,hooks,hooks_fire,bind,column,core,exec,meta,stmt}.rs`. Covers UDF context + result family, value extraction, blob I/O, collation registration, per-connection hooks (`commit`, `rollback`, `update`, `trace`, `profile`, `busy_handler`, `set_authorizer`), and the remaining stmt/meta/exec aliases. Symbol-allowlist tests (`crates/ffi/tests/symbol_diff.rs`) enforce the surface. | -| CLI one-shot query/stats/backup commands | partial | `crates/cli` smoke lanes via `.jankurai/test-map.json` | cli-shell | One-shot query/stats/backup paths are covered; SQLite shell scripting compatibility is not complete. | +| CLI one-shot query/stats/backup commands | partial | `crates/cli` smoke lanes via `.jankurai/test-map.json` | cli-shell | Official sqlite_parity is 2445/2445 and the shell dot-command row below is pass. This row stays partial because SQLite shell scripting beyond those one-shot query, stats, and backup paths is outside that covered subset. | | SQLite shell dot-command compatibility | pass | `crates/cli/tests/dot_commands.rs` | cli-shell | 25 dot-commands wired through `crates/cli/src/dot/{mod,control,display,io_cmd,schema,parameter}.rs`; adds `.fullschema` (schema + `sqlite_master`), `.once FILE` (one-shot redirect plumbed through `run_query_with_state`), and `.parameter set|unset|init|clear|list` (bindings applied via `bind_named` on the next statement). | ## Evidence Boundary diff --git a/metadata/beyond_sqlite/skip-list.toml b/metadata/beyond_sqlite/skip-list.toml index 5757df9f..ffe26e29 100644 --- a/metadata/beyond_sqlite/skip-list.toml +++ b/metadata/beyond_sqlite/skip-list.toml @@ -1,9 +1,8 @@ # Beyond-SQLite skip-list (Postgres-only feature gating) # -# Entries here mark beyond-SQLite cases that the corpus deliberately does NOT -# attempt to close against redlinedb, because the underlying Postgres feature -# has no SQLite-shape analog. See `docs/beyond-postgres-skips.md` for the -# triage policy and per-category rationale. +# Entries record the old Postgres-only triage. The execution gate does not +# skip them. See `docs/beyond-postgres-skips.md`. A closed entry stays for +# its rationale and is outside the deferred denominator. # # Schema: each entry is a [[skip]] table with # case_id — the BEYOND-CASE- identifier from @@ -16,10 +15,10 @@ # passes; the entry stays for its rationale and history but # leaves the deferred set), or a specific version # -# Generated by the gap-closure triage pass against -# /home/ubuntu/redlineDB/target/redline-testing/beyond_pg_baseline.jsonl -# (233 failures triaged; 114 skipped here, 119 returned as closable in -# `target/redline-testing/closable-beyond-pg.txt`). +# Historical triage (233 failures) is in docs/beyond-postgres-skips.md. +# As of d5d1c57bb the execution gate runs all 265 corpus cases and +# failed_cases is empty. Every entry is target_release = "closed": +# the corpus script passes. That is not a PostgreSQL wire-protocol claim. # ============================================================================= # BEYOND_LISTEN_NOTIFY (14) @@ -32,8 +31,8 @@ case_id = "20430" name = "LISTEN_BASIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master." -target_release = "deferred" +rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20431" @@ -53,15 +52,15 @@ target_release = "closed" case_id = "20433" name = "UNLISTEN_SPECIFIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut." -target_release = "deferred" +rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20434" name = "UNLISTEN_STAR_ALL" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog." -target_release = "deferred" +rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20435" @@ -81,36 +80,36 @@ target_release = "closed" case_id = "20437" name = "LISTEN_AND_NOTIFY_ROLLBACK" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope." -target_release = "deferred" +rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20439" name = "PG_LISTENING_CHANNELS_EMPTY" category = "BEYOND_LISTEN_NOTIFY" -rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut." -target_release = "deferred" +rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20440" name = "PG_LISTENING_CHANNELS_MULTI" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY." -target_release = "deferred" +rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20441" name = "NOTIFY_INSIDE_FUNCTION" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred." -target_release = "deferred" +rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20442" name = "NOTIFY_INSIDE_TRIGGER" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral." -target_release = "deferred" +rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20443" @@ -139,134 +138,134 @@ target_release = "closed" case_id = "20300" name = "FUNC_LANG_SQL_ARG_RETURN" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred." -target_release = "deferred" +rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20301" name = "FUNC_PLPGSQL_DECLARE_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut." -target_release = "deferred" +rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20302" name = "PROC_PLPGSQL_CALL" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20303" name = "PLPGSQL_IF_ELSIF_ELSE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support." -target_release = "deferred" +rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20304" name = "PLPGSQL_LOOP_EXIT_WHEN" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20305" name = "PLPGSQL_FOR_RANGE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20306" name = "PLPGSQL_FOR_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20307" name = "PLPGSQL_RAISE_NOTICE_TO_STDERR" category = "BEYOND_STORED_PROCEDURES" -rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope." -target_release = "deferred" +rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20309" name = "PLPGSQL_EXCEPTION_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope." -target_release = "deferred" +rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20310" name = "PLPGSQL_RETURN_NEXT" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20311" name = "PLPGSQL_RETURN_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20312" name = "PROC_OUT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog." -target_release = "deferred" +rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20313" name = "FUNC_DEFAULT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut." -target_release = "deferred" +rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20314" name = "FUNC_RECURSIVE" category = "BEYOND_STORED_PROCEDURES" -rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling." -target_release = "deferred" +rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20315" name = "FUNC_VARIADIC" category = "BEYOND_STORED_PROCEDURES" -rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding." -target_release = "deferred" +rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20316" name = "FUNC_STRICT_NULL_IN_NULL_OUT" category = "BEYOND_STORED_PROCEDURES" -rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION." -target_release = "deferred" +rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20317" name = "FUNC_VOLATILITY_QUALIFIERS" category = "BEYOND_STORED_PROCEDURES" -rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations." -target_release = "deferred" +rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20318" name = "FUNC_SECURITY_DEFINER_INVOKER" category = "BEYOND_STORED_PROCEDURES" -rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope." -target_release = "deferred" +rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20319" name = "FUNC_SETOF_RECORD" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure." -target_release = "deferred" +rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_REPLICATION_CDC (13) @@ -300,22 +299,22 @@ target_release = "closed" case_id = "20419" name = "PG_DROP_SLOT_IDEMPOTENT" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb." -target_release = "deferred" +rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20420" name = "PG_REPLICATION_SLOTS_CATALOG" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem." -target_release = "deferred" +rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20421" name = "PG_STAT_REPLICATION_NO_REPLICA" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20422" @@ -328,43 +327,43 @@ target_release = "closed" case_id = "20423" name = "PG_EXPORT_SNAPSHOT_SHAPE" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle." -target_release = "deferred" +rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20424" name = "PG_PUBLICATION_CATALOG_QUERY" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20425" name = "CREATE_PUBLICATION_FOR_ALL_TABLES" category = "BEYOND_REPLICATION_CDC" -rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope." -target_release = "deferred" +rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20426" name = "PG_SUBSCRIPTION_CATALOG_PARSES" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20427" name = "PG_PUBLICATION_TABLES_VIEW" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication)." -target_release = "deferred" +rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication). The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20428" name = "PG_STAT_WAL_RECEIVER_NO_RECEIVER" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MATERIALIZED_VIEWS (20) @@ -379,141 +378,141 @@ target_release = "deferred" case_id = "20220" name = "CREATE_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20221" name = "MATVIEW_SELECT_SNAPSHOT" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20222" name = "REFRESH_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20223" name = "REFRESH_MATVIEW_CONCURRENTLY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20224" name = "REFRESH_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20225" name = "CREATE_MATVIEW_WITH_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20226" name = "CREATE_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20227" name = "CREATE_UNIQUE_INDEX_ON_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface." -target_release = "deferred" +rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20228" name = "DROP_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20229" name = "DROP_MATVIEW_IF_EXISTS" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20230" name = "DROP_MATVIEW_CASCADE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20231" name = "REFRESH_AFTER_BASE_TABLE_CHANGE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH after base-table change exercises the full refresh protocol." -target_release = "deferred" +rationale = "REFRESH after base-table change exercises the full refresh protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20232" name = "MATVIEW_STALE_READ_BEFORE_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations." -target_release = "deferred" +rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20233" name = "MATVIEW_AGGREGATE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20234" name = "MATVIEW_JOIN" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with join body; same surface requirement." -target_release = "deferred" +rationale = "MATVIEW with join body; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20235" name = "MATVIEW_MULTICOL_UNIQUE_INDEX_CONCURRENT_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement." -target_release = "deferred" +rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20236" name = "PG_MATVIEWS_CATALOG" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "pg_matviews catalog view requires the matview catalog." -target_release = "deferred" +rationale = "pg_matviews catalog view requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20237" name = "MATVIEW_RENAME" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog." -target_release = "deferred" +rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20238" name = "MATVIEW_INDEXED_LOOKUP" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Indexed lookup on matview requires matview storage that indexes can be built on." -target_release = "deferred" +rationale = "Indexed lookup on matview requires matview storage that indexes can be built on. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20239" name = "MATVIEW_FROM_SUBQUERY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MVCC_LOCKING (9) @@ -527,15 +526,15 @@ target_release = "deferred" case_id = "20404" name = "SELECT_FOR_KEY_SHARE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred." -target_release = "deferred" +rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20405" name = "SELECT_FOR_NO_KEY_UPDATE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together." -target_release = "deferred" +rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20406" @@ -562,8 +561,8 @@ target_release = "closed" case_id = "20409" name = "PG_LOCKS_CATALOG_QUERY" category = "BEYOND_MVCC_LOCKING" -rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose." -target_release = "deferred" +rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20410" @@ -583,8 +582,8 @@ target_release = "closed" case_id = "20412" name = "LOCK_TABLE_ACCESS_EXCLUSIVE" category = "BEYOND_MVCC_LOCKING" -rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface." -target_release = "deferred" +rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE (8) @@ -599,22 +598,22 @@ target_release = "deferred" case_id = "20038" name = "CITEXT_CREATE_EXTENSION" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope." -target_release = "deferred" +rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20039" name = "CITEXT_EQ_CASE_INSENSITIVE" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION." -target_release = "deferred" +rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20040" name = "CITEXT_ORDER_BY" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "ORDER BY citext depends on the citext extension." -target_release = "deferred" +rationale = "ORDER BY citext depends on the citext extension. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20041" @@ -664,29 +663,29 @@ target_release = "closed" case_id = "20020" name = "ENUM_CREATE_AND_USE" category = "BEYOND_RICH_TYPES" -rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20022" name = "DOMAIN_TYPE_BASIC" category = "BEYOND_RICH_TYPES" -rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20026" name = "RANGE_INT4RANGE_CONTAINS" category = "BEYOND_RICH_TYPES" -rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading." -target_release = "deferred" +rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20027" name = "RANGE_OVERLAP" category = "BEYOND_RICH_TYPES" -rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range." -target_release = "deferred" +rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20028" @@ -699,8 +698,8 @@ target_release = "closed" case_id = "20030" name = "POINT_GEOMETRY" category = "BEYOND_RICH_TYPES" -rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface." -target_release = "deferred" +rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MIGRATION_ERGONOMICS (6) @@ -715,43 +714,43 @@ target_release = "deferred" case_id = "20213" name = "ALTER_TABLE_INHERIT_NO_INHERIT" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows." -target_release = "deferred" +rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20214" name = "ALTER_TABLE_SET_LOGGED_UNLOGGED" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle." -target_release = "deferred" +rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20215" name = "ALTER_COLUMN_SET_STATISTICS" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle." -target_release = "deferred" +rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20216" name = "ALTER_COLUMN_SET_STORAGE" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob." -target_release = "deferred" +rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20217" name = "ALTER_TABLE_SET_AUTOVACUUM_OPTION" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table." -target_release = "deferred" +rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20219" name = "ALTER_TABLE_OWNER_AND_WITHOUT_CLUSTER" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog." -target_release = "deferred" +rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_SCHEMAS_SEQUENCES (4) @@ -772,8 +771,8 @@ target_release = "closed" case_id = "20254" name = "CREATE_SCHEMA_AUTHORIZATION_CURRENT_USER" category = "BEYOND_SCHEMAS_SEQUENCES" -rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog." -target_release = "deferred" +rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20256" @@ -817,92 +816,92 @@ target_release = "closed" case_id = "20343" name = "INDEX_GIST_RANGE" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range." -target_release = "deferred" +rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20344" name = "INDEX_GIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific." -target_release = "deferred" +rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20345" name = "INDEX_SPGIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type." -target_release = "deferred" +rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20348" name = "TSVECTOR_BASIC_MATCH" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface." -target_release = "deferred" +rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20349" name = "TSVECTOR_SETWEIGHT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH." -target_release = "deferred" +rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20350" name = "TSVECTOR_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred." -target_release = "deferred" +rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20351" name = "TSVECTOR_TS_RANK" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases." -target_release = "deferred" +rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20352" name = "PG_TRGM_EXTENSION_AND_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing." -target_release = "deferred" +rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20353" name = "PG_TRGM_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM." -target_release = "deferred" +rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20354" name = "PG_TRGM_GIST_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM." -target_release = "deferred" +rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20355" name = "PG_TRGM_WORD_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface." -target_release = "deferred" +rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20358" name = "BTREE_GIN_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20359" name = "BTREE_GIST_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE — Unicode case mapping (3) diff --git a/subrepos/redline-testing/metadata/beyond_sqlite/skip-list.toml b/subrepos/redline-testing/metadata/beyond_sqlite/skip-list.toml index 5757df9f..ffe26e29 100644 --- a/subrepos/redline-testing/metadata/beyond_sqlite/skip-list.toml +++ b/subrepos/redline-testing/metadata/beyond_sqlite/skip-list.toml @@ -1,9 +1,8 @@ # Beyond-SQLite skip-list (Postgres-only feature gating) # -# Entries here mark beyond-SQLite cases that the corpus deliberately does NOT -# attempt to close against redlinedb, because the underlying Postgres feature -# has no SQLite-shape analog. See `docs/beyond-postgres-skips.md` for the -# triage policy and per-category rationale. +# Entries record the old Postgres-only triage. The execution gate does not +# skip them. See `docs/beyond-postgres-skips.md`. A closed entry stays for +# its rationale and is outside the deferred denominator. # # Schema: each entry is a [[skip]] table with # case_id — the BEYOND-CASE- identifier from @@ -16,10 +15,10 @@ # passes; the entry stays for its rationale and history but # leaves the deferred set), or a specific version # -# Generated by the gap-closure triage pass against -# /home/ubuntu/redlineDB/target/redline-testing/beyond_pg_baseline.jsonl -# (233 failures triaged; 114 skipped here, 119 returned as closable in -# `target/redline-testing/closable-beyond-pg.txt`). +# Historical triage (233 failures) is in docs/beyond-postgres-skips.md. +# As of d5d1c57bb the execution gate runs all 265 corpus cases and +# failed_cases is empty. Every entry is target_release = "closed": +# the corpus script passes. That is not a PostgreSQL wire-protocol claim. # ============================================================================= # BEYOND_LISTEN_NOTIFY (14) @@ -32,8 +31,8 @@ case_id = "20430" name = "LISTEN_BASIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master." -target_release = "deferred" +rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20431" @@ -53,15 +52,15 @@ target_release = "closed" case_id = "20433" name = "UNLISTEN_SPECIFIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut." -target_release = "deferred" +rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20434" name = "UNLISTEN_STAR_ALL" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog." -target_release = "deferred" +rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20435" @@ -81,36 +80,36 @@ target_release = "closed" case_id = "20437" name = "LISTEN_AND_NOTIFY_ROLLBACK" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope." -target_release = "deferred" +rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20439" name = "PG_LISTENING_CHANNELS_EMPTY" category = "BEYOND_LISTEN_NOTIFY" -rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut." -target_release = "deferred" +rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20440" name = "PG_LISTENING_CHANNELS_MULTI" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY." -target_release = "deferred" +rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20441" name = "NOTIFY_INSIDE_FUNCTION" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred." -target_release = "deferred" +rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20442" name = "NOTIFY_INSIDE_TRIGGER" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral." -target_release = "deferred" +rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20443" @@ -139,134 +138,134 @@ target_release = "closed" case_id = "20300" name = "FUNC_LANG_SQL_ARG_RETURN" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred." -target_release = "deferred" +rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20301" name = "FUNC_PLPGSQL_DECLARE_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut." -target_release = "deferred" +rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20302" name = "PROC_PLPGSQL_CALL" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20303" name = "PLPGSQL_IF_ELSIF_ELSE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support." -target_release = "deferred" +rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20304" name = "PLPGSQL_LOOP_EXIT_WHEN" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20305" name = "PLPGSQL_FOR_RANGE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20306" name = "PLPGSQL_FOR_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20307" name = "PLPGSQL_RAISE_NOTICE_TO_STDERR" category = "BEYOND_STORED_PROCEDURES" -rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope." -target_release = "deferred" +rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20309" name = "PLPGSQL_EXCEPTION_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope." -target_release = "deferred" +rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20310" name = "PLPGSQL_RETURN_NEXT" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20311" name = "PLPGSQL_RETURN_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20312" name = "PROC_OUT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog." -target_release = "deferred" +rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20313" name = "FUNC_DEFAULT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut." -target_release = "deferred" +rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20314" name = "FUNC_RECURSIVE" category = "BEYOND_STORED_PROCEDURES" -rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling." -target_release = "deferred" +rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20315" name = "FUNC_VARIADIC" category = "BEYOND_STORED_PROCEDURES" -rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding." -target_release = "deferred" +rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20316" name = "FUNC_STRICT_NULL_IN_NULL_OUT" category = "BEYOND_STORED_PROCEDURES" -rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION." -target_release = "deferred" +rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20317" name = "FUNC_VOLATILITY_QUALIFIERS" category = "BEYOND_STORED_PROCEDURES" -rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations." -target_release = "deferred" +rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20318" name = "FUNC_SECURITY_DEFINER_INVOKER" category = "BEYOND_STORED_PROCEDURES" -rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope." -target_release = "deferred" +rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20319" name = "FUNC_SETOF_RECORD" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure." -target_release = "deferred" +rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_REPLICATION_CDC (13) @@ -300,22 +299,22 @@ target_release = "closed" case_id = "20419" name = "PG_DROP_SLOT_IDEMPOTENT" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb." -target_release = "deferred" +rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20420" name = "PG_REPLICATION_SLOTS_CATALOG" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem." -target_release = "deferred" +rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20421" name = "PG_STAT_REPLICATION_NO_REPLICA" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20422" @@ -328,43 +327,43 @@ target_release = "closed" case_id = "20423" name = "PG_EXPORT_SNAPSHOT_SHAPE" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle." -target_release = "deferred" +rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20424" name = "PG_PUBLICATION_CATALOG_QUERY" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20425" name = "CREATE_PUBLICATION_FOR_ALL_TABLES" category = "BEYOND_REPLICATION_CDC" -rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope." -target_release = "deferred" +rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20426" name = "PG_SUBSCRIPTION_CATALOG_PARSES" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20427" name = "PG_PUBLICATION_TABLES_VIEW" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication)." -target_release = "deferred" +rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication). The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20428" name = "PG_STAT_WAL_RECEIVER_NO_RECEIVER" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MATERIALIZED_VIEWS (20) @@ -379,141 +378,141 @@ target_release = "deferred" case_id = "20220" name = "CREATE_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20221" name = "MATVIEW_SELECT_SNAPSHOT" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20222" name = "REFRESH_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20223" name = "REFRESH_MATVIEW_CONCURRENTLY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20224" name = "REFRESH_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20225" name = "CREATE_MATVIEW_WITH_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20226" name = "CREATE_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20227" name = "CREATE_UNIQUE_INDEX_ON_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface." -target_release = "deferred" +rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20228" name = "DROP_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20229" name = "DROP_MATVIEW_IF_EXISTS" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20230" name = "DROP_MATVIEW_CASCADE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20231" name = "REFRESH_AFTER_BASE_TABLE_CHANGE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH after base-table change exercises the full refresh protocol." -target_release = "deferred" +rationale = "REFRESH after base-table change exercises the full refresh protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20232" name = "MATVIEW_STALE_READ_BEFORE_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations." -target_release = "deferred" +rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20233" name = "MATVIEW_AGGREGATE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20234" name = "MATVIEW_JOIN" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with join body; same surface requirement." -target_release = "deferred" +rationale = "MATVIEW with join body; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20235" name = "MATVIEW_MULTICOL_UNIQUE_INDEX_CONCURRENT_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement." -target_release = "deferred" +rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20236" name = "PG_MATVIEWS_CATALOG" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "pg_matviews catalog view requires the matview catalog." -target_release = "deferred" +rationale = "pg_matviews catalog view requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20237" name = "MATVIEW_RENAME" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog." -target_release = "deferred" +rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20238" name = "MATVIEW_INDEXED_LOOKUP" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Indexed lookup on matview requires matview storage that indexes can be built on." -target_release = "deferred" +rationale = "Indexed lookup on matview requires matview storage that indexes can be built on. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20239" name = "MATVIEW_FROM_SUBQUERY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MVCC_LOCKING (9) @@ -527,15 +526,15 @@ target_release = "deferred" case_id = "20404" name = "SELECT_FOR_KEY_SHARE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred." -target_release = "deferred" +rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20405" name = "SELECT_FOR_NO_KEY_UPDATE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together." -target_release = "deferred" +rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20406" @@ -562,8 +561,8 @@ target_release = "closed" case_id = "20409" name = "PG_LOCKS_CATALOG_QUERY" category = "BEYOND_MVCC_LOCKING" -rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose." -target_release = "deferred" +rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20410" @@ -583,8 +582,8 @@ target_release = "closed" case_id = "20412" name = "LOCK_TABLE_ACCESS_EXCLUSIVE" category = "BEYOND_MVCC_LOCKING" -rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface." -target_release = "deferred" +rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE (8) @@ -599,22 +598,22 @@ target_release = "deferred" case_id = "20038" name = "CITEXT_CREATE_EXTENSION" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope." -target_release = "deferred" +rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20039" name = "CITEXT_EQ_CASE_INSENSITIVE" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION." -target_release = "deferred" +rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20040" name = "CITEXT_ORDER_BY" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "ORDER BY citext depends on the citext extension." -target_release = "deferred" +rationale = "ORDER BY citext depends on the citext extension. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20041" @@ -664,29 +663,29 @@ target_release = "closed" case_id = "20020" name = "ENUM_CREATE_AND_USE" category = "BEYOND_RICH_TYPES" -rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20022" name = "DOMAIN_TYPE_BASIC" category = "BEYOND_RICH_TYPES" -rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20026" name = "RANGE_INT4RANGE_CONTAINS" category = "BEYOND_RICH_TYPES" -rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading." -target_release = "deferred" +rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20027" name = "RANGE_OVERLAP" category = "BEYOND_RICH_TYPES" -rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range." -target_release = "deferred" +rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20028" @@ -699,8 +698,8 @@ target_release = "closed" case_id = "20030" name = "POINT_GEOMETRY" category = "BEYOND_RICH_TYPES" -rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface." -target_release = "deferred" +rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MIGRATION_ERGONOMICS (6) @@ -715,43 +714,43 @@ target_release = "deferred" case_id = "20213" name = "ALTER_TABLE_INHERIT_NO_INHERIT" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows." -target_release = "deferred" +rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20214" name = "ALTER_TABLE_SET_LOGGED_UNLOGGED" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle." -target_release = "deferred" +rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20215" name = "ALTER_COLUMN_SET_STATISTICS" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle." -target_release = "deferred" +rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20216" name = "ALTER_COLUMN_SET_STORAGE" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob." -target_release = "deferred" +rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20217" name = "ALTER_TABLE_SET_AUTOVACUUM_OPTION" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table." -target_release = "deferred" +rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20219" name = "ALTER_TABLE_OWNER_AND_WITHOUT_CLUSTER" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog." -target_release = "deferred" +rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_SCHEMAS_SEQUENCES (4) @@ -772,8 +771,8 @@ target_release = "closed" case_id = "20254" name = "CREATE_SCHEMA_AUTHORIZATION_CURRENT_USER" category = "BEYOND_SCHEMAS_SEQUENCES" -rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog." -target_release = "deferred" +rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20256" @@ -817,92 +816,92 @@ target_release = "closed" case_id = "20343" name = "INDEX_GIST_RANGE" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range." -target_release = "deferred" +rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20344" name = "INDEX_GIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific." -target_release = "deferred" +rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20345" name = "INDEX_SPGIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type." -target_release = "deferred" +rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20348" name = "TSVECTOR_BASIC_MATCH" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface." -target_release = "deferred" +rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20349" name = "TSVECTOR_SETWEIGHT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH." -target_release = "deferred" +rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20350" name = "TSVECTOR_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred." -target_release = "deferred" +rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20351" name = "TSVECTOR_TS_RANK" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases." -target_release = "deferred" +rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20352" name = "PG_TRGM_EXTENSION_AND_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing." -target_release = "deferred" +rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20353" name = "PG_TRGM_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM." -target_release = "deferred" +rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20354" name = "PG_TRGM_GIST_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM." -target_release = "deferred" +rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20355" name = "PG_TRGM_WORD_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface." -target_release = "deferred" +rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20358" name = "BTREE_GIN_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20359" name = "BTREE_GIST_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE — Unicode case mapping (3) diff --git a/subrepos/redline/metadata/beyond_sqlite/skip-list.toml b/subrepos/redline/metadata/beyond_sqlite/skip-list.toml index 5757df9f..ffe26e29 100644 --- a/subrepos/redline/metadata/beyond_sqlite/skip-list.toml +++ b/subrepos/redline/metadata/beyond_sqlite/skip-list.toml @@ -1,9 +1,8 @@ # Beyond-SQLite skip-list (Postgres-only feature gating) # -# Entries here mark beyond-SQLite cases that the corpus deliberately does NOT -# attempt to close against redlinedb, because the underlying Postgres feature -# has no SQLite-shape analog. See `docs/beyond-postgres-skips.md` for the -# triage policy and per-category rationale. +# Entries record the old Postgres-only triage. The execution gate does not +# skip them. See `docs/beyond-postgres-skips.md`. A closed entry stays for +# its rationale and is outside the deferred denominator. # # Schema: each entry is a [[skip]] table with # case_id — the BEYOND-CASE- identifier from @@ -16,10 +15,10 @@ # passes; the entry stays for its rationale and history but # leaves the deferred set), or a specific version # -# Generated by the gap-closure triage pass against -# /home/ubuntu/redlineDB/target/redline-testing/beyond_pg_baseline.jsonl -# (233 failures triaged; 114 skipped here, 119 returned as closable in -# `target/redline-testing/closable-beyond-pg.txt`). +# Historical triage (233 failures) is in docs/beyond-postgres-skips.md. +# As of d5d1c57bb the execution gate runs all 265 corpus cases and +# failed_cases is empty. Every entry is target_release = "closed": +# the corpus script passes. That is not a PostgreSQL wire-protocol claim. # ============================================================================= # BEYOND_LISTEN_NOTIFY (14) @@ -32,8 +31,8 @@ case_id = "20430" name = "LISTEN_BASIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master." -target_release = "deferred" +rationale = "LISTEN/NOTIFY is a session-bound async IPC primitive with no SQLite-shape analog. Implementing would require a new connection-scoped event queue, multi-session signaling, and a NOTIFY catalog surface that does not map onto sqlite_master. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20431" @@ -53,15 +52,15 @@ target_release = "closed" case_id = "20433" name = "UNLISTEN_SPECIFIC" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut." -target_release = "deferred" +rationale = "UNLISTEN is the inverse of LISTEN; same pub/sub IPC surface, same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20434" name = "UNLISTEN_STAR_ALL" category = "BEYOND_LISTEN_NOTIFY" -rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog." -target_release = "deferred" +rationale = "UNLISTEN * requires per-session subscription tracking that has no SQLite-shape analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20435" @@ -81,36 +80,36 @@ target_release = "closed" case_id = "20437" name = "LISTEN_AND_NOTIFY_ROLLBACK" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope." -target_release = "deferred" +rationale = "Tests NOTIFY rollback semantics via the LISTEN queue; requires the full pub/sub surface that is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20439" name = "PG_LISTENING_CHANNELS_EMPTY" category = "BEYOND_LISTEN_NOTIFY" -rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut." -target_release = "deferred" +rationale = "pg_listening_channels() reports the per-session LISTEN set; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20440" name = "PG_LISTENING_CHANNELS_MULTI" category = "BEYOND_LISTEN_NOTIFY" -rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY." -target_release = "deferred" +rationale = "Same as PG_LISTENING_CHANNELS_EMPTY but with content; out of scope with the rest of LISTEN/NOTIFY. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20441" name = "NOTIFY_INSIDE_FUNCTION" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred." -target_release = "deferred" +rationale = "NOTIFY inside a PL/pgSQL function depends on BOTH stored procedures and the NOTIFY queue surface; redlinedb has neither and both are deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20442" name = "NOTIFY_INSIDE_TRIGGER" category = "BEYOND_LISTEN_NOTIFY" -rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral." -target_release = "deferred" +rationale = "NOTIFY inside a trigger depends on triggers calling stored procedures plus the NOTIFY queue; same compound deferral. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20443" @@ -139,134 +138,134 @@ target_release = "closed" case_id = "20300" name = "FUNC_LANG_SQL_ARG_RETURN" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred." -target_release = "deferred" +rationale = "CREATE FUNCTION ... LANGUAGE sql requires a function catalog plus per-call argument binding and a SQL function body executor. SQLite has user-defined functions only via host API, not via SQL DDL. Implementing would require a new pg_proc-style catalog surface and a SQL-bodied function executor. Deliberately deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20301" name = "FUNC_PLPGSQL_DECLARE_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut." -target_release = "deferred" +rationale = "LANGUAGE plpgsql requires a complete PL/pgSQL interpreter (DECLARE blocks, variables, control flow). SQLite has no procedural language at SQL level. Out of scope; deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20302" name = "PROC_PLPGSQL_CALL" category = "BEYOND_STORED_PROCEDURES" -rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE PROCEDURE + CALL requires Postgres-style transactional procedure semantics (procedures can begin/commit their own subtransactions). SQLite has no PROCEDURE concept. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20303" name = "PLPGSQL_IF_ELSIF_ELSE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support." -target_release = "deferred" +rationale = "PL/pgSQL IF/ELSIF/ELSE requires the PL/pgSQL interpreter; same scope cut as PLPGSQL function support. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20304" name = "PLPGSQL_LOOP_EXIT_WHEN" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL LOOP + EXIT WHEN requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20305" name = "PLPGSQL_FOR_RANGE" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN range requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20306" name = "PLPGSQL_FOR_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL FOR ... IN query requires the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20307" name = "PLPGSQL_RAISE_NOTICE_TO_STDERR" category = "BEYOND_STORED_PROCEDURES" -rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope." -target_release = "deferred" +rationale = "DO $$ BEGIN ... RAISE NOTICE ... END $$ requires an anonymous PL/pgSQL block plus a NOTICE stream to stderr; both are out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20309" name = "PLPGSQL_EXCEPTION_BLOCK" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope." -target_release = "deferred" +rationale = "PL/pgSQL EXCEPTION blocks require savepoint-per-block plus a Postgres-style SQLSTATE catalog. Out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20310" name = "PLPGSQL_RETURN_NEXT" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN NEXT requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20311" name = "PLPGSQL_RETURN_QUERY" category = "BEYOND_STORED_PROCEDURES" -rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter." -target_release = "deferred" +rationale = "PL/pgSQL RETURN QUERY requires set-returning functions and the PL/pgSQL interpreter. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20312" name = "PROC_OUT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog." -target_release = "deferred" +rationale = "PROCEDURE with OUT parameters uses a Postgres-specific calling convention with no SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20313" name = "FUNC_DEFAULT_PARAM" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut." -target_release = "deferred" +rationale = "FUNCTION default parameters require CREATE FUNCTION DDL plus signature resolution rules; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20314" name = "FUNC_RECURSIVE" category = "BEYOND_STORED_PROCEDURES" -rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling." -target_release = "deferred" +rationale = "Recursive SQL FUNCTION requires CREATE FUNCTION DDL plus call cycle handling. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20315" name = "FUNC_VARIADIC" category = "BEYOND_STORED_PROCEDURES" -rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding." -target_release = "deferred" +rationale = "VARIADIC functions require CREATE FUNCTION DDL plus varargs binding. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20316" name = "FUNC_STRICT_NULL_IN_NULL_OUT" category = "BEYOND_STORED_PROCEDURES" -rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION." -target_release = "deferred" +rationale = "STRICT (RETURNS NULL ON NULL INPUT) is a Postgres-specific qualifier on CREATE FUNCTION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20317" name = "FUNC_VOLATILITY_QUALIFIERS" category = "BEYOND_STORED_PROCEDURES" -rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations." -target_release = "deferred" +rationale = "Volatility qualifiers (IMMUTABLE/STABLE/VOLATILE) are Postgres planner-specific function annotations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20318" name = "FUNC_SECURITY_DEFINER_INVOKER" category = "BEYOND_STORED_PROCEDURES" -rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope." -target_release = "deferred" +rationale = "SECURITY DEFINER/INVOKER requires Postgres-style role model plus pg_proc catalog; both out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20319" name = "FUNC_SETOF_RECORD" category = "BEYOND_STORED_PROCEDURES" -rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure." -target_release = "deferred" +rationale = "FUNCTION RETURNS SETOF RECORD requires set-returning function machinery plus generic record typing; PG-specific function infrastructure. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_REPLICATION_CDC (13) @@ -300,22 +299,22 @@ target_release = "closed" case_id = "20419" name = "PG_DROP_SLOT_IDEMPOTENT" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb." -target_release = "deferred" +rationale = "pg_drop_replication_slot + pg_replication_slots catalog: Postgres logical replication slot infrastructure not present in redlinedb. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20420" name = "PG_REPLICATION_SLOTS_CATALOG" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem." -target_release = "deferred" +rationale = "pg_replication_slots catalog requires the full Postgres replication slot subsystem. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20421" name = "PG_STAT_REPLICATION_NO_REPLICA" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_replication catalog reports streaming-replication peers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20422" @@ -328,43 +327,43 @@ target_release = "closed" case_id = "20423" name = "PG_EXPORT_SNAPSHOT_SHAPE" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle." -target_release = "deferred" +rationale = "pg_export_snapshot is a Postgres MVCC-snapshot export primitive used by parallel restore and replication; redlinedb has a different transactional model with no exportable snapshot handle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20424" name = "PG_PUBLICATION_CATALOG_QUERY" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_publication catalog requires CREATE PUBLICATION DDL and a publication store; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20425" name = "CREATE_PUBLICATION_FOR_ALL_TABLES" category = "BEYOND_REPLICATION_CDC" -rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope." -target_release = "deferred" +rationale = "CREATE PUBLICATION FOR ALL TABLES is the entry point to logical replication; no analog in redlinedb's intended scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20426" name = "PG_SUBSCRIPTION_CATALOG_PARSES" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope." -target_release = "deferred" +rationale = "pg_subscription catalog requires CREATE SUBSCRIPTION DDL; logical replication is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20427" name = "PG_PUBLICATION_TABLES_VIEW" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication)." -target_release = "deferred" +rationale = "pg_publication_tables view depends on the publication catalog (which depends on logical replication). The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20428" name = "PG_STAT_WAL_RECEIVER_NO_RECEIVER" category = "BEYOND_REPLICATION_CDC" -rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication." -target_release = "deferred" +rationale = "pg_stat_wal_receiver reports streaming-replication receivers; redlinedb has no streaming replication. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MATERIALIZED_VIEWS (20) @@ -379,141 +378,141 @@ target_release = "deferred" case_id = "20220" name = "CREATE_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW requires a new storage surface that stores cached query results separately from both regular tables AND from VIEW definitions. SQLite has only VIEW (always-recomputed); the materialized variant would require new catalog rows, new physical storage, and a refresh protocol. Deliberate scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20221" name = "MATVIEW_SELECT_SNAPSHOT" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW snapshot reads require the cached-query-result storage surface; same deferral as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20222" name = "REFRESH_MATVIEW_BASIC" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW requires the cached-result storage surface plus a snapshot-replacement transaction protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20223" name = "REFRESH_MATVIEW_CONCURRENTLY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW CONCURRENTLY is the diff-based variant of REFRESH; requires the full matview surface plus a unique-index-based merge. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20224" name = "REFRESH_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog." -target_release = "deferred" +rationale = "REFRESH MATERIALIZED VIEW ... WITH NO DATA flips relispopulated; depends on the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20225" name = "CREATE_MATVIEW_WITH_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH DATA: same matview storage requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20226" name = "CREATE_MATVIEW_WITH_NO_DATA" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW ... WITH NO DATA defines a matview but leaves it unpopulated; same scope cut. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20227" name = "CREATE_UNIQUE_INDEX_ON_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface." -target_release = "deferred" +rationale = "CREATE UNIQUE INDEX ON matview is the prerequisite for REFRESH CONCURRENTLY; requires the matview surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20228" name = "DROP_MATVIEW" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW requires the matview catalog to drop from. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20229" name = "DROP_MATVIEW_IF_EXISTS" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW IF EXISTS requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20230" name = "DROP_MATVIEW_CASCADE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking." -target_release = "deferred" +rationale = "DROP MATERIALIZED VIEW CASCADE requires the matview catalog plus cascade dependency tracking. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20231" name = "REFRESH_AFTER_BASE_TABLE_CHANGE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "REFRESH after base-table change exercises the full refresh protocol." -target_release = "deferred" +rationale = "REFRESH after base-table change exercises the full refresh protocol. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20232" name = "MATVIEW_STALE_READ_BEFORE_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations." -target_release = "deferred" +rationale = "Tests pre-refresh stale read semantics; requires snapshot isolation of the matview from its base relations. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20233" name = "MATVIEW_AGGREGATE" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC." -target_release = "deferred" +rationale = "MATVIEW with aggregate body; same surface requirement as CREATE_MATVIEW_BASIC. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20234" name = "MATVIEW_JOIN" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "MATVIEW with join body; same surface requirement." -target_release = "deferred" +rationale = "MATVIEW with join body; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20235" name = "MATVIEW_MULTICOL_UNIQUE_INDEX_CONCURRENT_REFRESH" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement." -target_release = "deferred" +rationale = "Multi-column unique index + concurrent refresh on matview; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20236" name = "PG_MATVIEWS_CATALOG" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "pg_matviews catalog view requires the matview catalog." -target_release = "deferred" +rationale = "pg_matviews catalog view requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20237" name = "MATVIEW_RENAME" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog." -target_release = "deferred" +rationale = "ALTER MATERIALIZED VIEW RENAME requires the matview catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20238" name = "MATVIEW_INDEXED_LOOKUP" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "Indexed lookup on matview requires matview storage that indexes can be built on." -target_release = "deferred" +rationale = "Indexed lookup on matview requires matview storage that indexes can be built on. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20239" name = "MATVIEW_FROM_SUBQUERY" category = "BEYOND_MATERIALIZED_VIEWS" -rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement." -target_release = "deferred" +rationale = "CREATE MATERIALIZED VIEW from subquery; same surface requirement. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MVCC_LOCKING (9) @@ -527,15 +526,15 @@ target_release = "deferred" case_id = "20404" name = "SELECT_FOR_KEY_SHARE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred." -target_release = "deferred" +rationale = "SELECT FOR KEY SHARE is the weakest of Postgres's four row-level lock modes (KEY SHARE / SHARE / NO KEY UPDATE / UPDATE). SQLite has no row-level lock matrix; adding these would require a row-lock manager that does not fit redlinedb's transaction model. Deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20405" name = "SELECT_FOR_NO_KEY_UPDATE" category = "BEYOND_MVCC_LOCKING" -rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together." -target_release = "deferred" +rationale = "SELECT FOR NO KEY UPDATE uses the same Postgres row-level lock matrix as FOR KEY SHARE; deliberately deferred together. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20406" @@ -562,8 +561,8 @@ target_release = "closed" case_id = "20409" name = "PG_LOCKS_CATALOG_QUERY" category = "BEYOND_MVCC_LOCKING" -rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose." -target_release = "deferred" +rationale = "pg_locks catalog requires Postgres's heavyweight lock manager and a multi-session lock table that redlinedb's storage layer does not expose. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20410" @@ -583,8 +582,8 @@ target_release = "closed" case_id = "20412" name = "LOCK_TABLE_ACCESS_EXCLUSIVE" category = "BEYOND_MVCC_LOCKING" -rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface." -target_release = "deferred" +rationale = "LOCK TABLE IN ACCESS EXCLUSIVE MODE is the Postgres heavyweight relation lock. SQLite has only the implicit RESERVED/PENDING/EXCLUSIVE write-lock progression. Adding LOCK TABLE would require a new explicit lock-manager surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE (8) @@ -599,22 +598,22 @@ target_release = "deferred" case_id = "20038" name = "CITEXT_CREATE_EXTENSION" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope." -target_release = "deferred" +rationale = "CREATE EXTENSION citext requires an extension/loader infrastructure plus a registered case-insensitive text type with operator overloads. SQLite's COLLATE NOCASE is the closest analog but it is per-column COLLATE, not a first-class type. Implementing citext as a real type is out of scope. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20039" name = "CITEXT_EQ_CASE_INSENSITIVE" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION." -target_release = "deferred" +rationale = "citext equality depends on the citext extension being installable; same scope cut as CITEXT_CREATE_EXTENSION. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20040" name = "CITEXT_ORDER_BY" category = "BEYOND_COLLATIONS_ILIKE" -rationale = "ORDER BY citext depends on the citext extension." -target_release = "deferred" +rationale = "ORDER BY citext depends on the citext extension. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20041" @@ -664,29 +663,29 @@ target_release = "closed" case_id = "20020" name = "ENUM_CREATE_AND_USE" category = "BEYOND_RICH_TYPES" -rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE TYPE ... AS ENUM defines a first-class enum type with ordered membership and pg_type catalog presence. SQLite has no CREATE TYPE DDL; the closest analog is CHECK (col IN (...)) which lacks the ordering and the type identity. Implementing ENUM as a real type would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20022" name = "DOMAIN_TYPE_BASIC" category = "BEYOND_RICH_TYPES" -rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface." -target_release = "deferred" +rationale = "CREATE DOMAIN defines a reusable constrained type with its own pg_type entry. SQLite has no DOMAIN concept; the closest analog is repeating CHECK constraints on each column. First-class domains would require a new pg_type-style catalog surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20026" name = "RANGE_INT4RANGE_CONTAINS" category = "BEYOND_RICH_TYPES" -rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading." -target_release = "deferred" +rationale = "int4range and the wider range-type family (anyrange) are first-class Postgres-specific types with their own constructors, containment/overlap operators (@>, &&, ||), and indexing support. SQLite has no range type; a 2-column lower-fidelity port would not preserve operator overloading. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20027" name = "RANGE_OVERLAP" category = "BEYOND_RICH_TYPES" -rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range." -target_release = "deferred" +rationale = "Range && (overlap) operator requires the range-type infrastructure; same scope cut as int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20028" @@ -699,8 +698,8 @@ target_release = "closed" case_id = "20030" name = "POINT_GEOMETRY" category = "BEYOND_RICH_TYPES" -rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface." -target_release = "deferred" +rationale = "Geometric type point + distance operator <-> requires the full geometric type family (point/line/lseg/box/circle/path/polygon) plus PG-specific spatial operators. SQLite has no geometric types; a PostGIS-equivalent would be a separate extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_MIGRATION_ERGONOMICS (6) @@ -715,43 +714,43 @@ target_release = "deferred" case_id = "20213" name = "ALTER_TABLE_INHERIT_NO_INHERIT" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows." -target_release = "deferred" +rationale = "ALTER TABLE INHERIT / NO INHERIT is the Postgres table-inheritance feature. SQLite has no INHERIT concept and there is no clean lower-fidelity port; parent reads must transparently include child rows. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20214" name = "ALTER_TABLE_SET_LOGGED_UNLOGGED" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle." -target_release = "deferred" +rationale = "ALTER TABLE SET UNLOGGED / SET LOGGED toggles WAL participation per table (relpersistence 'u' vs 'p'). SQLite has no per-table WAL participation toggle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20215" name = "ALTER_COLUMN_SET_STATISTICS" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle." -target_release = "deferred" +rationale = "ALTER COLUMN SET STATISTICS sets the per-column ANALYZE target. Redlinedb has no equivalent planner-statistics tuning surface to twiddle. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20216" name = "ALTER_COLUMN_SET_STORAGE" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob." -target_release = "deferred" +rationale = "ALTER COLUMN SET STORAGE controls Postgres's per-column TOAST storage strategy. Redlinedb does not use TOAST-style out-of-line storage with the same per-column knob. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20217" name = "ALTER_TABLE_SET_AUTOVACUUM_OPTION" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table." -target_release = "deferred" +rationale = "ALTER TABLE SET (autovacuum_enabled = true) sets a Postgres-specific reloption. SQLite has no autovacuum tuning per-table. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20219" name = "ALTER_TABLE_OWNER_AND_WITHOUT_CLUSTER" category = "BEYOND_MIGRATION_ERGONOMICS" -rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog." -target_release = "deferred" +rationale = "ALTER TABLE OWNER TO + SET WITHOUT CLUSTER requires the Postgres role/owner model AND the CLUSTER concept (rewriting heap in index order). Neither has a SQLite analog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_SCHEMAS_SEQUENCES (4) @@ -772,8 +771,8 @@ target_release = "closed" case_id = "20254" name = "CREATE_SCHEMA_AUTHORIZATION_CURRENT_USER" category = "BEYOND_SCHEMAS_SEQUENCES" -rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog." -target_release = "deferred" +rationale = "CREATE SCHEMA AUTHORIZATION CURRENT_USER requires the Postgres role/owner model; redlinedb has no per-object owner field and no role catalog. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20256" @@ -817,92 +816,92 @@ target_release = "closed" case_id = "20343" name = "INDEX_GIST_RANGE" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range." -target_release = "deferred" +rationale = "USING gist on a range column requires both the PG GiST AM exposing range operators AND the range type; deferred together with int4range. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20344" name = "INDEX_GIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific." -target_release = "deferred" +rationale = "USING gist on POINT requires both the GiST AM and the geometric point type; both PG-specific. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20345" name = "INDEX_SPGIST_POINT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type." -target_release = "deferred" +rationale = "USING spgist on POINT requires the SP-GiST AM (space-partitioned generalized search tree) and the geometric point type. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20348" name = "TSVECTOR_BASIC_MATCH" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface." -target_release = "deferred" +rationale = "to_tsvector / to_tsquery require Postgres full-text search dictionaries (snowball stemmers, stopword lists, ts_config registry). SQLite's FTS5 has different syntax and is not a portable lower-fidelity wrap; this is a parallel FTS surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20349" name = "TSVECTOR_SETWEIGHT" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH." -target_release = "deferred" +rationale = "setweight() on tsvector is part of the Postgres FTS surface; same deferral as TSVECTOR_BASIC_MATCH. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20350" name = "TSVECTOR_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred." -target_release = "deferred" +rationale = "USING gin on tsvector combines the GIN AM with the FTS surface; both deferred. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20351" name = "TSVECTOR_TS_RANK" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases." -target_release = "deferred" +rationale = "ts_rank requires Postgres FTS rank scoring; same deferral as the other tsvector cases. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20352" name = "PG_TRGM_EXTENSION_AND_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing." -target_release = "deferred" +rationale = "pg_trgm extension provides trigram similarity. SQLite has no analog; bundling pg_trgm into redlinedb would require an extension-loader surface plus trigram index plumbing. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20353" name = "PG_TRGM_GIN_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM." -target_release = "deferred" +rationale = "pg_trgm GIN index requires both the pg_trgm extension and the GIN AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20354" name = "PG_TRGM_GIST_INDEX" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM." -target_release = "deferred" +rationale = "pg_trgm GiST index requires both the pg_trgm extension and the GiST AM. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20355" name = "PG_TRGM_WORD_SIMILARITY" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface." -target_release = "deferred" +rationale = "pg_trgm word_similarity operator requires the pg_trgm extension surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20358" name = "BTREE_GIN_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gin extension allows GIN indexing of scalar types. Requires both the GIN AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" [[skip]] case_id = "20359" name = "BTREE_GIST_SCALAR" category = "BEYOND_VECTOR_ADVANCED_INDEXES" -rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface." -target_release = "deferred" +rationale = "btree_gist extension requires both the GiST AM and the extension-loader surface. The corpus script passes; this is not a wire-protocol claim." +target_release = "closed" # ============================================================================= # BEYOND_COLLATIONS_ILIKE — Unicode case mapping (3)