@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/41-alter-table.sqllogic

@@ -0,0 +1,191 @@
+-- ALTER TABLE operations: RENAME TABLE, RENAME COLUMN, ADD COLUMN, DROP COLUMN
+
+-- ===================================
+-- 1. ADD COLUMN (test first as simplest)
+-- ===================================
+
+create table t_addcol (id integer primary key, name text);
+insert into t_addcol values (1, 'Alice'), (2, 'Bob');
+
+-- Add column with NULL default (implicit)
+alter table t_addcol add column age integer null;
+
+-- Existing rows should get NULL for the new column
+select * from t_addcol order by id;
+→ [{"id": 1, "name": "Alice", "age": null}, {"id": 2, "name": "Bob", "age": null}]
+
+-- Can insert with new column
+insert into t_addcol values (3, 'Charlie', 30);
+
+select * from t_addcol where id = 3;
+→ [{"id": 3, "name": "Charlie", "age": 30}]
+
+-- Add column with DEFAULT value
+alter table t_addcol add column status text default 'active';
+
+select status from t_addcol where id = 1;
+→ [{"status": "active"}]
+
+-- Cannot add duplicate column
+alter table t_addcol add column name text;
+-- error: already exists
+
+-- Cannot add PRIMARY KEY column
+alter table t_addcol add column pk integer primary key;
+-- error: PRIMARY KEY
+
+drop table t_addcol;
+
+-- ===================================
+-- 2. DROP COLUMN
+-- ===================================
+
+create table t_dropcol (id integer primary key, name text, extra text);
+insert into t_dropcol values (1, 'Alice', 'x'), (2, 'Bob', 'y');
+
+alter table t_dropcol drop column extra;
+
+-- Remaining columns should work
+select * from t_dropcol order by id;
+→ [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
+
+-- Cannot drop PK column
+alter table t_dropcol drop column id;
+-- error: PRIMARY KEY
+
+-- Cannot drop non-existent column
+alter table t_dropcol drop column nonexistent;
+-- error: not found
+
+drop table t_dropcol;
+
+-- ===================================
+-- 3. RENAME COLUMN
+-- ===================================
+
+create table t_colrename (id integer primary key, old_name text);
+insert into t_colrename values (1, 'hello'), (2, 'world');
+
+alter table t_colrename rename column old_name to new_name;
+
+-- New column name should work
+select new_name from t_colrename where id = 1;
+→ [{"new_name": "hello"}]
+
+-- Data preserved
+select * from t_colrename order by id;
+→ [{"id": 1, "new_name": "hello"}, {"id": 2, "new_name": "world"}]
+
+-- Cannot rename to existing column name
+alter table t_colrename rename column new_name to id;
+-- error: already exists
+
+-- Cannot rename non-existent column
+alter table t_colrename rename column nonexistent to something;
+-- error: not found
+
+drop table t_colrename;
+
+-- ===================================
+-- 4. RENAME TABLE
+-- ===================================
+
+create table t_rename (id integer primary key, val text);
+insert into t_rename values (1, 'a'), (2, 'b');
+alter table t_rename rename to t_renamed;
+-- run
+
+-- Old name should no longer work
+select * from t_rename;
+-- error: not found
+
+-- New name should work and data preserved
+select * from t_renamed order by id;
+→ [{"id": 1, "val": "a"}, {"id": 2, "val": "b"}]
+
+-- Can insert into renamed table
+insert into t_renamed values (3, 'c');
+
+select count(*) as cnt from t_renamed;
+→ [{"cnt": 3}]
+
+-- Cannot rename to existing table
+create table t_conflict (x integer);
+-- run
+
+alter table t_renamed rename to t_conflict;
+-- error: already exists
+
+drop table t_renamed;
+drop table t_conflict;
+
+-- ===================================
+-- 5. ADD COLUMN with NOT NULL + DEFAULT
+-- ===================================
+
+create table t_notnull (id integer primary key);
+insert into t_notnull values (1), (2);
+-- run
+
+-- NOT NULL without DEFAULT should fail (table has rows)
+alter table t_notnull add column required text not null;
+-- error: NOT NULL
+
+-- Error message should name the column and qualified table
+alter table t_notnull add column rank integer not null;
+-- error: 'rank'
+
+alter table t_notnull add column rank integer not null;
+-- error: main.t_notnull
+
+-- NOT NULL with DEFAULT should succeed
+alter table t_notnull add column required text not null default 'default_val';
+
+select required from t_notnull where id = 1;
+→ [{"required": "default_val"}]
+
+-- NULL (no DEFAULT) on non-empty table is allowed
+alter table t_notnull add column nickname text null;
+select nickname from t_notnull where id = 1;
+→ [{"nickname": null}]
+
+drop table t_notnull;
+
+-- NOT NULL without DEFAULT is allowed on an empty table
+create table t_notnull_empty (id integer primary key, name text);
+alter table t_notnull_empty add column rank integer not null;
+insert into t_notnull_empty values (1, 'Alice', 10);
+select * from t_notnull_empty;
+→ [{"id": 1, "name": "Alice", "rank": 10}]
+drop table t_notnull_empty;
+
+-- ===================================
+-- 6. Combined operations
+-- ===================================
+
+create table t_combined (id integer primary key, a text, b text);
+insert into t_combined values (1, 'x', 'y');
+
+-- Add column, rename it, then use it
+alter table t_combined add column c integer null;
+
+alter table t_combined rename column c to score;
+
+insert into t_combined values (2, 'p', 'q', 100);
+
+select id, score from t_combined order by id;
+→ [{"id": 1, "score": null}, {"id": 2, "score": 100}]
+
+-- Drop original column
+alter table t_combined drop column b;
+
+select * from t_combined order by id;
+→ [{"id": 1, "a": "x", "score": null}, {"id": 2, "a": "p", "score": 100}]
+
+-- Rename table
+alter table t_combined rename to t_final;
+
+select * from t_final where id = 2;
+→ [{"id": 2, "a": "p", "score": 100}]
+
+drop table t_final;

package/test/logic/41-fk-cascade-conflict-and-self-ref.sqllogic

@@ -0,0 +1,263 @@
+-- adapted from SQLite test/fkey1.test, test/fkey2.test, test/fkey3.test, test/fkey4.test
+-- FK + ON CONFLICT, multi-row UPDATE cascade, self-referential composite,
+-- DROP-table-with-children, and DEFERRABLE INITIALLY DEFERRED column FK.
+
+pragma foreign_keys = true;
+
+-- ===================================
+-- 1. INSERT OR IGNORE on child silently skips FK violation
+-- ===================================
+
+create table p_oc (id integer primary key);
+create table c_oc (id integer primary key, p_id integer null,
+	foreign key (p_id) references p_oc(id));
+
+insert into p_oc values (1);
+
+-- IGNORE: orphan row silently skipped, no error
+insert or ignore into c_oc values (1, 99);
+
+select count(*) as cnt from c_oc;
+→ [{"cnt":0}]
+
+-- explicit ABORT raises
+insert or abort into c_oc values (2, 99);
+-- error:
+
+-- valid insert
+insert into c_oc values (10, 1);
+
+-- IGNORE in multi-row VALUES: only orphans skipped
+insert or ignore into c_oc values (11, 1), (12, 88), (13, 1);
+
+select id from c_oc order by id;
+→ [{"id":10},{"id":11},{"id":13}]
+
+drop table c_oc;
+drop table p_oc;
+
+-- ===================================
+-- 2. UPDATE OR IGNORE / OR ABORT — intentionally not supported.
+-- ===================================
+-- Per-statement conflict overrides on UPDATE are SQLite-only syntax; pinned closed.
+-- Schema-level ON CONFLICT on the constraint covers the IGNORE/ABORT defaults.
+-- See docs/sql.md §11.
+
+-- ===================================
+-- 3. ON UPDATE CASCADE where the cascade collides with another FK
+-- ===================================
+
+create table fa (id integer primary key);
+create table fb (id integer primary key,
+	foreign key (id) references fa(id) on update cascade);
+create table fc (b_id integer primary key,
+	foreign key (b_id) references fb(id));
+
+insert into fa values (1);
+insert into fb values (1);
+insert into fc values (1);
+
+-- updating fa.id cascades to fb.id; fb is referenced by fc with default
+-- (RESTRICT) action → end-to-end fails atomically
+update fa set id = 2 where id = 1;
+-- error:
+
+-- nothing changed
+select id from fa;
+→ [{"id":1}]
+select id from fb;
+→ [{"id":1}]
+select b_id from fc;
+→ [{"b_id":1}]
+
+drop table fc;
+drop table fb;
+drop table fa;
+
+-- ===================================
+-- 4. Multi-row parent UPDATE cascades per-row
+-- ===================================
+
+create table mp (id integer primary key);
+create table mc (id integer primary key, p_id integer null,
+	foreign key (p_id) references mp(id) on update cascade);
+
+insert into mp values (1), (2), (3);
+insert into mc values (10, 1), (11, 1), (20, 2), (21, 2), (30, 3);
+
+-- single UPDATE rewriting many parent rows; all matching children cascade
+update mp set id = id + 100;
+
+select id, p_id from mc order by id;
+→ [{"id":10,"p_id":101},{"id":11,"p_id":101},{"id":20,"p_id":102},{"id":21,"p_id":102},{"id":30,"p_id":103}]
+
+drop table mc;
+drop table mp;
+
+-- ===================================
+-- 5. Self-referential FK with composite UNIQUE target
+-- ===================================
+
+create table tree (
+	id integer primary key,
+	pid integer not null,
+	tag text not null,
+	unique (id, tag),
+	foreign key (pid, tag) references tree(id, tag)
+);
+
+-- root self-match
+insert into tree values (1, 1, 'a');
+
+select * from tree;
+→ [{"id":1,"pid":1,"tag":"a"}]
+
+-- valid child referencing existing (id, tag)
+insert into tree values (2, 1, 'a');
+
+-- invalid: (pid, tag) = (1, 'b') has no matching row
+insert into tree values (3, 1, 'b');
+-- error:
+
+drop table tree;
+
+-- ===================================
+-- 6. DROP TABLE of a parent while a child still references it
+-- ===================================
+
+create table fk_drop_parent (x integer primary key, y integer null);
+create table fk_drop_child (a integer primary key, b integer null references fk_drop_parent(x));
+
+insert into fk_drop_parent values (100, 1);
+insert into fk_drop_child values (1, 100);
+
+-- dropping the referenced parent must fail
+drop table fk_drop_parent;
+-- error:
+
+-- correct order (child first) succeeds
+drop table fk_drop_child;
+drop table fk_drop_parent;
+
+-- ===================================
+-- 7. DEFERRABLE INITIALLY DEFERRED column FK — auto-commit failure repeats cleanly
+-- ===================================
+
+create table t1 (a integer primary key, b integer null);
+create table t2 (c integer null references t1 deferrable initially deferred, d integer null);
+
+insert into t1 values (1, 2);
+insert into t2 values (1, 3);
+
+select * from t2;
+→ [{"c":1,"d":3}]
+
+-- deferred FK still rejects on auto-commit (no enclosing tx)
+insert into t2 values (2, 4);
+-- error:
+
+-- repeating it must fail the same way; no implicit tx left dangling
+insert into t2 values (2, 4);
+-- error:
+
+select * from t2;
+→ [{"c":1,"d":3}]
+
+drop table t2;
+drop table t1;
+
+-- ===================================
+-- 8. Self-referential ON DELETE CASCADE — multi-level subtree
+-- ===================================
+
+create table sr_tree (
+	id integer primary key,
+	pid integer null,
+	foreign key (pid) references sr_tree(id) on delete cascade
+);
+
+-- Build:
+--   1 (root, pid=NULL)
+--   ├─ 2 (pid=1)
+--   │  ├─ 4 (pid=2)
+--   │  └─ 5 (pid=2)
+--   └─ 3 (pid=1)
+--      └─ 6 (pid=3)
+insert into sr_tree values (1, null);
+insert into sr_tree values (2, 1), (3, 1);
+insert into sr_tree values (4, 2), (5, 2), (6, 3);
+
+select id from sr_tree order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6}]
+
+-- delete subtree rooted at 2 → cascades to 4 and 5
+delete from sr_tree where id = 2;
+
+select id from sr_tree order by id;
+→ [{"id":1},{"id":3},{"id":6}]
+
+-- delete root → cascades the entire remaining tree
+delete from sr_tree where id = 1;
+
+select count(*) as cnt from sr_tree;
+→ [{"cnt":0}]
+
+drop table sr_tree;
+
+-- ===================================
+-- 9. Self-referential ON UPDATE CASCADE — child's pid follows parent's id rename
+-- ===================================
+
+create table sru_tree (
+	id integer primary key,
+	pid integer null,
+	foreign key (pid) references sru_tree(id) on update cascade
+);
+
+insert into sru_tree values (1, null);
+insert into sru_tree values (2, 1), (3, 1);
+insert into sru_tree values (4, 2);
+
+-- rename leaf parent: child 4 follows
+update sru_tree set id = 200 where id = 2;
+
+select id, pid from sru_tree order by id;
+→ [{"id":1,"pid":null},{"id":3,"pid":1},{"id":4,"pid":200},{"id":200,"pid":1}]
+
+-- rename root: rows 3 and 200 follow (4's pid stays at 200 since 200 didn't move)
+update sru_tree set id = 100 where id = 1;
+
+select id, pid from sru_tree order by id;
+→ [{"id":3,"pid":100},{"id":4,"pid":200},{"id":100,"pid":null},{"id":200,"pid":100}]
+
+drop table sru_tree;
+
+-- ===================================
+-- 10. Deferred self-referential FK — forward reference within a transaction
+-- ===================================
+
+create table sd_tree (
+	id integer primary key,
+	pid integer null references sd_tree(id) deferrable initially deferred
+);
+
+-- forward reference: insert child before parent in the same tx; commit must succeed
+begin;
+insert into sd_tree values (2, 1);
+insert into sd_tree values (1, null);
+commit;
+
+select id, pid from sd_tree order by id;
+→ [{"id":1,"pid":null},{"id":2,"pid":1}]
+
+-- if the parent never appears, commit must fail
+begin;
+insert into sd_tree values (3, 99);
+commit;
+-- error:
+
+-- failed commit must leave no trace of row 3
+select id from sd_tree order by id;
+→ [{"id":1},{"id":2}]
+
+drop table sd_tree;

package/test/logic/41-fk-cross-schema.sqllogic

@@ -0,0 +1,155 @@
+-- fk-cross-schema.sqllogic - FK parent-side check must respect schema boundaries
+-- Regression: buildParentSideFKChecks matches by table name only, ignoring schema
+
+PRAGMA foreign_keys = true;
+
+-- ===================================================================
+-- Setup: Two schemas, each with an identically-named "items" table.
+-- Only s1 has a child table with FK referencing s1.items.
+-- ===================================================================
+
+declare schema s1 {
+	table items {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL
+	}
+
+	table orders {
+		id INTEGER PRIMARY KEY,
+		item_id INTEGER,
+		FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE RESTRICT
+	}
+}
+
+declare schema s2 {
+	table items {
+		id INTEGER PRIMARY KEY,
+		label TEXT
+	}
+}
+
+apply schema s1;
+apply schema s2;
+
+-- run
+
+-- Seed both schemas
+INSERT INTO s1.items VALUES (1, 'Widget'), (2, 'Gadget');
+INSERT INTO s1.orders VALUES (100, 1), (200, 2);
+
+INSERT INTO s2.items VALUES (1, 'Alpha'), (2, 'Beta'), (3, 'Gamma');
+
+-- Verify setup
+SELECT count(*) as cnt FROM s1.orders;
+→ [{"cnt":2}]
+
+SELECT count(*) as cnt FROM s2.items;
+→ [{"cnt":3}]
+
+-- ===================================================================
+-- Test: DELETE from s2.items should succeed — no FK references s2.items
+-- With the bug, it incorrectly matches s1.orders FK (which targets s1.items)
+-- ===================================================================
+
+DELETE FROM s2.items WHERE id = 3;
+
+SELECT count(*) as cnt FROM s2.items;
+→ [{"cnt":2}]
+
+-- DELETE from s1.items that IS referenced should fail (RESTRICT)
+DELETE FROM s1.items WHERE id = 1;
+-- error: constraint failed
+
+-- Verify s1.items unchanged
+SELECT count(*) as cnt FROM s1.items;
+→ [{"cnt":2}]
+
+-- ===================================================================
+-- Test: UPDATE on s2.items should also succeed
+-- ===================================================================
+
+UPDATE s2.items SET id = 99 WHERE id = 2;
+
+SELECT id FROM s2.items ORDER BY id;
+→ [{"id":1},{"id":99}]
+
+-- Cleanup
+DROP TABLE s1.orders;
+DROP TABLE s1.items;
+DROP TABLE s2.items;
+
+-- ===================================================================
+-- Test: CASCADE/SET NULL/SET DEFAULT actions across schemas must
+-- target the schema-qualified child table, not whichever 'children'
+-- happens to live in the default schema.
+-- Regression: executeSingleFKAction generated unqualified DELETE/UPDATE
+-- which would target the wrong table when child is in a non-default schema.
+-- ===================================================================
+
+declare schema sa {
+	table parents {
+		id INTEGER PRIMARY KEY,
+		val TEXT NULL
+	}
+
+	table cascade_children {
+		id INTEGER PRIMARY KEY,
+		parent_id INTEGER NULL,
+		FOREIGN KEY (parent_id) REFERENCES parents(id) ON DELETE CASCADE ON UPDATE CASCADE
+	}
+
+	table setnull_children {
+		id INTEGER PRIMARY KEY,
+		parent_id INTEGER NULL,
+		FOREIGN KEY (parent_id) REFERENCES parents(id) ON DELETE SET NULL
+	}
+
+	table setdefault_children {
+		id INTEGER PRIMARY KEY,
+		parent_id INTEGER NULL DEFAULT 99,
+		FOREIGN KEY (parent_id) REFERENCES parents(id) ON DELETE SET DEFAULT
+	}
+}
+
+apply schema sa;
+
+-- run
+
+-- Seed: parent 99 acts as the default-target row for SET DEFAULT.
+-- Each child references a distinct parent so that one action does not
+-- cascade into another.
+INSERT INTO sa.parents VALUES (1, 'one'), (2, 'two'), (3, 'three'), (4, 'four'), (99, 'default');
+INSERT INTO sa.cascade_children VALUES (10, 1), (11, 1);
+INSERT INTO sa.cascade_children VALUES (12, 2);
+INSERT INTO sa.setnull_children VALUES (20, 3);
+INSERT INTO sa.setdefault_children VALUES (30, 4);
+
+-- CASCADE DELETE across schema
+DELETE FROM sa.parents WHERE id = 1;
+
+SELECT count(*) as cnt FROM sa.cascade_children WHERE parent_id = 1;
+→ [{"cnt":0}]
+
+-- CASCADE UPDATE across schema
+UPDATE sa.parents SET id = 222 WHERE id = 2;
+
+SELECT parent_id FROM sa.cascade_children WHERE id = 12;
+→ [{"parent_id":222}]
+
+-- SET NULL across schema
+DELETE FROM sa.parents WHERE id = 3;
+
+SELECT parent_id FROM sa.setnull_children WHERE id = 20;
+→ [{"parent_id":null}]
+
+-- SET DEFAULT across schema
+DELETE FROM sa.parents WHERE id = 4;
+
+SELECT parent_id FROM sa.setdefault_children WHERE id = 30;
+→ [{"parent_id":99}]
+
+DROP TABLE sa.cascade_children;
+DROP TABLE sa.setnull_children;
+DROP TABLE sa.setdefault_children;
+DROP TABLE sa.parents;
+