@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/93-ddl-view-edge-cases.sqllogic

@@ -0,0 +1,104 @@
+-- ddl-view-edge-cases.sqllogic - View DDL and constraint edge cases
+-- Targets: create-view.ts, drop-view.ts, add-constraint.ts
+
+-- ===== VIEW DDL EDGE CASES =====
+
+CREATE TABLE v_base (id INTEGER PRIMARY KEY, name TEXT, val INTEGER);
+INSERT INTO v_base VALUES (1, 'Alpha', 10), (2, 'Beta', 20), (3, 'Gamma', 30);
+
+-- Basic view creation and query
+CREATE VIEW v_test AS SELECT id, name FROM v_base WHERE val > 15;
+SELECT * FROM v_test ORDER BY id;
+→ [{"id":2,"name":"Beta"},{"id":3,"name":"Gamma"}]
+
+-- expect error: duplicate view name without IF NOT EXISTS
+CREATE VIEW v_test AS SELECT id FROM v_base;
+-- error: already exists
+
+-- CREATE VIEW IF NOT EXISTS on existing view → no-op, original definition preserved
+CREATE VIEW IF NOT EXISTS v_test AS SELECT id FROM v_base;
+SELECT * FROM v_test ORDER BY id;
+→ [{"id":2,"name":"Beta"},{"id":3,"name":"Gamma"}]
+
+-- DROP VIEW (normal success case)
+DROP VIEW v_test;
+-- run
+
+-- expect error: DROP VIEW on nonexistent without IF EXISTS
+DROP VIEW v_test;
+-- error: does not exist
+
+-- DROP VIEW IF EXISTS on nonexistent → no-op (no error)
+DROP VIEW IF EXISTS v_test;
+SELECT 1 AS ok;
+→ [{"ok":1}]
+
+-- CREATE VIEW IF NOT EXISTS when view doesn't exist → creates it
+CREATE VIEW IF NOT EXISTS v_new AS SELECT id, val FROM v_base;
+SELECT * FROM v_new ORDER BY id;
+→ [{"id":1,"val":10},{"id":2,"val":20},{"id":3,"val":30}]
+
+-- DROP VIEW IF EXISTS on existing → drops it
+DROP VIEW IF EXISTS v_new;
+SELECT 1 AS ok;
+→ [{"ok":1}]
+
+-- Verify it's actually gone
+SELECT * FROM v_new;
+-- error: not found
+
+-- Drop and recreate with different definition
+CREATE VIEW v_redef AS SELECT name FROM v_base;
+SELECT * FROM v_redef ORDER BY name;
+→ [{"name":"Alpha"},{"name":"Beta"},{"name":"Gamma"}]
+
+DROP VIEW v_redef;
+CREATE VIEW v_redef AS SELECT val FROM v_base WHERE val < 25;
+SELECT * FROM v_redef ORDER BY val;
+→ [{"val":10},{"val":20}]
+
+DROP VIEW v_redef;
+DROP TABLE v_base;
+
+-- ===== CONSTRAINT EDGE CASES =====
+
+-- Named CHECK constraint via ALTER TABLE ADD CONSTRAINT
+CREATE TABLE t_chk (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO t_chk VALUES (1, 10);
+
+ALTER TABLE t_chk ADD CONSTRAINT val_nonneg CHECK (val >= 0);
+
+-- Valid insert passes constraint
+INSERT INTO t_chk VALUES (2, 5);
+SELECT * FROM t_chk ORDER BY id;
+→ [{"id":1,"val":10},{"id":2,"val":5}]
+
+-- Violating insert fails
+INSERT INTO t_chk VALUES (3, -1);
+-- error: CHECK constraint failed
+
+-- NULL should pass CHECK (SQL standard: NULL is UNKNOWN, not FALSE)
+INSERT INTO t_chk VALUES (4, null);
+SELECT id, val FROM t_chk WHERE id = 4;
+→ [{"id":4,"val":null}]
+
+DROP TABLE t_chk;
+
+-- Multiple named constraints on same table
+CREATE TABLE t_multi_chk (id INTEGER PRIMARY KEY, a INTEGER NULL, b INTEGER NULL);
+ALTER TABLE t_multi_chk ADD CONSTRAINT chk_a CHECK (a > 0);
+ALTER TABLE t_multi_chk ADD CONSTRAINT chk_b CHECK (b > 0);
+
+INSERT INTO t_multi_chk VALUES (1, 10, 20);
+SELECT * FROM t_multi_chk;
+→ [{"id":1,"a":10,"b":20}]
+
+-- Violates first constraint
+INSERT INTO t_multi_chk VALUES (2, -1, 20);
+-- error: CHECK constraint failed
+
+-- Violates second constraint
+INSERT INTO t_multi_chk VALUES (3, 10, -1);
+-- error: CHECK constraint failed
+
+DROP TABLE t_multi_chk;

package/test/logic/93.1-view-error-paths.sqllogic

@@ -0,0 +1,74 @@
+-- adapted from SQLite test/view.test
+-- View error / rejection paths.
+
+-- ===================================
+-- 1. View querying a dropped underlying table
+-- ===================================
+
+create table mb_base (id integer primary key, val integer);
+insert into mb_base values (1, 10);
+create view mb_v as select id, val from mb_base;
+
+select * from mb_v;
+→ [{"id":1,"val":10}]
+
+drop table mb_base;
+
+-- Querying view after base table dropped should error
+select * from mb_v;
+-- error: not found
+
+drop view mb_v;
+
+-- ===================================
+-- 2. Mutations through a single-source projection view (updateable)
+-- ===================================
+
+create table rom_base (id integer primary key, val integer);
+insert into rom_base values (1, 10);
+create view rom_v as select id, val from rom_base;
+
+insert into rom_v values (2, 20);
+
+update rom_v set val = 99 where id = 1;
+
+delete from rom_v where id = 1;
+
+-- View now reflects the base writes routed through it.
+select * from rom_v order by id;
+→ [{"id":2,"val":20}]
+
+drop view rom_v;
+drop table rom_base;
+
+-- ===================================
+-- 3. DROP TABLE on a view / DROP VIEW on a table
+-- ===================================
+
+create table dm_base (id integer primary key);
+create view dm_v as select id from dm_base;
+
+drop table dm_v;
+-- error:
+
+drop view dm_base;
+-- error:
+
+drop view dm_v;
+drop table dm_base;
+
+-- ===================================
+-- 4. ALTER TABLE on a view rejected
+-- ===================================
+
+create table at_base (id integer primary key, x integer);
+create view at_v as select id, x from at_base;
+
+alter table at_v rename to at_v2;
+-- error:
+
+alter table at_v add column y integer null;
+-- error:
+
+drop view at_v;
+drop table at_base;

package/test/logic/93.2-view-mutation-pending.sqllogic

@@ -0,0 +1,108 @@
+-- View updateability — Phase 1 rejections.
+-- Honest contract of body shapes NOT handled yet; each must raise a diagnostic.
+
+create table t (id integer primary key, name text);
+create table t2 (id integer primary key, name text);
+
+-- Computed-lineage projection: a computed view column is read-only (no-inverse),
+-- named in the diagnostic.
+create view vc as select id, length(name) as name_len from t;
+
+insert into vc (id, name_len) values (1, 5);
+-- error: name_len
+
+update vc set name_len = 9 where id = 1;
+-- error: name_len
+
+-- Aggregate body: not row-decomposable.
+create view va as select count(*) as c from t;
+
+insert into va (c) values (1);
+-- error: cannot write through view
+
+-- Set-operation (UNION) body.
+create view vu as select id from t union all select id from t2;
+
+insert into vu (id) values (1);
+-- error: cannot write through view
+
+-- Join body (multi-source inner join): update / delete AND insert write-through
+-- are SHIPPED (see 93.4-view-mutation.sqllogic). This view projects only the
+-- shared key `tid`, so an insert supplying just `tid` leaves both base tables'
+-- NOT NULL `name` columns (no default) unfilled — a `no-default` rejection naming
+-- the obstructing base column, not a blanket "insert not supported".
+create view vj as select t.id as tid from t join t2 on t.id = t2.id;
+
+insert into vj (tid) values (9);
+-- error: no default
+
+-- Outer (left) join body: BOTH the preserved side and a non-preserved-side update are
+-- now write-through-able (see 93.4-view-mutation.sqllogic § Outer joins — the matched-
+-- update / null-extended-insert materialization), so the prior `voj` non-preserved-update
+-- rejection moved there. What stays deferred is a FULL outer join (no preserved anchor):
+-- every side is null-extended, so a non-preserved update cannot key a materialization.
+create view voj_full as select t.id as tid, t2.name as n2 from t full join t2 on t.id = t2.id;
+
+update voj_full set n2 = 'q' where tid = 1;
+-- error: cannot write through view
+
+-- VALUES body: no base-table lineage.
+create view vv as values (1), (2);
+
+insert into vv values (3);
+-- error: no recoverable base operation
+
+-- Predicate contradiction: insert violates the view's selection at plan time.
+create view vp as select id, name from t where id = 1;
+
+insert into vp (id, name) values (2, 'x');
+-- error: contradicts its selection predicate
+
+-- RETURNING through a view is SHIPPED (see 93.4-view-mutation.sqllogic § RETURNING).
+-- Single-source insert/update/delete RETURNING (incl. computed view columns) and
+-- multi-source inner-join update/delete RETURNING are supported. Only a
+-- multi-source (join) INSERT … RETURNING is still rejected:
+create table jt1 (id integer primary key, a integer);
+create table jt2 (id integer primary key, c integer);
+create view rjv as select t1.id as id, t1.a as a, t2.c as c
+    from jt1 t1 join jt2 t2 on t2.id = t1.id;
+insert into rjv (id, a, c) values (1, 2, 3) returning id;
+-- error: RETURNING through a multi-source
+
+-- (A multi-source UPDATE that rewrites a column its own WHERE predicate filters on
+-- is now SHIPPED via per-row identity capture — see 93.4 § RETURNING (d). The
+-- former loud rejection for that shape has been removed.)
+
+-- Per-row identity capture now stitches on EACH side's PK columns (composite keys
+-- flattened to k<side>_0, k<side>_1, …), so a multi-source UPDATE … RETURNING through
+-- a join view whose (even non-written) side has a COMPOSITE PK is now SHIPPED — the
+-- RETURNING re-query correlates the full joined row by all sides' captured keys.
+create table cpp (a integer, b integer, label text, primary key (a, b));
+create table cpc (cid integer primary key, ra integer, rb integer, note text);
+insert into cpp values (1, 1, 'L');
+insert into cpc values (10, 1, 1, 'n');
+create view cppv as select c.cid as cid, c.note as note, p.label as label
+    from cpc c join cpp p on p.a = c.ra and p.b = c.rb;
+update cppv set note = 'N' where cid = 10 returning cid, note;
+→ [{"cid":10,"note":"N"}]
+
+-- the same update WITHOUT returning also works (identified by the child PK alone).
+update cppv set note = 'M' where cid = 10;
+select cid, note, label from cppv order by cid;
+→ [{"cid":10,"note":"M","label":"L"}]
+
+-- LIMIT body: the predicate-conjoin rewrite cannot reproduce the row-count
+-- window, so a mutation could escape it. Reject rather than widen the write.
+create view vlim as select id, name from t limit 5;
+
+delete from vlim;
+-- error: LIMIT/OFFSET body
+
+update vlim set name = 'z' where id = 1;
+-- error: LIMIT/OFFSET body
+
+-- DISTINCT body: no 1:1 base-row lineage.
+create view vdist as select distinct name from t;
+
+delete from vdist where name = 'a';
+-- error: DISTINCT body

package/test/logic/93.3-view-mutation-or-clause.sqllogic

@@ -0,0 +1,60 @@
+-- View updateability — OR-clause conflict resolution under view-mediated insert.
+-- The view's projection-filter body routes the OR clause to the base op verbatim.
+
+-- ===================================
+-- OR IGNORE: the violating op drops its row; siblings continue.
+-- ===================================
+create table ki (id integer primary key, val integer);
+insert into ki values (1, 10);
+create view kvi as select id, val from ki where val >= 0;
+
+insert or ignore into kvi values (1, 99), (2, 20);
+select * from ki order by id;
+→ [{"id":1,"val":10},{"id":2,"val":20}]
+
+-- ===================================
+-- OR REPLACE: the conflicting row is replaced.
+-- ===================================
+create table kr (id integer primary key, val integer);
+insert into kr values (1, 10);
+create view kvr as select id, val from kr where val >= 0;
+
+insert or replace into kvr values (1, 50);
+select * from kr order by id;
+→ [{"id":1,"val":50}]
+
+-- ===================================
+-- OR FAIL: abort at first violation; already-succeeded prior rows remain.
+-- ===================================
+create table kf (id integer primary key, val integer);
+insert into kf values (2, 10);
+create view kvf as select id, val from kf where val >= 0;
+
+insert or fail into kvf values (1, 1), (2, 2), (3, 3);
+-- error:
+select * from kf order by id;
+→ [{"id":1,"val":1},{"id":2,"val":10}]
+
+-- ===================================
+-- OR ABORT (default): abort and undo prior rows in the same statement.
+-- ===================================
+create table ka (id integer primary key, val integer);
+insert into ka values (2, 10);
+create view kva as select id, val from ka where val >= 0;
+
+insert into kva values (1, 1), (2, 2), (3, 3);
+-- error:
+select * from ka order by id;
+→ [{"id":2,"val":10}]
+
+-- ===================================
+-- OR ROLLBACK: abort the enclosing transaction.
+-- ===================================
+create table ko (id integer primary key, val integer);
+insert into ko values (2, 10);
+create view kvo as select id, val from ko where val >= 0;
+
+insert or rollback into kvo values (1, 1), (2, 2);
+-- error:
+select * from ko order by id;
+→ [{"id":2,"val":10}]