@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/51.8-maintained-table-declared-constraints.sqllogic

@@ -0,0 +1,440 @@
+-- 51.8-maintained-table-declared-constraints.sqllogic — declared CHECK and
+-- child-side FK constraints on a `create table … maintained as` table are
+-- validated against the rows the DERIVATION writes: the create-fill, the
+-- attach/re-attach reconcile, and steady-state row-time maintenance. The
+-- writing statement fails with a diagnostic attributed to the maintained
+-- table (the statement itself targeted a different table). A `delete` delta
+-- writes no row image and is never CHECK-validated.
+
+-- ===================================
+-- 1. create-fill validates declared CHECK (bulk scan), rolls back cleanly
+-- ===================================
+
+create table src (id integer primary key, v text not null);
+insert into src values (1, 'bad');
+
+create table mt (id integer primary key, v text not null check (v <> 'bad')) maintained as select id, v from src;
+-- error: row derived into maintained table 'main.mt'
+
+-- the failed create left nothing behind: the name is free for a plain create
+create table mt (id integer primary key);
+drop table mt;
+
+-- ===================================
+-- 2. steady-state maintenance validates the delta (insert and update images)
+-- ===================================
+
+update src set v = 'ok' where id = 1;
+create table mt (id integer primary key, v text not null check (v <> 'bad')) maintained as select id, v from src;
+
+insert into src values (2, 'bad');
+-- error: row derived into maintained table 'main.mt'
+
+-- the violating source statement rolled back whole
+select count(*) as n from src;
+→ [{"n":1}]
+select * from mt order by id;
+→ [{"id":1,"v":"ok"}]
+
+-- a derived UPDATE image is validated too
+insert into src values (2, 'fine');
+update src set v = 'bad' where id = 2;
+-- error: row derived into maintained table 'main.mt'
+select v from mt where id = 2;
+→ [{"v":"fine"}]
+
+-- deletes write no row image: removing a source row never CHECK-validates
+delete from src where id = 2;
+select count(*) as n from mt;
+→ [{"n":1}]
+
+-- conforming maintenance still flows
+insert into src values (3, 'good');
+select count(*) as n from mt;
+→ [{"n":2}]
+
+-- ===================================
+-- 3. child-side FK existence: create-fill, steady state, MATCH SIMPLE, pragma
+-- ===================================
+
+create table parent (pid integer primary key);
+insert into parent values (1);
+create table csrc (id integer primary key, ref integer null);
+insert into csrc values (10, 2);
+
+-- create-fill: a derived row referencing a missing parent fails the create
+create table mfk (id integer primary key, ref integer null references parent(pid)) maintained as select id, ref from csrc;
+-- error: row derived into maintained table 'main.mfk' references a missing 'main.parent'
+
+update csrc set ref = 1 where id = 10;
+create table mfk (id integer primary key, ref integer null references parent(pid)) maintained as select id, ref from csrc;
+
+-- MATCH SIMPLE: a NULL FK column is admitted regardless of parent presence
+insert into csrc values (11, null);
+select count(*) as n from mfk;
+→ [{"n":2}]
+
+-- steady state: an orphan-producing source write fails (deferred to the
+-- statement's autocommit, exactly as on an ordinary table)
+insert into csrc values (12, 99);
+-- error: row derived into maintained table 'main.mfk' references a missing 'main.parent'
+select count(*) as n from csrc;
+→ [{"n":2}]
+
+-- pragma off: the orphan is admitted (FK evaluation is gated at eval time)
+pragma foreign_keys = false;
+insert into csrc values (13, 77);
+select count(*) as n from mfk;
+→ [{"n":3}]
+
+-- pragma back on: the NEW delta validates; the pre-existing orphan (13) is
+-- NOT retro-validated (matches ordinary tables — no retro-check on pragma flip)
+pragma foreign_keys = true;
+insert into csrc values (14, 88);
+-- error: row derived into maintained table 'main.mfk' references a missing 'main.parent'
+delete from csrc where id = 13;
+
+-- ===================================
+-- 4. subquery-bearing CHECK defers to commit with maintained-table attribution
+-- ===================================
+
+create table quota (k integer primary key, lim integer not null);
+insert into quota values (1, 1);
+create table qsrc (id integer primary key, n integer not null);
+insert into qsrc values (1, 1);
+
+create table mq (id integer primary key, n integer not null check (n <= (select lim from quota where k = 1))) maintained as select id, n from qsrc;
+
+insert into qsrc values (2, 5);
+-- error: row derived into maintained table 'main.mq'
+select count(*) as n from qsrc;
+→ [{"n":1}]
+
+-- ===================================
+-- 5. CHECK op-mask collapse: a derived row image is neither a user INSERT nor
+-- UPDATE, so any CHECK touching insert|update applies to every written image
+-- ===================================
+
+create table usrc (id integer primary key, v text not null);
+create table mu (id integer primary key, v text not null check on update (v <> 'nope')) maintained as select id, v from usrc;
+-- an `on update` CHECK fires on a derived INSERT image
+insert into usrc values (1, 'nope');
+-- error: row derived into maintained table 'main.mu'
+
+create table isrc (id integer primary key, v text not null);
+insert into isrc values (1, 'fine');
+create table mi (id integer primary key, v text not null check on insert (v <> 'nope')) maintained as select id, v from isrc;
+-- an `on insert` CHECK fires on a derived UPDATE image
+update isrc set v = 'nope' where id = 1;
+-- error: row derived into maintained table 'main.mi'
+
+-- a delete-only CHECK never applies to derivation writes
+create table dsrc (id integer primary key, v text not null);
+create table md (id integer primary key, v text not null check on delete (v <> 'x')) maintained as select id, v from dsrc;
+insert into dsrc values (1, 'x');
+select count(*) as n from md;
+→ [{"n":1}]
+
+-- ===================================
+-- 6. attach / re-attach reconcile validation
+-- ===================================
+
+-- a violating PRE-EXISTING row the derivation does not reproduce is simply
+-- deleted by the derived-wins reconcile and never validated. (It slipped in
+-- via an op-masked `check on update`, which user INSERT does not evaluate.)
+create table b1 (id integer primary key, v text not null);
+insert into b1 values (1, 'ok');
+create table tgt (id integer primary key, v text not null check on update (v <> 'stale-bad'));
+insert into tgt values (1, 'ok'), (9, 'stale-bad');
+alter table tgt set maintained as select id, v from b1;
+select * from tgt order by id;
+→ [{"id":1,"v":"ok"}]
+
+-- a derivation that REPRODUCES a violator fails the attach (the op-mask
+-- collapse validates the derived image against the on-update CHECK too)
+alter table tgt drop maintained;
+create table b2 (id integer primary key, v text not null);
+insert into b2 values (9, 'stale-bad');
+alter table tgt set maintained as select id, v from b2;
+-- error: row derived into maintained table 'main.tgt'
+
+-- the failed attach left the table plain and intact
+insert into tgt values (2, 'still writable');
+select count(*) as n from tgt;
+→ [{"n":2}]
+
+-- re-attach failure restores the PRIOR derivation (and its row-time plan)
+create table a1 (id integer primary key, v text not null);
+insert into a1 values (1, 'good');
+create table a2 (id integer primary key, v text not null);
+insert into a2 values (1, 'evil');
+create table mr (id integer primary key, v text not null check (v <> 'evil')) maintained as select id, v from a1;
+alter table mr set maintained as select id, v from a2;
+-- error: row derived into maintained table 'main.mr'
+select * from mr;
+→ [{"id":1,"v":"good"}]
+-- the prior derivation is still live: an a1 write maintains mr
+insert into a1 values (2, 'more');
+select count(*) as n from mr;
+→ [{"n":2}]
+
+-- ===================================
+-- 7. MV-over-MV cascade: each level validates with its OWN evaluator
+-- ===================================
+
+create table base (id integer primary key, v text not null);
+insert into base values (1, 'ok');
+create table mt1 (id integer primary key, v text not null) maintained as select id, v from base;
+create table mt2 (id integer primary key, v text not null check (v <> 'poison')) maintained as select id, v from mt1;
+
+insert into base values (2, 'poison');
+-- error: row derived into maintained table 'main.mt2'
+select count(*) as n from base;
+→ [{"n":1}]
+select count(*) as n from mt2;
+→ [{"n":1}]
+
+-- ===================================
+-- 8. full-rebuild floor: the rebuild diff validates once at the statement flush
+-- ===================================
+
+-- (integer PK: a text PK would collate NOCASE under the store backend and fail
+-- the attach shape check before validation is ever reached)
+create table fsrc (id integer primary key, n integer not null);
+insert into fsrc values (1, 10);
+-- DISTINCT falls to the full-rebuild arm
+create table mfr (n integer not null primary key check (n < 100)) maintained as select distinct n from fsrc;
+
+insert into fsrc values (2, 500), (3, 20);
+-- error: row derived into maintained table 'main.mfr'
+select count(*) as n from fsrc;
+→ [{"n":1}]
+select * from mfr order by n;
+→ [{"n":10}]
+
+-- ===================================
+-- 9. detach: every committed row already satisfies the constraints, which
+-- become user-enforced — no stranded violators
+-- ===================================
+
+alter table mt drop maintained;
+update mt set v = 'bad' where id = 1;
+-- error: CHECK constraint failed
+update mt set v = 'still ok' where id = 1;
+select v from mt where id = 1;
+→ [{"v":"still ok"}]
+
+-- ===================================
+-- 10. zero-overhead regression: constraint-less maintained tables and the
+-- MV sugar behave exactly as before
+-- ===================================
+
+create table z (id integer primary key, v text not null);
+insert into z values (1, 'zz');
+create table mz (id integer primary key, v text not null) maintained as select id, v from z;
+create materialized view vz as select id, v from z;
+insert into z values (2, 'yy');
+select count(*) as n from mz;
+→ [{"n":2}]
+select count(*) as n from vz;
+→ [{"n":2}]
+
+-- ===================================
+-- 11. a CHECK referencing OLD/NEW row images is rejected at registration:
+-- a derived row has no OLD image (a transition CHECK would be vacuous) and
+-- NEW is the row itself (expressible unqualified)
+-- ===================================
+
+create table osrc (id integer primary key, v integer not null);
+create table mo (id integer primary key, v integer not null, check on update (new.v > old.v)) maintained as select id, v from osrc;
+-- error: references OLD/NEW row images
+
+-- the failed create left the name free
+create table mo (id integer primary key);
+drop table mo;
+
+-- the attach form rejects too, restoring the plain table (still writable,
+-- and its qualified CHECK still enforces on user DML)
+create table mo2 (id integer primary key, v integer not null, check (new.v > 0));
+alter table mo2 set maintained as select id, v from osrc;
+-- error: references OLD/NEW row images
+insert into mo2 values (1, 5);
+insert into mo2 values (2, -1);
+-- error: CHECK constraint failed
+select count(*) as n from mo2;
+→ [{"n":1}]
+
+-- a delete-only CHECK with image qualifiers is exempt (never fires on
+-- derivation writes)
+create table mo3 (id integer primary key, v integer not null, check on delete (old.v < 100)) maintained as select id, v from osrc;
+insert into osrc values (1, 500);
+select count(*) as n from mo3;
+→ [{"n":1}]
+
+-- ===================================
+-- 12. constraint-dependency DDL: rename/drop/re-create of a CONSTRAINT-ONLY
+-- dependency (FK parent / subquery-CHECK target — neither a derivation source)
+-- rebuilds the compiled derived-row validator. Before the fix the once-compiled
+-- validator went stale and maintenance writes failed with an internal
+-- "Module 'memory' connect failed … not found" error.
+-- ===================================
+
+-- FK parent RENAME: the maintained table's own FK is rewritten in place; the
+-- rebuilt validator resolves existence against the renamed parent
+create table rparent (pid integer primary key);
+create table rsrc (id integer primary key, ref integer null);
+create table rmt (id integer primary key, ref integer null references rparent(pid)) maintained as select id, ref from rsrc;
+insert into rparent values (10);
+alter table rparent rename to rparent2;
+insert into rsrc values (1, 10);
+select * from rmt order by id;
+→ [{"id":1,"ref":10}]
+-- an orphan fails with the FK attribution against the RENAMED parent (not internal)
+insert into rsrc values (2, 99);
+-- error: row derived into maintained table 'main.rmt' references a missing 'main.rparent2'
+select count(*) as n from rmt;
+→ [{"n":1}]
+
+-- FK parent DROP: the rebuild emits the absent-parent null-guards fallback — a
+-- non-NULL ref fails the maintained-table FK CONSTRAINT (NOT an internal connect
+-- error), a NULL ref is admitted under MATCH SIMPLE
+create table xparent (pid integer primary key);
+create table xsrc (id integer primary key, ref integer null);
+create table xmt (id integer primary key, ref integer null references xparent(pid)) maintained as select id, ref from xsrc;
+drop table xparent;
+insert into xsrc values (1, 5);
+-- error: row derived into maintained table 'main.xmt' references a missing 'main.xparent'
+insert into xsrc values (2, null);
+select * from xmt order by id;
+→ [{"id":2,"ref":null}]
+
+-- subquery-CHECK target DROP: REFUSED. A maintained table's declared CHECK is a
+-- stored expression like any other, so dropping the table its subquery reads is
+-- refused naming the maintained table and the constraint
+-- (41.10.4-drop-object-expression-dependents). This used to be accepted and left
+-- the validator poisoned — the next write failed with a bare
+-- `Table 'fquota' not found`, naming neither the maintained table nor the CHECK.
+-- The poisoned-validator fallback the rebuild carries is now defensive only: no
+-- user-facing DDL statement can reach it.
+create table fquota (k integer primary key, lim integer not null);
+insert into fquota values (1, 100);
+create table fqsrc (id integer primary key, n integer not null);
+create table fmq (id integer primary key, n integer not null check (n <= (select lim from fquota where k = 1))) maintained as select id, n from fqsrc;
+drop table fquota;
+-- error: it is referenced by CHECK constraint '_check_n' on table 'fmq'
+
+-- Nothing was applied, so the CHECK still compiles and still enforces.
+insert into fqsrc values (1, 5);
+select * from fmq order by id;
+→ [{"id":1,"n":5}]
+insert into fqsrc values (2, 500);
+-- error: row derived into maintained table 'main.fmq'
+select count(*) as n from fmq;
+→ [{"n":1}]
+
+-- Escape hatch: drop the maintained table (which takes its CHECK with it), then
+-- the target goes freely.
+drop table fmq;
+drop table fquota;
+-- run
+
+-- subquery-CHECK target RENAME: the CHECK AST is rewritten in place and the
+-- rebuilt validator re-resolves against the renamed target
+create table gquota (k integer primary key, lim integer not null);
+insert into gquota values (1, 100);
+create table gqsrc (id integer primary key, n integer not null);
+create table gmq (id integer primary key, n integer not null check (n <= (select lim from gquota where k = 1))) maintained as select id, n from gqsrc;
+alter table gquota rename to gquota2;
+insert into gqsrc values (1, 5);
+select * from gmq order by id;
+→ [{"id":1,"n":5}]
+insert into gqsrc values (2, 500);
+-- error: row derived into maintained table 'main.gmq'
+select count(*) as n from gmq;
+→ [{"n":1}]
+
+-- No self-heal case here any more. It used to read `drop table hquota;` followed by a
+-- re-`create table hquota`, asserting that the `table_added` rebuild restored healthy
+-- validation. Both halves are unreachable from SQL now: the drop is refused
+-- (41.10.4-drop-object-expression-dependents), and the maintained table cannot be
+-- declared against an absent CHECK target either — `create table … check ((select lim
+-- from hquota …)) maintained as …` fails at build time with `Table 'hquota' not found`.
+-- The rebuild-on-`table_added` path stays in the code as a defensive fallback for
+-- internal drop paths (rollback, catalog import), which no sqllogic file can drive.
+
+-- ===================================
+-- 13. CHECK truthiness: the derived-row validator must reject a bigint-0n / '0'
+-- CHECK result exactly like write-time DML, not the old narrower
+-- `value === false || value === 0` test that missed 0n. A bare-column `check (v)`
+-- yields bigint 0n for an integer 0 at steady-state maintenance time.
+-- ===================================
+
+create table tsrc (id integer primary key, v any not null);
+insert into tsrc values (1, 5);
+create table tmt (id integer primary key, v any not null check (v)) maintained as select id, v from tsrc;
+
+-- steady-state insert of v=0 → bigint 0n → must fail the derived-row CHECK.
+insert into tsrc values (2, 0);
+-- error: row derived into maintained table 'main.tmt'
+select count(*) as n from tmt;
+→ [{"n":1}]
+
+-- string '0' derives falsy under isTruthy's numeric conversion — also rejected.
+insert into tsrc values (3, '0');
+-- error: row derived into maintained table 'main.tmt'
+select count(*) as n from tmt;
+→ [{"n":1}]
+
+-- conforming steady-state maintenance still flows (truthy non-zero passes).
+insert into tsrc values (4, 7);
+select count(*) as n from tmt;
+→ [{"n":2}]
+
+-- ===================================
+-- 14. mutation-context variables on a maintained table are rejected at
+-- declaration time: nobody ever writes to a maintained table directly (its
+-- rows arrive from the derivation, not a user statement), so no statement
+-- could ever supply a `with context` value for a declared variable. Left
+-- unrejected this used to fail confusingly at DDL time with "Column not
+-- found" once a CHECK tried to read the variable.
+-- ===================================
+
+create table ctxsrc (id integer primary key, v integer) using memory;
+
+-- CREATE arm: declared together with a CHECK that reads the variable
+create table ctxmt (
+	id integer primary key,
+	v integer,
+	constraint gate check (v <= cap)
+) using memory
+maintained as select id, v from ctxsrc
+with context (cap integer);
+-- error: cannot create maintained table 'main.ctxmt'
+
+-- the failed create left the name free
+create table ctxmt (id integer primary key);
+drop table ctxmt;
+
+-- CREATE arm, declared-but-never-read: no constraint reads the variable, but
+-- the declaration alone is rejected — the "unread" case gets no exemption
+create table ctxmt2 (id integer primary key, v integer) using memory
+maintained as select id, v from ctxsrc
+with context (cap integer);
+-- error: cannot create maintained table 'main.ctxmt2'
+
+-- ALTER arm: a plain context-declaring table is accepted on its own...
+create table ctxamt (id integer primary key, v integer check (v <= cap))
+	using memory with context (cap integer);
+insert into ctxamt values (1, 5) with context cap = 10;
+select * from ctxamt order by id;
+→ [{"id":1,"v":5}]
+
+-- ...but making it maintained is rejected
+alter table ctxamt set maintained as select id, v from ctxsrc;
+-- error: cannot make table 'main.ctxamt' maintained
+
+-- the failed alter left the table plain and still writable with a
+-- `with context` value
+insert into ctxamt values (2, 20) with context cap = 30;
+select * from ctxamt order by id;
+→ [{"id":1,"v":5},{"id":2,"v":20}]

package/test/logic/51.85-maintained-table-parent-fk.sqllogic

@@ -0,0 +1,103 @@
+-- 51.85-maintained-table-parent-fk.sqllogic — parent-side FK enforcement for
+-- maintained-table maintenance writes, exercised against the LevelDB store backend.
+-- `enforceParentSideReferentialActions` is arm-agnostic; the inverse-projection arm
+-- is sufficient to cover all four declared FK actions on the store backend.
+
+pragma foreign_keys = true;
+
+-- ===================================
+-- 1. RESTRICT blocks a maintenance delete and rolls back the source write atomically
+-- ===================================
+
+create table src (id integer primary key, v text);
+create table m (id integer primary key, v text) maintained as select id, v from src;
+create table c (cid integer primary key, m_id integer,
+    foreign key (m_id) references m(id) on delete restrict);
+insert into src values (1, 'a'), (2, 'b');
+insert into c values (10, 1);
+
+-- maintenance delete of m(1) blocked by RESTRICT FK on c
+delete from src where id = 1;
+-- error: violates RESTRICT from 'c'
+
+-- atomic rollback: all three tables intact
+select * from src order by id;
+→ [{"id":1,"v":"a"},{"id":2,"v":"b"}]
+select * from m order by id;
+→ [{"id":1,"v":"a"},{"id":2,"v":"b"}]
+select count(*) as n from c;
+→ [{"n":1}]
+
+-- unreferenced row maintains cleanly
+delete from src where id = 2;
+select id from m;
+→ [{"id":1}]
+
+drop table c;
+drop table m;
+drop table src;
+
+-- ===================================
+-- 2. CASCADE removes children on a maintenance delete
+-- ===================================
+
+create table src (id integer primary key, v text);
+create table m (id integer primary key, v text) maintained as select id, v from src;
+create table c (cid integer primary key, m_id integer,
+    foreign key (m_id) references m(id) on delete cascade);
+insert into src values (1, 'a');
+insert into c values (10, 1), (11, 1);
+
+delete from src where id = 1;
+select count(*) as n from m;
+→ [{"n":0}]
+select count(*) as n from c;
+→ [{"n":0}]
+
+drop table c;
+drop table m;
+drop table src;
+
+-- ===================================
+-- 3. SET NULL clears the child FK column on a maintenance delete
+-- ===================================
+
+create table src (id integer primary key, v text);
+create table m (id integer primary key, v text) maintained as select id, v from src;
+create table c (cid integer primary key, m_id integer null,
+    foreign key (m_id) references m(id) on delete set null);
+insert into src values (1, 'a');
+insert into c values (10, 1);
+
+delete from src where id = 1;
+select count(*) as n from m;
+→ [{"n":0}]
+select * from c;
+→ [{"cid":10,"m_id":null}]
+
+drop table c;
+drop table m;
+drop table src;
+
+-- ===================================
+-- 4. SET DEFAULT resets the child FK column to its default on a maintenance delete
+--    (simple non-nested case: the default value points at the surviving parent row)
+-- ===================================
+
+create table src (id integer primary key);
+create table m (id integer primary key) maintained as select id from src;
+create table c (cid integer primary key, m_id integer default 99,
+    foreign key (m_id) references m(id) on delete set default);
+insert into src values (1), (99);
+insert into c values (10, 1);
+
+-- delete src(1): m(1) removed, SET DEFAULT resets c.m_id to 99 (which still exists in m)
+delete from src where id = 1;
+select id from m;
+→ [{"id":99}]
+select * from c;
+→ [{"cid":10,"m_id":99}]
+
+drop table c;
+drop table m;
+drop table src;