@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/41-foreign-keys.sqllogic

@@ -0,0 +1,1001 @@
+-- foreign-keys.sqllogic - Testing FOREIGN KEY constraint enforcement
+
+-- ===================================================================
+-- Setup: Enable foreign key enforcement
+-- ===================================================================
+
+PRAGMA foreign_keys = true;
+
+-- ===================================================================
+-- Phase 1: Child-side referential validation
+-- ===================================================================
+
+-- --- Basic FK validation (child-side INSERT) ---
+
+CREATE TABLE authors (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL
+);
+
+CREATE TABLE books (
+    id INTEGER PRIMARY KEY,
+    title TEXT NOT NULL,
+    author_id INTEGER,
+    FOREIGN KEY (author_id) REFERENCES authors(id) ON DELETE RESTRICT ON UPDATE RESTRICT
+);
+
+-- Populate parent table
+INSERT INTO authors VALUES (1, 'Alice'), (2, 'Bob');
+SELECT * FROM authors ORDER BY id;
+→ [{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]
+
+-- Valid FK insert (author exists)
+INSERT INTO books VALUES (1, 'Book A', 1);
+SELECT * FROM books;
+→ [{"id":1,"title":"Book A","author_id":1}]
+
+-- Invalid FK insert (author_id 99 does not exist)
+INSERT INTO books VALUES (2, 'Book B', 99);
+-- error: CHECK constraint failed: _fk_books_author_id
+
+-- Verify state after failed insert
+SELECT count(*) FROM books;
+→ [{"count(*)":1}]
+
+-- --- Child-side UPDATE validation ---
+
+-- Valid FK update
+UPDATE books SET author_id = 2 WHERE id = 1;
+SELECT author_id FROM books WHERE id = 1;
+→ [{"author_id":2}]
+
+-- Invalid FK update (author_id 50 does not exist)
+UPDATE books SET author_id = 50 WHERE id = 1;
+-- error: CHECK constraint failed: _fk_books_author_id
+
+-- Verify state after failed update
+SELECT author_id FROM books WHERE id = 1;
+→ [{"author_id":2}]
+
+DROP TABLE books;
+DROP TABLE authors;
+
+-- ===================================================================
+-- Phase 1: Parent-side RESTRICT and NO ACTION
+-- ===================================================================
+
+-- --- RESTRICT on DELETE ---
+
+CREATE TABLE departments (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL
+);
+
+CREATE TABLE employees (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    dept_id INTEGER,
+    FOREIGN KEY (dept_id) REFERENCES departments(id) ON DELETE RESTRICT ON UPDATE RESTRICT
+);
+
+INSERT INTO departments VALUES (1, 'Engineering'), (2, 'Marketing');
+INSERT INTO employees VALUES (1, 'Alice', 1), (2, 'Bob', 1);
+
+-- Commit setup data before error test
+SELECT count(*) FROM departments;
+→ [{"count(*)":2}]
+
+-- Attempt to delete a referenced department (should fail - RESTRICT; enforced
+-- by the batched statement-end probe since fk-restrict-statement-batch)
+DELETE FROM departments WHERE id = 1;
+-- error: violates RESTRICT from 'employees'
+
+-- Verify nothing was deleted
+SELECT count(*) FROM departments;
+→ [{"count(*)":2}]
+
+-- Delete an unreferenced department (should succeed)
+DELETE FROM departments WHERE id = 2;
+SELECT count(*) FROM departments;
+→ [{"count(*)":1}]
+
+-- --- RESTRICT on UPDATE ---
+
+-- Attempt to update referenced PK (should fail - RESTRICT; batched probe)
+UPDATE departments SET id = 99 WHERE id = 1;
+-- error: violates RESTRICT from 'employees'
+
+-- Verify nothing changed
+SELECT id FROM departments;
+→ [{"id":1}]
+
+DROP TABLE employees;
+DROP TABLE departments;
+
+-- --- NO ACTION (treated as RESTRICT) ---
+
+CREATE TABLE categories (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL
+);
+
+CREATE TABLE products (
+    id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    cat_id INTEGER,
+    FOREIGN KEY (cat_id) REFERENCES categories(id) ON DELETE NO ACTION
+);
+
+INSERT INTO categories VALUES (1, 'Electronics'), (2, 'Books');
+INSERT INTO products VALUES (1, 'Laptop', 1);
+
+SELECT count(*) FROM products;
+→ [{"count(*)":1}]
+
+-- NO ACTION → RESTRICT: deleting parent with existing children fails
+DELETE FROM categories WHERE id = 1;
+-- error: violates RESTRICT from 'products'
+
+-- Nothing changed
+SELECT count(*) FROM categories WHERE id = 1;
+→ [{"count(*)":1}]
+SELECT count(*) FROM products WHERE cat_id = 1;
+→ [{"count(*)":1}]
+
+-- Deleting an unreferenced parent succeeds
+DELETE FROM categories WHERE id = 2;
+SELECT count(*) FROM categories;
+→ [{"count(*)":1}]
+
+DROP TABLE products;
+DROP TABLE categories;
+
+-- ===================================================================
+-- Phase 2: Cascading actions
+-- ===================================================================
+
+-- --- CASCADE DELETE ---
+
+CREATE TABLE parent_table (
+    id INTEGER PRIMARY KEY,
+    data TEXT
+);
+
+CREATE TABLE child_table (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER,
+    info TEXT,
+    FOREIGN KEY (parent_id) REFERENCES parent_table(id) ON DELETE CASCADE
+);
+
+INSERT INTO parent_table VALUES (1, 'P1'), (2, 'P2'), (3, 'P3');
+INSERT INTO child_table VALUES (10, 1, 'C1a'), (11, 1, 'C1b'), (20, 2, 'C2a');
+
+-- Commit setup
+SELECT count(*) FROM child_table;
+→ [{"count(*)":3}]
+
+-- Delete parent row - children should cascade
+DELETE FROM parent_table WHERE id = 1;
+
+SELECT count(*) FROM parent_table WHERE id = 1;
+→ [{"count(*)":0}]
+
+-- Child rows referencing parent_id=1 should be gone
+SELECT count(*) FROM child_table WHERE parent_id = 1;
+→ [{"count(*)":0}]
+
+-- Child rows referencing parent_id=2 should still exist
+SELECT count(*) FROM child_table WHERE parent_id = 2;
+→ [{"count(*)":1}]
+
+DROP TABLE child_table;
+DROP TABLE parent_table;
+
+-- --- CASCADE UPDATE ---
+
+CREATE TABLE ref_parent (
+    id INTEGER PRIMARY KEY,
+    value TEXT
+);
+
+CREATE TABLE ref_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER,
+    FOREIGN KEY (parent_id) REFERENCES ref_parent(id) ON UPDATE CASCADE
+);
+
+INSERT INTO ref_parent VALUES (1, 'A'), (2, 'B');
+INSERT INTO ref_child VALUES (100, 1), (101, 1), (200, 2);
+
+-- Commit setup
+SELECT count(*) FROM ref_child;
+→ [{"count(*)":3}]
+
+-- Update parent PK - children should cascade
+UPDATE ref_parent SET id = 10 WHERE id = 1;
+
+SELECT parent_id FROM ref_child WHERE id = 100;
+→ [{"parent_id":10}]
+SELECT parent_id FROM ref_child WHERE id = 101;
+→ [{"parent_id":10}]
+
+-- Non-cascaded child should be unchanged
+SELECT parent_id FROM ref_child WHERE id = 200;
+→ [{"parent_id":2}]
+
+DROP TABLE ref_child;
+DROP TABLE ref_parent;
+
+-- --- SET NULL on DELETE ---
+
+CREATE TABLE sn_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE sn_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES sn_parent(id) ON DELETE SET NULL
+);
+
+INSERT INTO sn_parent VALUES (1, 'X'), (2, 'Y');
+INSERT INTO sn_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- Commit setup
+Select count(*) FROM sn_child;
+→ [{"count(*)":3}]
+
+-- Delete parent - child FK columns should become NULL
+DELETE FROM sn_parent WHERE id = 1;
+
+SELECT id, parent_id FROM sn_child ORDER BY id;
+→ [{"id":1,"parent_id":null},{"id":2,"parent_id":null},{"id":3,"parent_id":2}]
+
+DROP TABLE sn_child;
+DROP TABLE sn_parent;
+
+-- --- SET DEFAULT on DELETE ---
+
+CREATE TABLE sd_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE sd_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER DEFAULT 0,
+    FOREIGN KEY (parent_id) REFERENCES sd_parent(id) ON DELETE SET DEFAULT
+);
+
+INSERT INTO sd_parent VALUES (0, 'Default'), (1, 'One'), (2, 'Two');
+INSERT INTO sd_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- Commit setup
+SELECT count(*) FROM sd_child;
+→ [{"count(*)":3}]
+
+-- Delete parent - child FK columns should become default (0)
+DELETE FROM sd_parent WHERE id = 1;
+
+SELECT id, parent_id FROM sd_child ORDER BY id;
+→ [{"id":1,"parent_id":0},{"id":2,"parent_id":0},{"id":3,"parent_id":2}]
+
+DROP TABLE sd_child;
+DROP TABLE sd_parent;
+
+-- --- SET NULL on UPDATE ---
+
+CREATE TABLE snu_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE snu_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES snu_parent(id) ON UPDATE SET NULL
+);
+
+INSERT INTO snu_parent VALUES (1, 'X'), (2, 'Y');
+INSERT INTO snu_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- Update parent PK - child FK columns should become NULL
+UPDATE snu_parent SET id = 10 WHERE id = 1;
+
+SELECT id, parent_id FROM snu_child ORDER BY id;
+→ [{"id":1,"parent_id":null},{"id":2,"parent_id":null},{"id":3,"parent_id":2}]
+
+DROP TABLE snu_child;
+DROP TABLE snu_parent;
+
+-- --- SET DEFAULT on UPDATE ---
+
+CREATE TABLE sdu_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE sdu_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER DEFAULT 0,
+    FOREIGN KEY (parent_id) REFERENCES sdu_parent(id) ON UPDATE SET DEFAULT
+);
+
+INSERT INTO sdu_parent VALUES (0, 'Default'), (1, 'One'), (2, 'Two');
+INSERT INTO sdu_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- Update parent PK - child FK columns should become default (0)
+UPDATE sdu_parent SET id = 10 WHERE id = 1;
+
+SELECT id, parent_id FROM sdu_child ORDER BY id;
+→ [{"id":1,"parent_id":0},{"id":2,"parent_id":0},{"id":3,"parent_id":2}]
+
+DROP TABLE sdu_child;
+DROP TABLE sdu_parent;
+
+-- ===================================================================
+-- NULL FK values (NULLs don't participate in FK matching)
+-- ===================================================================
+
+CREATE TABLE null_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE null_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES null_parent(id) ON DELETE RESTRICT
+);
+
+INSERT INTO null_parent VALUES (1, 'A');
+
+-- Inserting NULL FK value should succeed (NULLs bypass FK checks)
+INSERT INTO null_child VALUES (1, NULL);
+SELECT * FROM null_child;
+→ [{"id":1,"parent_id":null}]
+
+-- Update FK column to NULL should also succeed (MATCH SIMPLE applies to UPDATE too)
+INSERT INTO null_parent VALUES (2, 'B');
+INSERT INTO null_child VALUES (2, 2);
+UPDATE null_child SET parent_id = NULL WHERE id = 2;
+SELECT * FROM null_child ORDER BY id;
+→ [{"id":1,"parent_id":null},{"id":2,"parent_id":null}]
+
+DROP TABLE null_child;
+DROP TABLE null_parent;
+
+-- --- MATCH SIMPLE: NULL FK with empty parent (RESTRICT) ---
+
+CREATE TABLE ms_parent (
+    id INTEGER PRIMARY KEY
+);
+
+CREATE TABLE ms_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES ms_parent(id) ON DELETE RESTRICT
+);
+
+-- Insert with NULL FK into empty parent table — must succeed per MATCH SIMPLE
+INSERT INTO ms_child VALUES (1, NULL);
+SELECT * FROM ms_child;
+→ [{"id":1,"parent_id":null}]
+
+DROP TABLE ms_child;
+DROP TABLE ms_parent;
+
+-- --- MATCH SIMPLE: self-referential FK, first row NULL ---
+
+CREATE TABLE ms_tree (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES ms_tree(id) ON DELETE CASCADE
+);
+
+-- Insert root with NULL parent_id into empty table — must succeed
+INSERT INTO ms_tree VALUES (1, NULL);
+SELECT * FROM ms_tree;
+→ [{"id":1,"parent_id":null}]
+
+DROP TABLE ms_tree;
+
+-- --- MATCH SIMPLE: multi-column FK, one NULL column ---
+
+CREATE TABLE ms_mc_parent (
+    a INTEGER,
+    b INTEGER,
+    PRIMARY KEY (a, b)
+);
+
+CREATE TABLE ms_mc_child (
+    id INTEGER PRIMARY KEY,
+    ref_a INTEGER NULL,
+    ref_b INTEGER NULL,
+    FOREIGN KEY (ref_a, ref_b) REFERENCES ms_mc_parent(a, b) ON DELETE RESTRICT
+);
+
+-- One NULL column satisfies MATCH SIMPLE even with empty parent
+INSERT INTO ms_mc_child VALUES (1, 42, NULL);
+SELECT * FROM ms_mc_child;
+→ [{"id":1,"ref_a":42,"ref_b":null}]
+
+DROP TABLE ms_mc_child;
+DROP TABLE ms_mc_parent;
+
+-- --- MATCH SIMPLE: multi-column FK, all NULLs ---
+
+CREATE TABLE ms_mc2_parent (
+    a INTEGER,
+    b INTEGER,
+    PRIMARY KEY (a, b)
+);
+
+CREATE TABLE ms_mc2_child (
+    id INTEGER PRIMARY KEY,
+    ref_a INTEGER NULL,
+    ref_b INTEGER NULL,
+    FOREIGN KEY (ref_a, ref_b) REFERENCES ms_mc2_parent(a, b) ON DELETE RESTRICT
+);
+
+-- All NULLs satisfies MATCH SIMPLE
+INSERT INTO ms_mc2_child VALUES (1, NULL, NULL);
+SELECT * FROM ms_mc2_child;
+→ [{"id":1,"ref_a":null,"ref_b":null}]
+
+DROP TABLE ms_mc2_child;
+DROP TABLE ms_mc2_parent;
+
+-- --- MATCH SIMPLE: multi-column FK, no NULLs, no match (regression guard) ---
+
+CREATE TABLE ms_mc3_parent (
+    a INTEGER,
+    b INTEGER,
+    PRIMARY KEY (a, b)
+);
+
+CREATE TABLE ms_mc3_child (
+    id INTEGER PRIMARY KEY,
+    ref_a INTEGER,
+    ref_b INTEGER,
+    FOREIGN KEY (ref_a, ref_b) REFERENCES ms_mc3_parent(a, b) ON DELETE RESTRICT
+);
+
+-- No NULLs, no matching parent row — must fail
+INSERT INTO ms_mc3_child VALUES (1, 1, 2);
+-- error: CHECK constraint failed: _fk_ms_mc3_child_ref_a_ref_b
+
+DROP TABLE ms_mc3_child;
+DROP TABLE ms_mc3_parent;
+
+-- ===================================================================
+-- Multi-column FK
+-- ===================================================================
+
+CREATE TABLE mc_parent (
+    a INTEGER,
+    b INTEGER,
+    data TEXT,
+    PRIMARY KEY (a, b)
+);
+
+CREATE TABLE mc_child (
+    id INTEGER PRIMARY KEY,
+    ref_a INTEGER,
+    ref_b INTEGER,
+    FOREIGN KEY (ref_a, ref_b) REFERENCES mc_parent(a, b) ON DELETE CASCADE
+);
+
+INSERT INTO mc_parent VALUES (1, 10, 'P1'), (2, 20, 'P2');
+INSERT INTO mc_child VALUES (1, 1, 10), (2, 2, 20);
+
+-- Valid composite FK insert
+SELECT count(*) FROM mc_child;
+→ [{"count(*)":2}]
+
+-- Invalid composite FK insert (no matching parent)
+INSERT INTO mc_child VALUES (3, 1, 99);
+-- error: CHECK constraint failed: _fk_mc_child_ref_a_ref_b
+
+-- CASCADE DELETE with composite FK
+DELETE FROM mc_parent WHERE a = 1 AND b = 10;
+SELECT count(*) FROM mc_child WHERE ref_a = 1;
+→ [{"count(*)":0}]
+
+-- Other child rows intact
+SELECT count(*) FROM mc_child WHERE ref_a = 2;
+→ [{"count(*)":1}]
+
+DROP TABLE mc_child;
+DROP TABLE mc_parent;
+
+-- ===================================================================
+-- Pragma on/off behavior
+-- ===================================================================
+
+PRAGMA foreign_keys = false;
+
+CREATE TABLE p_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE p_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER,
+    FOREIGN KEY (parent_id) REFERENCES p_parent(id) ON DELETE RESTRICT
+);
+
+-- With FK off, should be able to insert orphan row
+INSERT INTO p_child VALUES (1, 999);
+SELECT * FROM p_child;
+→ [{"id":1,"parent_id":999}]
+
+-- Turn FK on - existing data is not retroactively checked
+PRAGMA foreign_keys = true;
+
+-- New inserts should be checked
+INSERT INTO p_child VALUES (2, 888);
+-- error: CHECK constraint failed: _fk_p_child_parent_id
+
+DROP TABLE p_child;
+DROP TABLE p_parent;
+
+-- ===================================================================
+-- Column-level FK syntax
+-- ===================================================================
+
+PRAGMA foreign_keys = true;
+
+CREATE TABLE col_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE col_child (
+    id INTEGER PRIMARY KEY,
+    ref_id INTEGER REFERENCES col_parent(id) ON DELETE CASCADE
+);
+
+INSERT INTO col_parent VALUES (1, 'A'), (2, 'B');
+INSERT INTO col_child VALUES (10, 1), (20, 2);
+
+-- CASCADE DELETE via column-level FK
+DELETE FROM col_parent WHERE id = 1;
+SELECT count(*) FROM col_child WHERE ref_id = 1;
+→ [{"count(*)":0}]
+
+-- Remaining data intact
+SELECT count(*) FROM col_child WHERE ref_id = 2;
+→ [{"count(*)":1}]
+
+DROP TABLE col_child;
+DROP TABLE col_parent;
+
+-- ===================================================================
+-- Cycle detection
+-- ===================================================================
+
+PRAGMA foreign_keys = true;
+
+CREATE TABLE cycle_a (
+    id INTEGER PRIMARY KEY,
+    b_id INTEGER
+);
+
+CREATE TABLE cycle_b (
+    id INTEGER PRIMARY KEY,
+    a_id INTEGER,
+    FOREIGN KEY (a_id) REFERENCES cycle_a(id) ON DELETE CASCADE
+);
+
+-- Add FK from cycle_a to cycle_b after both tables exist
+-- (Note: cycle_a -> cycle_b -> cycle_a would form a cascade cycle)
+-- For now, test that simple cascades don't trigger false cycle detection
+INSERT INTO cycle_a VALUES (1, 10);
+INSERT INTO cycle_b VALUES (10, 1);
+
+-- Commit setup
+SELECT count(*) FROM cycle_b;
+→ [{"count(*)":1}]
+
+-- Deleting from cycle_a should cascade to cycle_b
+DELETE FROM cycle_a WHERE id = 1;
+SELECT count(*) FROM cycle_b WHERE a_id = 1;
+→ [{"count(*)":0}]
+
+DROP TABLE cycle_b;
+DROP TABLE cycle_a;
+
+-- ===================================================================
+-- UPSERT DO UPDATE with FK CASCADE on parent table
+-- ===================================================================
+
+-- CASCADE UPDATE via UPSERT DO UPDATE on parent
+
+CREATE TABLE upsert_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE upsert_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER,
+    FOREIGN KEY (parent_id) REFERENCES upsert_parent(id) ON UPDATE CASCADE
+);
+
+INSERT INTO upsert_parent VALUES (1, 'Alice'), (2, 'Bob');
+INSERT INTO upsert_child VALUES (10, 1), (20, 1), (30, 2);
+
+-- UPSERT that updates parent PK: child rows should cascade
+INSERT INTO upsert_parent (id, name) VALUES (1, 'Alice_updated')
+ON CONFLICT (id) DO UPDATE SET id = 100, name = NEW.name;
+
+-- Parent row should have new id
+SELECT id, name FROM upsert_parent WHERE id = 100;
+→ [{"id":100,"name":"Alice_updated"}]
+
+-- Child rows should have cascaded to new parent_id
+SELECT id, parent_id FROM upsert_child ORDER BY id;
+→ [{"id":10,"parent_id":100},{"id":20,"parent_id":100},{"id":30,"parent_id":2}]
+
+DROP TABLE upsert_child;
+DROP TABLE upsert_parent;
+
+-- SET NULL via UPSERT DO UPDATE on parent
+
+CREATE TABLE upsert_sn_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE upsert_sn_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES upsert_sn_parent(id) ON UPDATE SET NULL
+);
+
+INSERT INTO upsert_sn_parent VALUES (1, 'X'), (2, 'Y');
+INSERT INTO upsert_sn_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- UPSERT that updates parent PK: child FK columns should become NULL
+INSERT INTO upsert_sn_parent (id, name) VALUES (1, 'X_new')
+ON CONFLICT (id) DO UPDATE SET id = 10, name = NEW.name;
+
+SELECT id, parent_id FROM upsert_sn_child ORDER BY id;
+→ [{"id":1,"parent_id":null},{"id":2,"parent_id":null},{"id":3,"parent_id":2}]
+
+DROP TABLE upsert_sn_child;
+DROP TABLE upsert_sn_parent;
+
+-- ===================================================================
+-- INSERT OR REPLACE with FK CASCADE on parent table
+-- ===================================================================
+
+-- CASCADE DELETE via INSERT OR REPLACE on parent
+
+CREATE TABLE repl_del_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE repl_del_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER,
+    FOREIGN KEY (parent_id) REFERENCES repl_del_parent(id) ON DELETE CASCADE
+);
+
+INSERT INTO repl_del_parent VALUES (1, 'Alice'), (2, 'Bob');
+INSERT INTO repl_del_child VALUES (10, 1), (20, 1), (30, 2);
+
+-- REPLACE is semantically delete+insert, so ON DELETE CASCADE should fire
+INSERT OR REPLACE INTO repl_del_parent VALUES (1, 'Alice_replaced');
+
+-- Child rows referencing parent_id=1 should be cascade-deleted
+SELECT id, parent_id FROM repl_del_child ORDER BY id;
+→ [{"id":30,"parent_id":2}]
+
+DROP TABLE repl_del_child;
+DROP TABLE repl_del_parent;
+
+-- SET NULL via INSERT OR REPLACE on parent (ON DELETE SET NULL)
+
+CREATE TABLE repl_sn_parent (
+    id INTEGER PRIMARY KEY,
+    name TEXT
+);
+
+CREATE TABLE repl_sn_child (
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER NULL,
+    FOREIGN KEY (parent_id) REFERENCES repl_sn_parent(id) ON DELETE SET NULL
+);
+
+INSERT INTO repl_sn_parent VALUES (1, 'X'), (2, 'Y');
+INSERT INTO repl_sn_child VALUES (1, 1), (2, 1), (3, 2);
+
+-- REPLACE parent — child FK columns should become NULL via ON DELETE SET NULL
+INSERT OR REPLACE INTO repl_sn_parent VALUES (1, 'X_replaced');
+
+SELECT id, parent_id FROM repl_sn_child ORDER BY id;
+→ [{"id":1,"parent_id":null},{"id":2,"parent_id":null},{"id":3,"parent_id":2}]
+
+DROP TABLE repl_sn_child;
+DROP TABLE repl_sn_parent;
+
+-- ===================================================================
+-- Phase: Parent-side FK UPDATE column-mask (regression for fix-fk-parent-update-column-mask)
+-- ===================================================================
+-- Updates that don't touch any FK-referenced parent column must NOT trip
+-- the synthesised parent-side NOT EXISTS check.
+
+CREATE TABLE pmask_parent (id TEXT PRIMARY KEY, name TEXT NOT NULL);
+CREATE TABLE pmask_child (parent_id TEXT PRIMARY KEY REFERENCES pmask_parent(id));
+
+INSERT INTO pmask_parent VALUES ('a', 'x');
+INSERT INTO pmask_child VALUES ('a');
+
+-- UPDATE on a non-referenced column succeeds even with referencing child rows
+UPDATE pmask_parent SET name = 'y' WHERE id = 'a';
+
+SELECT id, name FROM pmask_parent;
+→ [{"id":"a","name":"y"}]
+
+-- UPDATE that touches the referenced PK still trips RESTRICT
+UPDATE pmask_parent SET id = 'b' WHERE id = 'a';
+-- error: violates RESTRICT from 'pmask_child'
+
+DROP TABLE pmask_child;
+DROP TABLE pmask_parent;
+
+-- Two FKs referencing different parent columns: updating only one must
+-- skip the other parent-side check.
+
+CREATE TABLE pmask2_parent (
+    id INTEGER PRIMARY KEY,
+    code TEXT NOT NULL UNIQUE,
+    label TEXT NOT NULL UNIQUE,
+    extra TEXT NULL
+);
+CREATE TABLE pmask2_child_code (
+    cid INTEGER PRIMARY KEY,
+    parent_code TEXT REFERENCES pmask2_parent(code)
+);
+CREATE TABLE pmask2_child_label (
+    cid INTEGER PRIMARY KEY,
+    parent_label TEXT REFERENCES pmask2_parent(label)
+);
+
+INSERT INTO pmask2_parent VALUES (1, 'C1', 'L1', NULL);
+INSERT INTO pmask2_child_code VALUES (10, 'C1');
+INSERT INTO pmask2_child_label VALUES (20, 'L1');
+
+-- Updating `label` only: pmask2_child_code's parent-side check (on `code`) must skip;
+-- pmask2_child_label's check fires on `label` change → RESTRICT.
+UPDATE pmask2_parent SET label = 'L2' WHERE id = 1;
+-- error: violates RESTRICT from 'pmask2_child_label'
+
+-- Updating `code` only: symmetric — pmask2_child_code's check fires.
+UPDATE pmask2_parent SET code = 'C2' WHERE id = 1;
+-- error: violates RESTRICT from 'pmask2_child_code'
+
+-- Updating neither referenced column: both checks must skip.
+UPDATE pmask2_parent SET extra = 'ok' WHERE id = 1;
+
+SELECT id, code, label, extra FROM pmask2_parent;
+→ [{"id":1,"code":"C1","label":"L1","extra":"ok"}]
+
+DROP TABLE pmask2_child_label;
+DROP TABLE pmask2_child_code;
+DROP TABLE pmask2_parent;
+
+-- ===================================================================
+-- Phase: change-detection short-circuit coerces before comparing
+-- (regression for bug-fk-restrict-change-detection-uncoerced)
+-- ===================================================================
+-- The referenced-column-change short-circuit used to compare the stored OLD
+-- value against the raw, uncoerced NEW value, so a value spelled differently
+-- from its stored form (integer 1 written as text '1'; a JSON object written
+-- with reordered keys) read as "changed" and wrongly tripped RESTRICT even
+-- though the stored value would not actually move. Both tables below carry a
+-- RESTRICT child and a CASCADE child on the SAME parent so the gate that
+-- batches pure-RESTRICT statements (see 41.9-fk-restrict-batched.sqllogic)
+-- excludes them: the update runs the per-row transitive pre-walk
+-- (assertNoRestrictedChildrenForParentMutation + the cascade-recursion arm of
+-- assertTransitiveRestrictsForParentMutation), not the batched accumulator.
+
+CREATE TABLE crc_parent (id INTEGER PRIMARY KEY, other INTEGER);
+CREATE TABLE crc_restrict_child (cid INTEGER PRIMARY KEY, p_id INTEGER,
+    FOREIGN KEY (p_id) REFERENCES crc_parent(id) ON UPDATE RESTRICT);
+CREATE TABLE crc_cascade_child (cid INTEGER PRIMARY KEY, p_id INTEGER,
+    FOREIGN KEY (p_id) REFERENCES crc_parent(id) ON UPDATE CASCADE);
+
+INSERT INTO crc_parent VALUES (1, 100);
+INSERT INTO crc_restrict_child VALUES (10, 1);
+INSERT INTO crc_cascade_child VALUES (20, 1);
+
+-- Rewriting the integer key as the text '1' does not change the stored value:
+-- must NOT trip RESTRICT.
+UPDATE crc_parent SET id = '1' WHERE id = 1;
+SELECT id FROM crc_parent;
+→ [{"id":1}]
+
+-- The cascade child must be untouched too — no key change means no
+-- propagating UPDATE should fire (the short-circuit is shared by both arms).
+SELECT p_id FROM crc_cascade_child;
+→ [{"p_id":1}]
+
+-- Sanity: a genuine key change with a live RESTRICT child still raises the
+-- error, so the fix cannot silently disable enforcement. Mixed actions are
+-- not batchable, so this is the plan-time synthesized parent-side NOT EXISTS
+-- (ConstraintCheckNode), not the runtime pre-walk's friendlier message.
+UPDATE crc_parent SET id = 2 WHERE id = 1;
+-- error: CHECK constraint failed: _fk_crc_restrict_child_p_id
+
+DROP TABLE crc_cascade_child;
+DROP TABLE crc_restrict_child;
+DROP TABLE crc_parent;
+
+-- Same short-circuit, JSON-typed key: a value re-typed through the column's
+-- logical type (validateAndParse) rather than compared as raw text — a JSON
+-- object rewritten with different whitespace / key order is the same stored
+-- value.
+
+CREATE TABLE crcj_parent (id JSON PRIMARY KEY, other INTEGER);
+CREATE TABLE crcj_restrict_child (cid INTEGER PRIMARY KEY, p_id JSON,
+    FOREIGN KEY (p_id) REFERENCES crcj_parent(id) ON UPDATE RESTRICT);
+CREATE TABLE crcj_cascade_child (cid INTEGER PRIMARY KEY, p_id JSON,
+    FOREIGN KEY (p_id) REFERENCES crcj_parent(id) ON UPDATE CASCADE);
+
+INSERT INTO crcj_parent VALUES ('{"a":1,"b":2}', 100);
+INSERT INTO crcj_restrict_child VALUES (10, '{"a":1,"b":2}');
+INSERT INTO crcj_cascade_child VALUES (20, '{"a":1,"b":2}');
+
+-- Reorder-equal JSON key: must NOT trip RESTRICT.
+UPDATE crcj_parent SET id = '{"b": 2, "a": 1}' WHERE other = 100;
+SELECT id FROM crcj_parent;
+→ [{"id":{"b":2,"a":1}}]
+
+-- Cascade child untouched (no key change ⇒ no propagating UPDATE).
+SELECT p_id FROM crcj_cascade_child;
+→ [{"p_id":{"a":1,"b":2}}]
+
+-- Sanity: a genuine JSON key change with a live RESTRICT child still raises
+-- the error (plan-time NOT EXISTS, as above — mixed actions are not batchable).
+UPDATE crcj_parent SET id = '{"a":9,"b":9}' WHERE other = 100;
+-- error: CHECK constraint failed: _fk_crcj_restrict_child_p_id
+
+DROP TABLE crcj_cascade_child;
+DROP TABLE crcj_restrict_child;
+DROP TABLE crcj_parent;
+
+-- ON DELETE RESTRICT has no NEW row, so the change-detection short-circuit
+-- never runs for it — guard that the refactor left the delete path alone.
+CREATE TABLE crcd_parent (id INTEGER PRIMARY KEY);
+CREATE TABLE crcd_child (cid INTEGER PRIMARY KEY, p_id INTEGER,
+    FOREIGN KEY (p_id) REFERENCES crcd_parent(id) ON DELETE RESTRICT);
+
+INSERT INTO crcd_parent VALUES (1);
+INSERT INTO crcd_child VALUES (10, 1);
+
+DELETE FROM crcd_parent WHERE id = 1;
+-- error: violates RESTRICT from 'crcd_child'
+
+DROP TABLE crcd_child;
+DROP TABLE crcd_parent;
+
+-- ===================================================================
+-- Phase: ON UPDATE action gate — untouched referenced column must not
+-- fire the action at all (regression for fk-update-actions-fire-when-key-unchanged)
+-- ===================================================================
+-- executeForeignKeyActions used to re-issue the child DML for CASCADE / SET NULL /
+-- SET DEFAULT after every parent UPDATE, even when the referenced column never
+-- changed. Updating an unrelated parent column wrongly rewrote (or nulled) child
+-- rows that were never re-keyed. Each block below asserts the untouched case is a
+-- no-op and a genuine re-key still fires the action.
+
+-- SET DEFAULT: an untouched referenced column must leave the child alone; a
+-- genuine re-key must still re-point the child to the default (a live parent key).
+CREATE TABLE fkgd_parent (id INTEGER PRIMARY KEY, other INTEGER);
+CREATE TABLE fkgd_child (cid INTEGER PRIMARY KEY, p_id INTEGER DEFAULT 99,
+    FOREIGN KEY (p_id) REFERENCES fkgd_parent(id) ON UPDATE SET DEFAULT);
+
+INSERT INTO fkgd_parent VALUES (1, 100), (99, 200);
+INSERT INTO fkgd_child VALUES (10, 1);
+
+UPDATE fkgd_parent SET other = 111 WHERE id = 1;
+SELECT p_id FROM fkgd_child WHERE cid = 10;
+→ [{"p_id":1}]
+
+UPDATE fkgd_parent SET id = 7 WHERE id = 1;
+SELECT p_id FROM fkgd_child WHERE cid = 10;
+→ [{"p_id":99}]
+
+DROP TABLE fkgd_child;
+DROP TABLE fkgd_parent;
+
+-- SET NULL, nullable child column: an untouched referenced column must leave the
+-- child alone; a genuine re-key must still null it out.
+CREATE TABLE fkgn_parent (id INTEGER PRIMARY KEY, other INTEGER);
+CREATE TABLE fkgn_child (cid INTEGER PRIMARY KEY, p_id INTEGER NULL,
+    FOREIGN KEY (p_id) REFERENCES fkgn_parent(id) ON UPDATE SET NULL);
+
+INSERT INTO fkgn_parent VALUES (1, 100);
+INSERT INTO fkgn_child VALUES (10, 1);
+
+UPDATE fkgn_parent SET other = 111 WHERE id = 1;
+SELECT p_id FROM fkgn_child WHERE cid = 10;
+→ [{"p_id":1}]
+
+UPDATE fkgn_parent SET id = 7 WHERE id = 1;
+SELECT p_id FROM fkgn_child WHERE cid = 10;
+→ [{"p_id":null}]
+
+DROP TABLE fkgn_child;
+DROP TABLE fkgn_parent;
+
+-- SET NULL, non-nullable child column: before the fix, an update leaving the
+-- referenced column alone still re-issued the child SET NULL and tripped NOT NULL.
+-- It must now succeed as a no-op on the child. This is the case most likely to
+-- regress unnoticed, since the symptom was an error rather than silently bad data.
+-- NOT NULL is spelled out even though it is Quereus's column default, so the case
+-- keeps testing what it claims if that default ever changes.
+CREATE TABLE fkgnn_parent (id INTEGER PRIMARY KEY, other INTEGER);
+CREATE TABLE fkgnn_child (cid INTEGER PRIMARY KEY, p_id INTEGER NOT NULL,
+    FOREIGN KEY (p_id) REFERENCES fkgnn_parent(id) ON UPDATE SET NULL);
+
+INSERT INTO fkgnn_parent VALUES (1, 100);
+INSERT INTO fkgnn_child VALUES (10, 1);
+
+UPDATE fkgnn_parent SET other = 111 WHERE id = 1;
+SELECT p_id FROM fkgnn_child WHERE cid = 10;
+→ [{"p_id":1}]
+
+DROP TABLE fkgnn_child;
+DROP TABLE fkgnn_parent;
+
+-- CASCADE: an untouched referenced column must leave the child value alone (a
+-- phantom rewrite-to-same-value used to fire here — see the runtime spec for the
+-- data-change-event assertion this value-only check cannot make); a genuine
+-- re-key must still cascade.
+CREATE TABLE fkgc_parent (id INTEGER PRIMARY KEY, other INTEGER);
+CREATE TABLE fkgc_child (cid INTEGER PRIMARY KEY, p_id INTEGER,
+    FOREIGN KEY (p_id) REFERENCES fkgc_parent(id) ON UPDATE CASCADE);
+
+INSERT INTO fkgc_parent VALUES (1, 100);
+INSERT INTO fkgc_child VALUES (10, 1);
+
+UPDATE fkgc_parent SET other = 111 WHERE id = 1;
+SELECT p_id FROM fkgc_child WHERE cid = 10;
+→ [{"p_id":1}]
+
+UPDATE fkgc_parent SET id = 7 WHERE id = 1;
+SELECT p_id FROM fkgc_child WHERE cid = 10;
+→ [{"p_id":7}]
+
+DROP TABLE fkgc_child;
+DROP TABLE fkgc_parent;
+
+-- Composite CASCADE: the gate asks whether ANY referenced column changed, so a
+-- parent update that moves only the second key column must still cascade, while
+-- one that moves neither must not fire at all.
+CREATE TABLE fkgmc_parent (a INTEGER, b INTEGER, other INTEGER, PRIMARY KEY (a, b));
+CREATE TABLE fkgmc_child (cid INTEGER PRIMARY KEY, ref_a INTEGER, ref_b INTEGER,
+    FOREIGN KEY (ref_a, ref_b) REFERENCES fkgmc_parent(a, b) ON UPDATE CASCADE);
+
+INSERT INTO fkgmc_parent VALUES (1, 2, 100);
+INSERT INTO fkgmc_child VALUES (10, 1, 2);
+
+UPDATE fkgmc_parent SET other = 111 WHERE a = 1 AND b = 2;
+SELECT ref_a, ref_b FROM fkgmc_child WHERE cid = 10;
+→ [{"ref_a":1,"ref_b":2}]
+
+UPDATE fkgmc_parent SET b = 20 WHERE a = 1 AND b = 2;
+SELECT ref_a, ref_b FROM fkgmc_child WHERE cid = 10;
+→ [{"ref_a":1,"ref_b":20}]
+
+DROP TABLE fkgmc_child;
+DROP TABLE fkgmc_parent;
+