@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/50-declarative-schema.sqllogic

@@ -0,0 +1,2550 @@
+-- Test declarative schema full lifecycle
+
+-- Step 1: Declare a schema with a table
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT
+	}
+}
+
+-- run
+
+-- Step 2: Diff against empty database (should show CREATE TABLE as DDL row)
+diff schema main;
+→ [{"ddl": "create table users (id INTEGER primary key, name TEXT not null, email TEXT)"}]
+
+-- Step 3: Apply the schema (creates the table, returns nothing)
+apply schema main;
+
+-- run
+
+-- Step 4: Verify table was created
+select count(*) from users;
+→ [{"count(*)": 0}]
+
+-- Step 5: Diff again - should now be empty (no rows) since schema matches
+diff schema main;
+→ []
+
+-- Step 6: Declare schema with seed data
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT
+	}
+
+	seed users (
+		(1, 'Alice', 'alice@example.com'),
+		(2, 'Bob', 'bob@example.com')
+	)
+}
+
+-- run
+
+-- Step 7: Apply with seed (no rows returned)
+apply schema main with seed;
+
+-- run
+
+-- Step 8: Verify seed data was inserted
+select * from users order by id;
+→ [{"id": 1, "name": "Alice", "email": "alice@example.com"}, {"id": 2, "name": "Bob", "email": "bob@example.com"}]
+
+-- Step 9: Test forward references - declare tables out of order with foreign keys
+declare schema main {
+	table posts {
+		id INTEGER PRIMARY KEY,
+		user_id INTEGER NOT NULL,
+		title TEXT NOT NULL,
+		content TEXT,
+		constraint fk_user foreign key (user_id) references users(id)
+	}
+
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT
+	}
+
+	table comments {
+		id INTEGER PRIMARY KEY,
+		post_id INTEGER NOT NULL,
+		user_id INTEGER NOT NULL,
+		text TEXT NOT NULL,
+		constraint fk_post foreign key (post_id) references posts(id),
+		constraint fk_comment_user foreign key (user_id) references users(id)
+	}
+}
+
+-- run
+
+-- Step 10: Diff should show posts and comments to create (users already exists)
+diff schema main;
+→ [{"ddl": "create table posts (id INTEGER primary key, user_id INTEGER not null, title TEXT not null, content TEXT, constraint fk_user foreign key (user_id) references users(id))"}, {"ddl": "create table comments (id INTEGER primary key, post_id INTEGER not null, user_id INTEGER not null, text TEXT not null, constraint fk_post foreign key (post_id) references posts(id), constraint fk_comment_user foreign key (user_id) references users(id))"}]
+
+-- Step 11: Apply the forward-referenced schema
+apply schema main;
+
+-- run
+
+-- Step 12: Verify all three tables exist
+select count(*) from users;
+→ [{"count(*)": 2}]
+
+select count(*) from posts;
+→ [{"count(*)": 0}]
+
+select count(*) from comments;
+→ [{"count(*)": 0}]
+
+-- Step 13: Insert data respecting foreign key order
+insert into posts (id, user_id, title, content) values (1, 1, 'First Post', 'This is the content');
+insert into comments (id, post_id, user_id, text) values (1, 1, 2, 'Great post!');
+
+select p.title, c.text, u.name as commenter
+from posts p
+join comments c on p.id = c.post_id
+join users u on c.user_id = u.id;
+→ [{"title": "First Post", "text": "Great post!", "commenter": "Bob"}]
+
+-- Step 14: Test table removal via redeclaration (only keep users)
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT
+	}
+}
+
+-- run
+
+-- Step 15: Diff should show DROP statements for posts and comments
+-- (comments must be dropped before posts because it FK-references posts)
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS comments"}, {"ddl": "DROP TABLE IF EXISTS posts"}]
+
+-- Step 16: Apply to drop extra tables
+apply schema main;
+
+-- run
+
+-- Step 17: Verify posts and comments are gone
+select count(*) from users;
+→ [{"count(*)": 2}]
+
+select count(*) from posts;
+-- error: Table 'posts' not found in schema path
+
+select count(*) from comments;
+-- error: Table 'comments' not found in schema path
+
+-- Step 18: Test composite schema with multiple seeds and forward refs
+-- Declare a completely new schema (replacing the previous one)
+declare schema main {
+	table categories {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL
+	}
+
+	table products {
+		id INTEGER PRIMARY KEY,
+		category_id INTEGER NOT NULL,
+		name TEXT NOT NULL,
+		price REAL NOT NULL,
+		constraint fk_category foreign key (category_id) references categories(id)
+	}
+
+	seed categories (
+		(1, 'Electronics'),
+		(2, 'Books'),
+		(3, 'Clothing')
+	)
+
+	seed products (
+		(1, 1, 'Laptop', 999.99),
+		(2, 1, 'Mouse', 29.99),
+		(3, 2, 'SQL Guide', 49.99)
+	)
+}
+
+-- run
+
+-- Step 19: Apply complete replacement (drops users, creates categories/products)
+apply schema main with seed;
+
+-- run
+
+-- Step 20: Verify relational integrity with join
+select p.name as product, c.name as category, p.price
+from products p
+join categories c on p.category_id = c.id
+order by c.id, p.id;
+→ [{"product": "Laptop", "category": "Electronics", "price": 999.99}, {"product": "Mouse", "category": "Electronics", "price": 29.99}, {"product": "SQL Guide", "category": "Books", "price": 49.99}]
+
+-- Step 21: Verify old tables are gone
+select count(*) from users;
+-- error: not found in schema path:
+
+-- Step 22: Test trailing commas in table definitions
+declare schema main {
+	table config {
+		config_key TEXT PRIMARY KEY,
+		value TEXT,
+		description TEXT,
+	}
+}
+
+-- run
+
+apply schema main with seed;
+
+-- run
+
+select count(*) from config;
+→ [{"count(*)": 0}]
+
+-- Verify products table was dropped
+select count(*) from products;
+-- error: not found in schema path:
+
+-- Verify categories table was dropped
+select count(*) from categories;
+-- error: not found in schema path:
+
+-- Step 23: Test explicit main schema qualification
+select count(*) from main.config;
+→ [{"count(*)": 0}]
+
+-- Step 24: Verify trailing comma test passed
+declare schema main {
+	table test_trailing {
+		a INTEGER PRIMARY KEY,
+		b TEXT,
+		c TEXT,
+	}
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+select count(*) from test_trailing;
+→ [{"count(*)": 0}]
+
+-- Step 25: Test custom schema with forward references and CHECK constraints
+declare schema Test2 {
+	table A {
+		Col1 TEXT,
+		constraint Col1InB check on insert, update (exists (select 1 from B where new.Col1 = B.Col1))
+	}
+
+	table B {
+		Col1 TEXT,
+		primary key (Col1)
+	}
+
+	seed B (
+		('valid1'),
+		('valid2')
+	)
+}
+
+-- run
+
+apply schema Test2 with seed;
+
+-- run
+
+-- Verify B has seed data
+select * from Test2.B order by Col1;
+→ [{"Col1": "valid1"}, {"Col1": "valid2"}]
+
+-- Insert into A with value that exists in B (should succeed)
+insert into Test2.A (Col1) values ('valid1');
+
+select * from Test2.A;
+→ [{"Col1": "valid1"}]
+
+-- Insert into A with value that doesn't exist in B (should fail)
+insert into Test2.A (Col1) values ('invalid');
+-- error: CHECK constraint failed
+
+-- Verify schema isolation: Test2 and main are separate
+select count(*) from Test2.A;
+→ [{"count(*)": 1}]
+
+select count(*) from main.test_trailing;
+→ [{"count(*)": 0}]
+
+-- Step 26: Test views in declarative schema
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT,
+		active INTEGER DEFAULT 1
+	}
+
+	table posts {
+		id INTEGER PRIMARY KEY,
+		user_id INTEGER NOT NULL,
+		title TEXT NOT NULL,
+		content TEXT,
+		constraint fk_user foreign key (user_id) references users(id)
+	}
+
+	view active_users AS select id, name, email from users where active = 1
+
+	view user_posts AS select
+		u.name as author,
+		p.title,
+		p.content
+	from users u
+	join posts p on u.id = p.user_id
+	where u.active = 1
+
+	seed users (
+		(1, 'Alice', 'alice@example.com', 1),
+		(2, 'Bob', 'bob@example.com', 1),
+		(3, 'Charlie', 'charlie@example.com', 0)
+	)
+
+	seed posts (
+		(1, 1, 'First Post', 'Hello world'),
+		(2, 2, 'Second Post', 'Another post'),
+		(3, 3, 'Inactive Post', 'This should not appear in view')
+	)
+}
+
+-- run
+
+-- Step 27: Diff should show tables and views to create
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS test_trailing"}, {"ddl": "create table users (id INTEGER primary key, name TEXT not null, email TEXT, active INTEGER default 1)"}, {"ddl": "create table posts (id INTEGER primary key, user_id INTEGER not null, title TEXT not null, content TEXT, constraint fk_user foreign key (user_id) references users(id))"}, {"ddl": "create view active_users as select id, name, email from users where active = 1"}, {"ddl": "create view user_posts as select u.name as author, p.title, p.content from users as u inner join posts as p on u.id = p.user_id where u.active = 1"}]
+
+-- Step 28: Apply schema with views
+apply schema main with seed;
+
+-- run
+
+-- Step 29: Test views work correctly
+select * from active_users order by id;
+→ [{"id": 1, "name": "Alice", "email": "alice@example.com"}, {"id": 2, "name": "Bob", "email": "bob@example.com"}]
+
+select * from user_posts order by author;
+→ [{"author": "Alice", "title": "First Post", "content": "Hello world"}, {"author": "Bob", "title": "Second Post", "content": "Another post"}]
+
+-- Step 30: Test view with explicit column names
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT,
+		active INTEGER DEFAULT 1
+	}
+
+	view user_summary (user_id, full_name, contact) AS select id, name, email from users where active = 1
+}
+
+-- run
+
+-- Step 31: Diff should show view changes (drop old views, create new one)
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS posts"}, {"ddl": "DROP VIEW IF EXISTS active_users"}, {"ddl": "DROP VIEW IF EXISTS user_posts"}, {"ddl": "create view user_summary (user_id, full_name, contact) as select id, name, email from users where active = 1"}]
+
+-- Step 32: Apply view changes
+apply schema main;
+
+-- run
+
+-- Step 33: Test new view with explicit columns
+select * from user_summary order by user_id;
+→ [{"user_id": 1, "full_name": "Alice", "contact": "alice@example.com"}, {"user_id": 2, "full_name": "Bob", "contact": "bob@example.com"}]
+
+-- Step 33.1: Declarative apply rejects a conflicting-collation FK. The differ emits
+-- CREATE TABLE in dependency order (parent before child), so the child's CREATE
+-- re-executes through the same declaration-time collation validation as a direct
+-- CREATE TABLE and the apply fails. Isolated in schema Test3 so `main` is
+-- untouched. Ticket fk-collation-conflict-create-time-validation.
+declare schema Test3 {
+	table cfk_parent {
+		k TEXT COLLATE RTRIM PRIMARY KEY
+	}
+
+	table cfk_child {
+		id INTEGER PRIMARY KEY,
+		ref TEXT COLLATE NOCASE,
+		constraint fk_bad foreign key (ref) references cfk_parent(k)
+	}
+}
+
+-- run
+
+apply schema Test3;
+-- error: conflicting collations
+
+-- Step 34: Test view removal
+declare schema main {
+	table users {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		email TEXT,
+		active INTEGER DEFAULT 1
+	}
+}
+
+-- run
+
+-- Step 35: Diff should show view to drop
+diff schema main;
+→ [{"ddl": "DROP VIEW IF EXISTS user_summary"}]
+
+-- Step 36: Apply to remove view
+apply schema main;
+
+-- run
+
+-- Step 37: Verify view is gone
+select count(*) from user_summary;
+-- error: not found in schema path:
+
+-- Step 38: Test indexes in declarative schema
+-- Note: Using a unique table name to avoid DROP TABLE bug where data persists
+declare schema main {
+	table products_with_indexes {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		category TEXT,
+		price REAL
+	}
+
+	index idx_products_name on products_with_indexes(name)
+	index idx_products_category on products_with_indexes(category, price)
+}
+
+-- run
+
+-- Step 39: Diff should show table and indexes to create
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS users"}, {"ddl": "create table products_with_indexes (id INTEGER primary key, name TEXT not null, category TEXT, price REAL)"}, {"ddl": "create index idx_products_name on products_with_indexes (name)"}, {"ddl": "create index idx_products_category on products_with_indexes (category, price)"}]
+
+-- Step 40: Apply schema with indexes
+apply schema main;
+
+-- run
+
+-- Step 41: Verify table was created
+select count(*) from products_with_indexes;
+→ [{"count(*)": 0}]
+
+-- Step 42: Insert test data
+insert into products_with_indexes values (1, 'Laptop', 'Electronics', 999.99);
+insert into products_with_indexes values (2, 'Book', 'Books', 29.99);
+insert into products_with_indexes values (3, 'Shirt', 'Clothing', 19.99);
+
+-- Step 43: Verify data
+select * from products_with_indexes order by name;
+→ [{"id": 2, "name": "Book", "category": "Books", "price": 29.99}, {"id": 1, "name": "Laptop", "category": "Electronics", "price": 999.99}, {"id": 3, "name": "Shirt", "category": "Clothing", "price": 19.99}]
+
+-- Step 44: Diff again - should be empty since schema matches
+diff schema main;
+→ []
+
+-- Step 45: Test index removal
+declare schema main {
+	table products_with_indexes {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		category TEXT,
+		price REAL
+	}
+
+	index idx_products_name on products_with_indexes(name)
+}
+
+-- run
+
+-- Step 46: Diff should show one index to drop
+diff schema main;
+→ [{"ddl": "DROP INDEX IF EXISTS idx_products_category"}]
+
+-- Step 47: Apply to remove index
+apply schema main;
+
+-- run
+
+-- Step 48: Diff again - should be empty
+diff schema main;
+
+-- Test NOT EXISTS in CHECK constraint (regression test for operator spacing)
+-- This tests that "NOT EXISTS" is properly stringified with a space between NOT and EXISTS
+-- The bug was that "not exists" was being concatenated as "notexists" without a space
+
+declare schema check_not_exists {
+	table B (x int);
+	table A (
+		x int check (not exists(select 1 from B))
+	)
+}
+
+-- run
+
+-- The key test: DDL should have "not exists" with a space, not "notexists"
+diff schema check_not_exists;
+→ [{"ddl": "create table check_not_exists.B (x int)"}, {"ddl": "create table check_not_exists.A (x int check (not exists (select 1 from B)))"}]
+
+-- This should apply without parse errors (would fail with "notexists" syntax error)
+apply schema check_not_exists;
+
+-- run
+
+-- Step 49: Test schema-level default vtab module
+-- When using (default_vtab_module = 'memory') is specified, tables without explicit USING
+-- should inherit the schema-level default module
+declare schema test_default_module using (default_vtab_module = 'memory') {
+	table items {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL
+	}
+}
+
+-- run
+
+-- Diff should show the table with USING memory clause applied
+diff schema test_default_module;
+→ [{"ddl": "create table test_default_module.items (id INTEGER primary key, name TEXT not null) using memory"}]
+
+-- Apply the schema
+apply schema test_default_module;
+
+-- run
+
+-- Verify table works
+insert into test_default_module.items values (1, 'Test Item');
+select * from test_default_module.items;
+→ [{"id": 1, "name": "Test Item"}]
+
+-- Step 50: Test that explicit USING clause takes precedence over schema default
+declare schema test_explicit_module using (default_vtab_module = 'memory') {
+	table default_table {
+		id INTEGER PRIMARY KEY,
+		name TEXT
+	}
+
+	table explicit_table using memory {
+		id INTEGER PRIMARY KEY,
+		value TEXT
+	}
+}
+
+-- run
+
+-- Both tables should use memory module (one from default, one explicit)
+diff schema test_explicit_module;
+→ [{"ddl": "create table test_explicit_module.default_table (id INTEGER primary key, name TEXT) using memory"}, {"ddl": "create table test_explicit_module.explicit_table (id INTEGER primary key, value TEXT) using memory"}]
+
+apply schema test_explicit_module;
+
+-- run
+
+-- Verify both tables work
+insert into test_explicit_module.default_table values (1, 'Default');
+insert into test_explicit_module.explicit_table values (1, 'Explicit');
+select dt.name, et.value from test_explicit_module.default_table as dt cross join test_explicit_module.explicit_table as et;
+→ [{"name": "Default", "value": "Explicit"}]
+
+-- Step 51: Test WITH CONTEXT in declared table
+-- This tests that mutation context variables are properly parsed for tables inside declare schema blocks
+declare schema test_mutation_context using (default_vtab_module = 'memory') {
+	table secure_items (
+		id INTEGER PRIMARY KEY,
+		value TEXT,
+		CONSTRAINT auth_check CHECK (context.allowed = 1)
+	) with context (allowed INTEGER)
+}
+
+-- run
+
+-- Diff should include the WITH CONTEXT clause
+diff schema test_mutation_context;
+→ [{"ddl": "create table test_mutation_context.secure_items (id INTEGER primary key, value TEXT, constraint auth_check check (context.allowed = 1)) using memory with context (allowed INTEGER)"}]
+
+-- Apply the schema
+apply schema test_mutation_context;
+
+-- run
+
+-- Insert with allowed = 1 should succeed
+insert into test_mutation_context.secure_items (id, value)
+with context allowed = 1
+values (1, 'test value');
+
+select * from test_mutation_context.secure_items;
+→ [{"id": 1, "value": "test value"}]
+
+-- Insert with allowed = 0 should fail the CHECK constraint
+insert into test_mutation_context.secure_items (id, value)
+with context allowed = 0
+values (2, 'should fail');
+-- error: CHECK constraint failed
+
+-- Verify only the first row exists
+select count(*) from test_mutation_context.secure_items;
+→ [{"count(*)": 1}]
+
+-- Step 52: Test WITH CONTEXT with default values in declared table
+declare schema test_context_defaults using (default_vtab_module = 'memory') {
+	table orders (
+		id INTEGER PRIMARY KEY,
+		amount INTEGER DEFAULT base_amount + tax
+	) with context (base_amount INTEGER, tax INTEGER)
+}
+
+-- run
+
+apply schema test_context_defaults;
+
+-- run
+
+-- Insert using context for defaults
+insert into test_context_defaults.orders (id)
+with context base_amount = 100, tax = 15
+values (1);
+
+select * from test_context_defaults.orders;
+→ [{"id": 1, "amount": 115}]
+
+-- Step 53: Test boolean and blob seed data types
+-- Regression: boolean and Uint8Array values were silently NULLed in seed data interpolation
+declare schema test_seed_types using (default_vtab_module = 'memory') {
+	table typed_data {
+		id INTEGER PRIMARY KEY,
+		flag INTEGER,
+		data BLOB
+	}
+
+	seed typed_data (
+		(1, true, X'cafebabe'),
+		(2, false, X'deadbeef')
+	)
+}
+
+-- run
+
+apply schema test_seed_types with seed;
+
+-- run
+
+-- Verify boolean values were converted to 0/1 (not NULL)
+select id, flag from test_seed_types.typed_data order by id;
+→ [{"id": 1, "flag": 1}, {"id": 2, "flag": 0}]
+
+-- Verify blob values were preserved (not NULL)
+select id, typeof(data), length(data) from test_seed_types.typed_data order by id;
+→ [{"id": 1, "typeof(data)": "blob", "length(data)": 4}, {"id": 2, "typeof(data)": "blob", "length(data)": 4}]
+
+-- Step 54: Test assertions in declarative schema (using main since assertions live in main)
+-- First clean up: redeclare main as empty to clear leftover tables
+declare schema main {
+	table assert_accounts {
+		id INTEGER PRIMARY KEY,
+		balance INTEGER NOT NULL
+	}
+
+	assertion positive_balance check (not exists (select 1 from assert_accounts where balance < 0))
+
+	seed assert_accounts (
+		(1, 100),
+		(2, 200)
+	)
+}
+
+-- run
+
+-- Step 55: Diff should show drops for old main objects plus CREATE TABLE and CREATE ASSERTION
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS products_with_indexes"}, {"ddl": "DROP INDEX IF EXISTS idx_products_name"}, {"ddl": "create table assert_accounts (id INTEGER primary key, balance INTEGER not null)"}, {"ddl": "create assertion positive_balance check (not exists (select 1 from assert_accounts where balance < 0))"}]
+
+-- Step 56: Apply creates the table and assertion
+apply schema main with seed;
+
+-- run
+
+-- Step 57: Verify seed data
+select * from assert_accounts order by id;
+→ [{"id": 1, "balance": 100}, {"id": 2, "balance": 200}]
+
+-- Step 58: Diff should be empty now
+diff schema main;
+→ []
+
+-- Step 59: Assertion is enforced — commit with violation fails
+begin;
+insert into assert_accounts values (3, -50);
+commit;
+-- error: Integrity assertion failed: positive_balance
+
+-- Step 60: Verify state unchanged
+select count(*) from assert_accounts;
+→ [{"count(*)": 2}]
+
+-- Step 61: Valid insert works
+begin;
+insert into assert_accounts values (3, 50);
+commit;
+
+-- run
+
+select count(*) from assert_accounts;
+→ [{"count(*)": 3}]
+
+-- Step 62: Redeclare schema without the assertion — diff shows DROP ASSERTION
+declare schema main {
+	table assert_accounts {
+		id INTEGER PRIMARY KEY,
+		balance INTEGER NOT NULL
+	}
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP ASSERTION IF EXISTS positive_balance"}]
+
+-- Step 63: Apply removes the assertion
+apply schema main;
+
+-- run
+
+-- Step 64: Violation no longer fails (assertion removed)
+begin;
+insert into assert_accounts values (4, -99);
+commit;
+
+-- run
+
+select count(*) from assert_accounts;
+→ [{"count(*)": 4}]
+
+-- Step 65: Multiple assertions in one declaration
+declare schema main {
+	table assert_items {
+		id INTEGER PRIMARY KEY,
+		qty INTEGER NOT NULL,
+		price INTEGER NOT NULL
+	}
+
+	assertion qty_positive check (not exists (select 1 from assert_items where qty < 0))
+	assertion price_positive check (not exists (select 1 from assert_items where price < 0))
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP TABLE IF EXISTS assert_accounts"}, {"ddl": "create table assert_items (id INTEGER primary key, qty INTEGER not null, price INTEGER not null)"}, {"ddl": "create assertion qty_positive check (not exists (select 1 from assert_items where qty < 0))"}, {"ddl": "create assertion price_positive check (not exists (select 1 from assert_items where price < 0))"}]
+
+apply schema main;
+
+-- run
+
+-- Both assertions enforced
+begin;
+insert into assert_items values (1, -1, 10);
+commit;
+-- error: Integrity assertion failed: qty_positive
+
+begin;
+insert into assert_items values (1, 1, -10);
+commit;
+-- error: Integrity assertion failed: price_positive
+
+-- Valid insert
+begin;
+insert into assert_items values (1, 5, 10);
+commit;
+
+-- run
+
+select * from assert_items;
+→ [{"id": 1, "qty": 5, "price": 10}]
+
+-- ===================================================================
+-- Redeclaring an assertion's CHECK body must be visible to `diff` / `apply` —
+-- regression for bug-assertion-body-drift-invisible-to-diff. Uses its own
+-- schema so it does not disturb the assert_accounts / assert_items row
+-- counts asserted above.
+-- ===================================================================
+
+declare schema assert_drift {
+	table t (
+		x INTEGER PRIMARY KEY
+	)
+
+	assertion range_check check (not exists (select 1 from t where x < 0))
+}
+
+-- run
+
+apply schema assert_drift;
+
+-- run
+
+diff schema assert_drift;
+→ []
+
+-- Redeclare with a changed CHECK body (forbid x < 0 → forbid x < -100). The
+-- diff must show a drop+recreate pair for the drifted assertion, not [].
+declare schema assert_drift {
+	table t (
+		x INTEGER PRIMARY KEY
+	)
+
+	assertion range_check check (not exists (select 1 from t where x < -100))
+}
+
+-- run
+
+diff schema assert_drift;
+→ [{"ddl": "DROP ASSERTION IF EXISTS assert_drift.range_check"}, {"ddl": "create assertion assert_drift.range_check check (not exists (select 1 from t where x < -100))"}]
+
+apply schema assert_drift;
+
+-- run
+
+-- Idempotent: re-diff is empty.
+diff schema assert_drift;
+→ []
+
+-- A row illegal under the OLD rule (x < 0) but legal under the NEW rule
+-- (only x < -100 is forbidden) commits — the new rule is the one enforced.
+begin;
+insert into assert_drift.t values (-50);
+commit;
+
+-- run
+
+select * from assert_drift.t;
+→ [{"x": -50}]
+
+-- A row illegal under the NEW rule fails at commit.
+begin;
+insert into assert_drift.t values (-150);
+commit;
+-- error: Integrity assertion failed: assert_drift.range_check
+
+select count(*) as cnt from assert_drift.t;
+→ [{"cnt": 1}]
+
+-- ===================================================================
+-- Drift interacting with a same-apply ADD COLUMN: the recreated assertion names
+-- a column the same migration adds. `create assertion` plans its body at create
+-- time (same strictness as a view body), so the create MUST run after the
+-- table-alter block — assertion creates are emitted last, after every ADD COLUMN
+-- and maintained re-attach. Assertion DROPs still lead the whole migration.
+-- ===================================================================
+
+declare schema assert_addcol {
+	table t (
+		x INTEGER PRIMARY KEY
+	)
+
+	assertion range_check check (not exists (select 1 from t where x < 0))
+}
+
+-- run
+
+apply schema assert_addcol;
+
+-- run
+
+declare schema assert_addcol {
+	table t (
+		x INTEGER PRIMARY KEY,
+		y INTEGER
+	)
+
+	assertion range_check check (not exists (select 1 from t where y < 0))
+}
+
+-- run
+
+diff schema assert_addcol;
+→ [{"ddl": "DROP ASSERTION IF EXISTS assert_addcol.range_check"}, {"ddl": "ALTER TABLE assert_addcol.t ADD COLUMN y INTEGER"}, {"ddl": "create assertion assert_addcol.range_check check (not exists (select 1 from t where y < 0))"}]
+
+apply schema assert_addcol;
+
+-- run
+
+diff schema assert_addcol;
+→ []
+
+-- The recreated rule enforces against the freshly added column.
+begin;
+insert into assert_addcol.t values (1, -5);
+commit;
+-- error: Integrity assertion failed: assert_addcol.range_check
+
+begin;
+insert into assert_addcol.t values (2, 5);
+commit;
+
+-- run
+
+select * from assert_addcol.t;
+→ [{"x": 2, "y": 5}]
+
+-- ===================================================================
+-- Table rename in the same apply as an assertion whose body follows the new
+-- name. Assertion CHECK bodies are never rename-reconciled by the differ, so
+-- the unchanged-in-spirit assertion reads as drifted and churns a
+-- drop+recreate. That is correct-but-avoidable, and it must still APPLY
+-- cleanly: renames are emitted before assertion drops/creates.
+-- ===================================================================
+
+declare schema assert_rename {
+	table t (
+		x INTEGER PRIMARY KEY
+	)
+
+	assertion range_check check (not exists (select 1 from t where x < 0))
+}
+
+-- run
+
+apply schema assert_rename;
+
+-- run
+
+declare schema assert_rename {
+	table t2 (
+		x INTEGER PRIMARY KEY
+	) with tags ("quereus.previous_name" = 't')
+
+	assertion range_check check (not exists (select 1 from t2 where x < 0))
+}
+
+-- run
+
+diff schema assert_rename;
+→ [{"ddl": "ALTER TABLE assert_rename.t RENAME TO t2"}, {"ddl": "DROP ASSERTION IF EXISTS assert_rename.range_check"}, {"ddl": "create assertion assert_rename.range_check check (not exists (select 1 from t2 where x < 0))"}]
+
+apply schema assert_rename;
+
+-- run
+
+diff schema assert_rename;
+→ []
+
+-- The rebound assertion enforces against the renamed table.
+begin;
+insert into assert_rename.t2 values (-1);
+commit;
+-- error: Integrity assertion failed: assert_rename.range_check
+
+-- ===================================================================
+-- Declarative `unique index` — parser admits the UNIQUE qualifier and
+-- the diff stringifies it back as `create unique index` so that the
+-- apply path enforces uniqueness the same way a top-level
+-- `CREATE UNIQUE INDEX` does.
+-- ===================================================================
+
+declare schema decl_uniq {
+	table T (
+		id INTEGER PRIMARY KEY,
+		email TEXT NOT NULL,
+		a TEXT,
+		b TEXT
+	)
+
+	unique index ix_T_email on T(email)
+	unique index ix_T_a_b on T(a, b)
+}
+
+-- run
+
+-- Diff stringifies the declared indexes with the `unique` qualifier.
+diff schema decl_uniq;
+→ [{"ddl": "create table decl_uniq.T (id INTEGER primary key, email TEXT not null, a TEXT, b TEXT)"}, {"ddl": "create unique index decl_uniq.ix_T_email on decl_uniq.T (email)"}, {"ddl": "create unique index decl_uniq.ix_T_a_b on decl_uniq.T (a, b)"}]
+
+apply schema decl_uniq;
+
+-- run
+
+-- Apply was idempotent; re-diff is empty.
+diff schema decl_uniq;
+→ []
+
+-- Single-column unique enforcement.
+insert into decl_uniq.T values (1, 'x@y', 'p', 'q');
+insert into decl_uniq.T values (2, 'x@y', 'r', 's');
+-- error: UNIQUE
+
+-- Multi-column unique enforcement (compound key collides on (p,q)).
+insert into decl_uniq.T values (3, 'a@y', 'p', 'q');
+-- error: UNIQUE
+
+-- Distinct compound key is accepted.
+insert into decl_uniq.T values (4, 'b@y', 'p', 'r');
+
+select count(*) as cnt from decl_uniq.T;
+→ [{"cnt": 2}]
+
+-- Regression for github.com/gotchoices/quereus/issues/22 — prefix NOT against
+-- a subquery predicate inside CHECK, through the declare/apply round-trip.
+-- This exercises stringify → re-parse and must produce a semantically
+-- equivalent CHECK constraint (not one that rejects every row).
+declare schema decl_not_in
+{
+	table Block (Code text primary key);
+	table TIn (
+		Id int, Color text,
+		primary key (Id),
+		constraint NoBlocked check (Color not in (select Code from Block))
+	);
+}
+
+-- run
+
+apply schema decl_not_in;
+
+-- run
+
+insert into decl_not_in.Block (Code) values ('r');
+insert into decl_not_in.Block (Code) values ('y');
+insert into decl_not_in.TIn (Id, Color) values (1, 'g');
+select Color from decl_not_in.TIn;
+→ [{"Color":"g"}]
+
+insert into decl_not_in.TIn (Id, Color) values (2, 'r');
+-- error: CHECK constraint failed: NoBlocked
+
+drop table decl_not_in.TIn;
+drop table decl_not_in.Block;
+
+-- ===================================================================
+-- Regression for github.com/gotchoices/quereus/issues/23 — CHECK
+-- `on delete` operations clause survives the declare/apply round-trip.
+-- The stringifier used to drop the `operations` list, so the constraint
+-- defaulted to the all-ops mask (INSERT+UPDATE+DELETE) and fired on
+-- INSERT instead of only on DELETE.
+-- ===================================================================
+
+declare schema decl_check_ops
+{
+	table NoDelete (
+		Id int,
+		primary key (Id),
+		constraint NoDeleteEver check on delete (false)
+	);
+}
+
+-- run
+
+apply schema decl_check_ops;
+
+-- run
+
+-- INSERT must succeed (operations list excludes insert).
+insert into decl_check_ops.NoDelete (Id) values (1);
+select Id from decl_check_ops.NoDelete;
+→ [{"Id":1}]
+
+-- DELETE must fail.
+delete from decl_check_ops.NoDelete where Id = 1;
+-- error: CHECK constraint failed: NoDeleteEver
+
+drop table decl_check_ops.NoDelete;
+
+-- CHECK `on update` (the other half of the default-mask, distinct from
+-- the on-delete case so a mistakenly-defaulted mask still surfaces).
+declare schema decl_check_upd
+{
+	table OnUpdOnly (
+		Id int,
+		Val int,
+		primary key (Id),
+		constraint NoNegOnUpdate check on update (new.Val >= 0)
+	);
+}
+
+-- run
+
+apply schema decl_check_upd;
+
+-- run
+
+-- INSERT must succeed regardless of the bad value (constraint excludes insert).
+insert into decl_check_upd.OnUpdOnly (Id, Val) values (1, -5);
+select Val from decl_check_upd.OnUpdOnly;
+→ [{"Val":-5}]
+
+-- UPDATE must fail when the new value violates the constraint.
+update decl_check_upd.OnUpdOnly set Val = -1 where Id = 1;
+-- error: CHECK constraint failed: NoNegOnUpdate
+
+-- UPDATE that satisfies the constraint succeeds.
+update decl_check_upd.OnUpdOnly set Val = 7 where Id = 1;
+select Val from decl_check_upd.OnUpdOnly;
+→ [{"Val":7}]
+
+drop table decl_check_upd.OnUpdOnly;
+
+-- ===================================================================
+-- Regression for github.com/gotchoices/quereus/issues/21 — compound
+-- SELECT tail survives the declare/apply round-trip. The stringifier
+-- read `stmt.union` / `stmt.unionAll` (dead fields the parser never
+-- populates) instead of `stmt.compound`, silently dropping every leg
+-- beyond the first. Views are declared in `main` since declarative
+-- views in non-main schemas are emitted without a schema prefix (a
+-- separate concern outside this fix).
+-- ===================================================================
+
+declare schema main {
+	view rgb_codes as
+		select 'r' as Code, 'Red' as Name
+		union all select 'g' as Code, 'Green' as Name
+		union all select 'b' as Code, 'Blue' as Name
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+-- All three legs must be present; previously only 'r' survived.
+select Code from rgb_codes order by Code;
+→ [{"Code":"b"}, {"Code":"g"}, {"Code":"r"}]
+
+drop view rgb_codes;
+
+-- UNION (DISTINCT) — duplicate row collapses.
+declare schema main {
+	view distinct_union as
+		select 1 as N union select 2 as N union select 1 as N
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+select N from distinct_union order by N;
+→ [{"N": 1}, {"N": 2}]
+
+drop view distinct_union;
+
+-- INTERSECT — only common row survives. (Compound operators are
+-- right-associative in this parser, so the test uses single-leg sides
+-- to keep the test focused on the stringifier emitting `intersect`.)
+declare schema main {
+	view two_only as
+		select 2 as N intersect select 2 as N
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+select N from two_only;
+→ [{"N": 2}]
+
+drop view two_only;
+
+-- EXCEPT — left minus right.
+declare schema main {
+	view one_only as
+		select 1 as N except select 2 as N
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+select N from one_only;
+→ [{"N": 1}]
+
+drop view one_only;
+
+-- Cross-fix smoke: CHECK whose expression is a compound subquery. Both
+-- the operations list and the compound tail must survive the round-trip
+-- for the constraint to evaluate as written.
+declare schema decl_check_cmpd
+{
+	table Palette (
+		Color text primary key,
+		constraint InPalette check (Color in (
+			select 'r' as c union all
+			select 'g'      union all
+			select 'b'
+		))
+	);
+}
+
+-- run
+
+apply schema decl_check_cmpd;
+
+-- run
+
+insert into decl_check_cmpd.Palette values ('g');
+select Color from decl_check_cmpd.Palette;
+→ [{"Color":"g"}]
+
+insert into decl_check_cmpd.Palette values ('z');
+-- error: CHECK constraint failed: InPalette
+
+drop table decl_check_cmpd.Palette;
+
+-- ===================================================================
+-- Exposed implicit covering index — a UNIQUE constraint tagged
+-- quereus.expose_implicit_index surfaces its secondary BTree for
+-- introspection (schema() / index_info()), but the differ must NOT
+-- manage it as a standalone index. A converged schema diffs EMPTY (no
+-- phantom DROP INDEX IF EXISTS uq_expo_vin) across both the memory and
+-- store backends (ticket
+-- declarative-differ-spurious-drop-exposed-implicit-index).
+-- ===================================================================
+
+declare schema decl_expo_idx
+{
+	table ExpoTbl (
+		id INTEGER PRIMARY KEY,
+		vin TEXT,
+		constraint uq_expo_vin unique (vin) with tags ("quereus.expose_implicit_index" = true)
+	);
+}
+
+-- run
+
+apply schema decl_expo_idx;
+
+-- run
+
+-- Converged: re-diff is empty — no spurious DROP INDEX for the exposed
+-- implicit covering index (was the bug this ticket fixes).
+diff schema decl_expo_idx;
+→ []
+
+-- UNIQUE enforcement still holds (the constraint, not the index, governs it).
+insert into decl_expo_idx.ExpoTbl values (1, 'VIN001');
+insert into decl_expo_idx.ExpoTbl values (2, 'VIN001');
+-- error: UNIQUE
+
+drop table decl_expo_idx.ExpoTbl;
+
+-- ===================================================================
+-- View `with defaults (col = expr, …)` survives the declare/diff/apply
+-- round-trip: the diff renders the clause in the create DDL, the apply
+-- re-parses that DDL, and an insert through the applied view supplies the
+-- defaulted column. Declared in `main` since declarative views in
+-- non-main schemas are emitted without a schema prefix (see the
+-- compound-tail blocks above). `main` is empty at this point in the file
+-- (the last `apply schema main` reconciled it down to a single view,
+-- since dropped), so the diff is exactly the two creates.
+-- ===================================================================
+
+declare schema main {
+	table decl_dfl (
+		id INTEGER PRIMARY KEY,
+		name TEXT,
+		created INTEGER NOT NULL
+	)
+
+	view decl_dfl_v as select id, name from decl_dfl with defaults (created = 424242)
+}
+
+-- run
+
+-- The rendered create DDL carries the clause in canonical form.
+diff schema main;
+→ [{"ddl": "create table decl_dfl (id INTEGER primary key, name TEXT, created INTEGER not null)"}, {"ddl": "create view decl_dfl_v as select id, name from decl_dfl with defaults (created = 424242)"}]
+
+apply schema main;
+
+-- run
+
+-- Write-through: the applied view supplies the omitted not-null column.
+insert into decl_dfl_v values (1, 'x');
+select * from decl_dfl order by id;
+→ [{"id":1,"name":"x","created":424242}]
+
+-- Converged: an identical re-declare diffs empty (declared and actual agree,
+-- clause included).
+diff schema main;
+→ []
+
+drop view decl_dfl_v;
+drop table decl_dfl;
+
+-- ===================================================================
+-- View definition drift on a NAME-MATCHED view (ticket
+-- view-insert-defaults-declarative-drift-undetected): a changed /
+-- removed / added `with defaults` clause and a changed body each
+-- diff as DROP VIEW + CREATE VIEW. Previously all four diffed EMPTY —
+-- a stale default survived apply silently. Tag-only drift still takes
+-- the in-place SET TAGS path (declarative-equivalence unit tests).
+-- `main` is empty again at this point in the file.
+-- ===================================================================
+
+create table vd_t (id integer primary key, name text, created integer not null);
+create view vd_v as select id, name from vd_t with defaults (created = 111);
+
+-- run
+
+-- Baseline: write-through uses the original default.
+insert into vd_v values (1, 'a');
+select created from vd_t where id = 1;
+→ [{"created": 111}]
+
+-- Clause changed (111 → 222) on the name-matched view.
+declare schema main {
+	table vd_t (
+		id integer primary key,
+		name text,
+		created integer not null
+	)
+
+	view vd_v as select id, name from vd_t with defaults (created = 222)
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP VIEW IF EXISTS vd_v"}, {"ddl": "create view vd_v as select id, name from vd_t with defaults (created = 222)"}]
+
+apply schema main;
+
+-- run
+
+-- Write-through now uses the NEW default (it kept writing 111 before this fix).
+insert into vd_v values (2, 'b');
+select created from vd_t where id = 2;
+→ [{"created": 222}]
+
+-- Converged: re-diff is empty.
+diff schema main;
+→ []
+
+-- Clause removed: drift again → drop+recreate; an insert omitting the
+-- NOT NULL column now fails (nothing supplies it anymore).
+declare schema main {
+	table vd_t (
+		id integer primary key,
+		name text,
+		created integer not null
+	)
+
+	view vd_v as select id, name from vd_t
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP VIEW IF EXISTS vd_v"}, {"ddl": "create view vd_v as select id, name from vd_t"}]
+
+apply schema main;
+
+-- run
+
+insert into vd_v values (3, 'c');
+-- error: NOT NULL constraint failed: vd_t.created
+
+diff schema main;
+→ []
+
+-- Clause added (the inverse migration): drift → drop+recreate; the
+-- defaulted write-through works again with the new value.
+declare schema main {
+	table vd_t (
+		id integer primary key,
+		name text,
+		created integer not null
+	)
+
+	view vd_v as select id, name from vd_t with defaults (created = 333)
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP VIEW IF EXISTS vd_v"}, {"ddl": "create view vd_v as select id, name from vd_t with defaults (created = 333)"}]
+
+apply schema main;
+
+-- run
+
+insert into vd_v values (4, 'd');
+select created from vd_t where id = 4;
+→ [{"created": 333}]
+
+-- Body changed (added a predicate), same name and clause: drift → drop+recreate.
+declare schema main {
+	table vd_t (
+		id integer primary key,
+		name text,
+		created integer not null
+	)
+
+	view vd_v as select id, name from vd_t where id > 2 with defaults (created = 333)
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP VIEW IF EXISTS vd_v"}, {"ddl": "create view vd_v as select id, name from vd_t where id > 2 with defaults (created = 333)"}]
+
+apply schema main;
+
+-- run
+
+-- The new body filters: rows 1 (id=1) and 2 (id=2) are excluded; row 3 errored.
+select id from vd_v order by id;
+→ [{"id": 4}]
+
+diff schema main;
+→ []
+
+drop view vd_v;
+drop table vd_t;
+
+-- ---------------------------------------------------------------------------
+-- Maintained-table re-attach convergence (explicit rename-list reshape).
+-- A rename-list change on an EXPLICIT maintained table re-attaches in place via
+-- the carried `set maintained (cols) as` op — the backing column is renamed, rows
+-- are relabeled (not rebuilt), and a re-diff converges. Ticket
+-- maintained-reattach-explicit-rename-list-reshape.
+-- ---------------------------------------------------------------------------
+declare schema main {
+	table mvr_t (id INTEGER PRIMARY KEY, x INTEGER NOT NULL)
+	materialized view mvr_mv (a, b) as select id, x from mvr_t
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+insert into mvr_t values (1, 10), (2, 20);
+select a, b from mvr_mv order by a;
+→ [{"a": 1, "b": 10}, {"a": 2, "b": 20}]
+
+-- Rename-list change b → c: an in-place re-attach carrying the declared list.
+declare schema main {
+	table mvr_t (id INTEGER PRIMARY KEY, x INTEGER NOT NULL)
+	materialized view mvr_mv (a, c) as select id, x from mvr_t
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "alter table mvr_mv set maintained (a, c) as select id, x from mvr_t"}]
+
+apply schema main;
+
+-- run
+
+-- The backing column is relabeled b → c with values intact (a rename, not a rebuild).
+select a, c from mvr_mv order by a;
+→ [{"a": 1, "c": 10}, {"a": 2, "c": 20}]
+
+-- Maintenance is live on the relabeled backing.
+insert into mvr_t values (3, 30);
+select c from mvr_mv where a = 3;
+→ [{"c": 30}]
+
+-- Converged: re-diff wants nothing further.
+diff schema main;
+→ []
+
+drop table mvr_mv;
+drop table mvr_t;
+
+-- ===================================================================
+-- Seed application is idempotent (ticket
+-- declarative-seed-reopen-pk-collision). Re-applying `apply schema …
+-- with seed` over a table that already holds its seed rows must not
+-- collide on the seed PKs.
+-- The store package covers the reopen-without-rehydrate crash directly;
+-- this memory-backed case pins the in-engine SEMANTICS: the second apply
+-- uses INSERT … ON CONFLICT (<pk>) DO NOTHING — existing rows (including
+-- user-edited seed rows) are left untouched, and non-seed rows survive
+-- (no full-reset DELETE).
+-- ===================================================================
+
+declare schema decl_seed_idem using (default_vtab_module = 'memory') {
+	table meta {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL
+	}
+
+	seed meta (
+		(1, 'AllSite'),
+		(2, 'Other')
+	)
+}
+
+-- run
+
+-- First apply seeds the freshly-created table.
+apply schema decl_seed_idem with seed;
+
+-- run
+
+select id, name from decl_seed_idem.meta order by id;
+→ [{"id": 1, "name": "AllSite"}, {"id": 2, "name": "Other"}]
+
+-- A user adds a non-seed row and edits a seeded row.
+insert into decl_seed_idem.meta values (3, 'UserAdded');
+update decl_seed_idem.meta set name = 'Edited' where id = 2;
+select id, name from decl_seed_idem.meta order by id;
+→ [{"id": 1, "name": "AllSite"}, {"id": 2, "name": "Edited"}, {"id": 3, "name": "UserAdded"}]
+
+-- Re-apply the SAME schema with seed: no DDL diff, but the seed re-runs.
+-- ON CONFLICT (<pk>) DO NOTHING skips existing PKs, so user edits and
+-- non-seed rows survive unchanged.
+apply schema decl_seed_idem with seed;
+
+-- run
+
+select id, name from decl_seed_idem.meta order by id;
+→ [{"id": 1, "name": "AllSite"}, {"id": 2, "name": "Edited"}, {"id": 3, "name": "UserAdded"}]
+
+drop table decl_seed_idem.meta;
+
+-- ===================================================================
+-- Seed re-application must NOT fire ON DELETE CASCADE for an unchanged
+-- seed parent (ticket seed-reseed-or-replace-cascade-tradeoff). This is
+-- the headline reason the seed insert skips an existing PK (via ON
+-- CONFLICT (<pk>) DO NOTHING) rather than using OR REPLACE: OR REPLACE
+-- is delete-then-insert on a PK conflict, so a reseed of an
+-- already-seeded parent would delete the parent row, fire ON DELETE
+-- CASCADE, and destroy child rows — even when the replacement values are
+-- identical. DO NOTHING skips the existing parent entirely (no delete),
+-- so the cascade never fires and children survive.
+-- ===================================================================
+
+pragma foreign_keys = true;
+
+declare schema decl_seed_cascade using (default_vtab_module = 'memory') {
+	table parent {
+		id INTEGER PRIMARY KEY,
+		name TEXT
+	}
+
+	table child {
+		id INTEGER PRIMARY KEY,
+		parent_id INTEGER,
+		constraint fk_parent foreign key (parent_id) references parent(id) on delete cascade
+	}
+
+	seed parent (
+		(1, 'P1')
+	)
+}
+
+-- run
+
+apply schema decl_seed_cascade with seed;
+
+-- run
+
+-- A user adds a child referencing the seeded parent.
+insert into decl_seed_cascade.child values (10, 1);
+select id, parent_id from decl_seed_cascade.child order by id;
+→ [{"id": 10, "parent_id": 1}]
+
+-- Re-apply the seed: ON CONFLICT (<pk>) DO NOTHING skips the
+-- already-present parent (1) with no delete, so ON DELETE CASCADE never
+-- fires and the child survives.
+apply schema decl_seed_cascade with seed;
+
+-- run
+
+select id, parent_id from decl_seed_cascade.child order by id;
+→ [{"id": 10, "parent_id": 1}]
+
+-- The seed parent is still present and unchanged.
+select id, name from decl_seed_cascade.parent order by id;
+→ [{"id": 1, "name": "P1"}]
+
+drop table decl_seed_cascade.child;
+drop table decl_seed_cascade.parent;
+
+-- ===================================================================
+-- A malformed seed row aborts on first apply instead of vanishing
+-- (ticket seed-or-ignore-masks-malformed-rows). The seed insert uses
+-- `ON CONFLICT (<pk>) DO NOTHING`, which suppresses ONLY the seed-PK
+-- already-present conflict (the idempotency cases above). A row that
+-- violates a CHECK, a NOT NULL column, or a child-side FK is NOT a PK
+-- conflict, so it aborts with a clear error rather than being silently
+-- dropped the way `INSERT OR IGNORE` used to drop it.
+-- ===================================================================
+
+-- Positive control: valid seed rows on a CHECK-constrained table apply
+-- cleanly, and a re-apply stays idempotent (the PK-targeted conflict
+-- clause skips the already-present rows, it does not re-run the CHECK
+-- into an error).
+declare schema decl_seed_good_check using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		n INTEGER,
+		constraint positive check (n > 0)
+	}
+
+	seed t (
+		(1, 5),
+		(2, 10)
+	)
+}
+
+-- run
+
+apply schema decl_seed_good_check with seed;
+
+-- run
+
+select id, n from decl_seed_good_check.t order by id;
+→ [{"id": 1, "n": 5}, {"id": 2, "n": 10}]
+
+-- Idempotent reseed: existing seed PKs are skipped, no CHECK re-fires.
+apply schema decl_seed_good_check with seed;
+
+-- run
+
+select id, n from decl_seed_good_check.t order by id;
+→ [{"id": 1, "n": 5}, {"id": 2, "n": 10}]
+
+drop table decl_seed_good_check.t;
+
+-- CHECK violation: a seed row failing `check (n < 10)` aborts the apply
+-- (was silently dropped under OR IGNORE). (Seed literals must be bare —
+-- the parser rejects unary-minus — so the violation uses an over-large
+-- positive value rather than a negative one.)
+declare schema decl_seed_bad_check using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		n INTEGER,
+		constraint small check (n < 10)
+	}
+
+	seed t (
+		(1, 50)
+	)
+}
+
+-- run
+
+apply schema decl_seed_bad_check with seed;
+-- error: CHECK constraint failed
+
+-- NOT NULL violation: a seed row supplying NULL for a NOT NULL column
+-- aborts the apply.
+declare schema decl_seed_bad_nn using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		name TEXT NOT NULL
+	}
+
+	seed t (
+		(1, NULL)
+	)
+}
+
+-- run
+
+apply schema decl_seed_bad_nn with seed;
+-- error: NOT NULL constraint failed
+
+-- Child-side FK violation: a seed child row referencing a missing parent
+-- aborts the apply (the FK existence check is synthesized as a CHECK).
+pragma foreign_keys = true;
+
+declare schema decl_seed_bad_fk using (default_vtab_module = 'memory') {
+	table parent {
+		id INTEGER PRIMARY KEY
+	}
+
+	table child {
+		id INTEGER PRIMARY KEY,
+		parent_id INTEGER NOT NULL,
+		constraint fk_parent foreign key (parent_id) references parent(id)
+	}
+
+	seed child (
+		(1, 999)
+	)
+}
+
+-- run
+
+apply schema decl_seed_bad_fk with seed;
+-- error: CHECK constraint failed
+
+-- Composite PRIMARY KEY: the conflict clause names every PK column
+-- (`on conflict (a, b) do nothing`). A reseed over an already-present
+-- composite key is skipped (idempotent), a user edit to a non-PK column
+-- survives, and a non-seed row is preserved — the multi-column analogue
+-- of decl_seed_idem.
+declare schema decl_seed_composite using (default_vtab_module = 'memory') {
+	table pair {
+		a INTEGER,
+		b INTEGER,
+		label TEXT,
+		primary key (a, b)
+	}
+
+	seed pair (
+		(1, 1, 'one-one'),
+		(1, 2, 'one-two')
+	)
+}
+
+-- run
+
+apply schema decl_seed_composite with seed;
+
+-- run
+
+select a, b, label from decl_seed_composite.pair order by a, b;
+→ [{"a": 1, "b": 1, "label": "one-one"}, {"a": 1, "b": 2, "label": "one-two"}]
+
+-- A user edits a non-PK column on a seeded row and adds a non-seed row.
+update decl_seed_composite.pair set label = 'edited' where a = 1 and b = 2;
+insert into decl_seed_composite.pair values (2, 1, 'user-added');
+
+-- Reseed: the composite-key conflict is skipped (no overwrite of the
+-- edit), and the non-seed row survives.
+apply schema decl_seed_composite with seed;
+
+-- run
+
+select a, b, label from decl_seed_composite.pair order by a, b;
+→ [{"a": 1, "b": 1, "label": "one-one"}, {"a": 1, "b": 2, "label": "edited"}, {"a": 2, "b": 1, "label": "user-added"}]
+
+drop table decl_seed_composite.pair;
+
+-- Secondary UNIQUE collision: two seed rows share a UNIQUE value but have
+-- distinct PKs (a typo in the seed data). The seed insert targets the PK
+-- with `ON CONFLICT (<pk>) DO NOTHING`, so the second row's conflict is on
+-- the `email` UNIQUE constraint, NOT the targeted PK — it must abort the
+-- apply rather than vanish silently (ticket
+-- seed-secondary-unique-silently-skipped). Previously the PK-targeted
+-- clause short-circuited and swallowed any unique conflict.
+declare schema decl_seed_dup_unique using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		email TEXT,
+		constraint uq_email unique (email)
+	}
+
+	seed t (
+		(1, 'dup@x'),
+		(2, 'dup@x')
+	)
+}
+
+-- run
+
+apply schema decl_seed_dup_unique with seed;
+-- error: UNIQUE constraint failed
+
+-- Comparison-domain ALTER ordering. A column whose declared type AND collation both
+-- drift needs `SET DATA TYPE` and `SET COLLATE` in the order the engine accepts:
+-- `SET DATA TYPE` carries the column's CURRENT collation into the new type, and
+-- DATE / TIME / DATETIME / TIMESPAN / JSON accept BINARY only, so narrowing a
+-- `TEXT COLLATE NOCASE` column to `DATE` must emit `SET COLLATE BINARY` FIRST — the
+-- other order is rejected engine-side and aborts the whole migration
+-- (bug-retype-keeps-illegal-collation). Widening back keeps the opposite order: NOCASE
+-- can only land once the column is TEXT again.
+declare schema decl_collate_retype using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		d TEXT COLLATE NOCASE
+	}
+}
+
+-- run
+
+apply schema decl_collate_retype;
+insert into decl_collate_retype.t values (1, '2024-01-01'), (2, '2024-02-01');
+
+-- run
+
+-- Narrowing: TEXT COLLATE NOCASE → DATE.
+declare schema decl_collate_retype using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		d DATE
+	}
+}
+
+-- run
+
+diff schema decl_collate_retype;
+→ [{"ddl": "ALTER TABLE decl_collate_retype.t ALTER COLUMN d SET COLLATE BINARY"}, {"ddl": "ALTER TABLE decl_collate_retype.t ALTER COLUMN d SET DATA TYPE DATE"}]
+
+apply schema decl_collate_retype;
+
+-- run
+
+-- Converged (no residual drift) and the rows survived the retype.
+diff schema decl_collate_retype;
+→ []
+
+select id, d from decl_collate_retype.t order by d;
+→ [{"id": 1, "d": "2024-01-01"}, {"id": 2, "d": "2024-02-01"}]
+
+-- Widening back: DATE → TEXT COLLATE NOCASE, retype first this time.
+declare schema decl_collate_retype using (default_vtab_module = 'memory') {
+	table t {
+		id INTEGER PRIMARY KEY,
+		d TEXT COLLATE NOCASE
+	}
+}
+
+-- run
+
+diff schema decl_collate_retype;
+→ [{"ddl": "ALTER TABLE decl_collate_retype.t ALTER COLUMN d SET DATA TYPE TEXT"}, {"ddl": "ALTER TABLE decl_collate_retype.t ALTER COLUMN d SET COLLATE NOCASE"}]
+
+apply schema decl_collate_retype;
+
+-- run
+
+diff schema decl_collate_retype;
+→ []
+
+select id, d from decl_collate_retype.t order by id;
+→ [{"id": 1, "d": "2024-01-01"}, {"id": 2, "d": "2024-02-01"}]
+
+drop table decl_collate_retype.t;
+
+-- run
+
+-- ---------------------------------------------------------------------------
+-- Views and materialized views in a NON-main declared schema. The apply must
+-- land both in the declared schema, their bodies must resolve their unqualified
+-- source names against that schema (independent of the session's schema path),
+-- and a re-diff immediately after apply must be empty.
+-- Ticket `bug-declared-materialized-view-non-main-schema`.
+declare schema nm_view_pol using (default_vtab_module = 'memory') {
+	table nt {
+		id INTEGER PRIMARY KEY,
+		x INTEGER
+	}
+
+	view nv as select id, x from nt
+
+	materialized view nmv as select id, x from nt
+}
+
+-- run
+
+apply schema nm_view_pol;
+
+-- run
+
+-- Converged immediately: the stored (unqualified) bodies match the declared ones.
+diff schema nm_view_pol;
+→ []
+
+insert into nm_view_pol.nt values (1, 10), (2, 20);
+
+-- The view body resolves `nt` in its home schema even though the session path is
+-- the default (`main, temp`).
+select * from nm_view_pol.nv order by id;
+→ [{"id": 1, "x": 10}, {"id": 2, "x": 20}]
+
+-- The MV was filled at apply and row-time maintained through the insert above.
+select * from nm_view_pol.nmv order by id;
+→ [{"id": 1, "x": 10}, {"id": 2, "x": 20}]
+
+-- run
+
+-- Refresh re-plans the body — still against the MV's home schema.
+refresh materialized view nm_view_pol.nmv;
+
+select * from nm_view_pol.nmv order by id;
+→ [{"id": 1, "x": 10}, {"id": 2, "x": 20}]
+
+-- Still converged after use.
+diff schema nm_view_pol;
+→ []
+
+drop materialized view nm_view_pol.nmv;
+drop view nm_view_pol.nv;
+drop table nm_view_pol.nt;
+
+-- run
+
+-- ---------------------------------------------------------------------------
+-- Assertion in a NON-main declared schema. The apply must land the assertion in
+-- the declared schema (not main), its body must resolve the unqualified table
+-- name against that schema, a re-diff immediately after apply must be empty,
+-- and a write to an unrelated main-schema table must still commit.
+-- Ticket `bug-declared-assertion-ignores-target-schema`.
+declare schema nm_assert_pol using (default_vtab_module = 'memory') {
+	table at_t {
+		id INTEGER PRIMARY KEY,
+		x INTEGER NOT NULL
+	}
+
+	assertion a1 check (not exists (select 1 from at_t where x < 0))
+}
+
+-- run
+
+apply schema nm_assert_pol;
+
+-- run
+
+-- Converged immediately: the assertion landed in its declared schema.
+diff schema nm_assert_pol;
+→ []
+
+-- The assertion lives in the declared schema, not main.
+select schema_name, name from assertion_info() where name = 'a1';
+→ [{"schema_name": "nm_assert_pol", "name": "a1"}]
+
+-- A conforming row commits (the body's unqualified `at_t` resolves in the
+-- assertion's home schema even though the session path is `main, temp`).
+insert into nm_assert_pol.at_t values (1, 10);
+
+select id, x from nm_assert_pol.at_t order by id;
+→ [{"id": 1, "x": 10}]
+
+-- run
+
+-- A violating row fails at commit.
+begin;
+insert into nm_assert_pol.at_t values (2, -5);
+commit;
+-- error: Integrity assertion failed: nm_assert_pol.a1
+
+select count(*) as cnt from nm_assert_pol.at_t;
+→ [{"cnt": 1}]
+
+-- An unrelated main-schema write still commits: compiling the non-main
+-- assertion at commit time no longer fails against the session path.
+create table nm_unrelated (id integer primary key);
+insert into nm_unrelated values (1);
+
+select id from nm_unrelated;
+→ [{"id": 1}]
+
+-- run
+
+-- Redeclare the schema WITHOUT the assertion: the diff emits a schema-qualified
+-- drop, and applying it removes the assertion from its home schema.
+declare schema nm_assert_pol using (default_vtab_module = 'memory') {
+	table at_t {
+		id INTEGER PRIMARY KEY,
+		x INTEGER NOT NULL
+	}
+}
+
+-- run
+
+diff schema nm_assert_pol;
+→ [{"ddl": "DROP ASSERTION IF EXISTS nm_assert_pol.a1"}]
+
+apply schema nm_assert_pol;
+
+-- run
+
+select count(*) as cnt from assertion_info() where name = 'a1';
+→ [{"cnt": 0}]
+
+diff schema nm_assert_pol;
+→ []
+
+drop table nm_unrelated;
+drop table nm_assert_pol.at_t;
+
+-- ===================================================================
+-- Seed-apply against a quoted (non-bare) schema name (ticket
+-- bug-seed-schema-name-not-quoted). The generated seed INSERT used to
+-- splice schemaName/tableName into the target unquoted, so any schema
+-- name needing quoting broke the apply. Two distinct failure shapes:
+-- a colon in the name reaches the parser as a bare token and derails
+-- statement parsing, while a name whose leading run looks like a broken
+-- number (e.g. "4ee6...") is rejected by the LEXER as a truncated
+-- scientific-notation literal before the parser ever sees it. Both are
+-- fixed by quoting the whole name. A table name needing quoting takes
+-- the same path (third block).
+-- ===================================================================
+
+-- Symptom 1: colon in the schema name, no digit-e-nondigit run.
+declare schema "scope:alpha" using (default_vtab_module = 'memory') {
+	table meta {
+		id INTEGER PRIMARY KEY,
+		label TEXT NOT NULL
+	}
+
+	seed meta (
+		(1, 'first')
+	)
+}
+
+-- run
+
+apply schema "scope:alpha" with seed;
+
+-- run
+
+select id, label from "scope:alpha".meta order by id;
+→ [{"id": 1, "label": "first"}]
+
+-- Idempotent reseed stays a no-op on the existing PK.
+apply schema "scope:alpha" with seed;
+
+-- run
+
+select id, label from "scope:alpha".meta order by id;
+→ [{"id": 1, "label": "first"}]
+
+drop table "scope:alpha".meta;
+
+-- Symptom 2: no colon, but a leading digit-e-nondigit run the lexer
+-- misreads as a truncated scientific-notation number literal. The
+-- leading digit is what makes the name non-bare: an interior run
+-- (item4ee6) is a valid identifier and never needed quoting.
+declare schema "4ee6item" using (default_vtab_module = 'memory') {
+	table meta {
+		id INTEGER PRIMARY KEY,
+		label TEXT NOT NULL
+	}
+
+	seed meta (
+		(1, 'first')
+	)
+}
+
+-- run
+
+apply schema "4ee6item" with seed;
+
+-- run
+
+select id, label from "4ee6item".meta order by id;
+→ [{"id": 1, "label": "first"}]
+
+apply schema "4ee6item" with seed;
+
+-- run
+
+select id, label from "4ee6item".meta order by id;
+→ [{"id": 1, "label": "first"}]
+
+drop table "4ee6item".meta;
+
+-- Both symptoms in one name (the shape the original report hit: a UUID
+-- suffix after a colon), plus a table name that itself needs quoting —
+-- the seed INSERT target quotes both halves.
+declare schema "recording:1fec5b46-014d-4e77-9dc1-b44df5513e88" using (default_vtab_module = 'memory') {
+	table "row data" {
+		id INTEGER PRIMARY KEY,
+		label TEXT NOT NULL
+	}
+
+	seed "row data" (
+		(1, 'first')
+	)
+}
+
+-- run
+
+apply schema "recording:1fec5b46-014d-4e77-9dc1-b44df5513e88" with seed;
+
+-- run
+
+select id, label from "recording:1fec5b46-014d-4e77-9dc1-b44df5513e88"."row data" order by id;
+→ [{"id": 1, "label": "first"}]
+
+drop table "recording:1fec5b46-014d-4e77-9dc1-b44df5513e88"."row data";
+
+-- ===================================
+-- apply schema options: unhonored keys are rejected, not dropped
+-- ===================================
+
+create table opt_probe (id integer primary key);
+
+declare schema main {
+	table opt_probe {
+		id integer primary key
+	}
+}
+
+-- run
+
+-- `dry_run` / `validate_only` promise a preview the engine never had.
+apply schema main options (dry_run = true);
+-- error: Unsupported apply schema option 'dry_run'
+
+apply schema main options (validate_only = false);
+-- error: Unsupported apply schema option 'validate_only'
+
+-- An unrecognized key is an error too, rather than a silent no-op.
+apply schema main options (allow_destructiv = true);
+-- error: Unsupported apply schema option 'allow_destructiv'
+
+-- So is a value that is not a boolean literal.
+apply schema main options (allow_destructive = 'yes');
+-- error: Expected 'true' or 'false'
+
+-- The supported options still apply cleanly.
+apply schema main options (allow_destructive = true, rename_policy = 'deny');
+
+-- run
+
+drop table opt_probe;
+
+-- ===================================================================
+-- Unnamed CHECK / UNIQUE / FOREIGN KEY constraints are diffed by body
+-- (ticket declarative-differ-ignores-unnamed-constraint-additions). The
+-- differ used to key constraints only by name, so adding or removing an
+-- unnamed one produced an empty diff and an upgraded database never
+-- gained (or lost) the rule a fresh create at the new version has. An
+-- added one lands under a reserved `_`-prefixed name (so it stays
+-- body-matched and is droppable); a CREATE-time one stored with no name
+-- cannot be dropped by any statement, so its removal is refused.
+-- ===================================================================
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null }
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+insert into uc_p values (5);
+insert into uc_t values (1, 5, 5);
+
+-- Table-level unnamed CHECK: ADD under `_check_<n>`, enforced, converged.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null, check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t ADD constraint _check_0 check (a > 0)"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (2, -1, null);
+-- error: CHECK constraint failed
+
+diff schema main;
+→ []
+
+-- The same rule spelled column-level has the same body — not a change.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null check (a > 0), b integer null }
+}
+
+-- run
+
+diff schema main;
+→ []
+
+-- Table- and column-level unnamed UNIQUE, and an unnamed FOREIGN KEY.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t {
+		id integer primary key,
+		a integer null check (a > 0),
+		b integer null unique,
+		unique (a),
+		foreign key (b) references uc_p(id)
+	}
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t ADD constraint _uc_a unique (a)"}, {"ddl": "ALTER TABLE uc_t ADD constraint _fk_uc_t_b foreign key (b) references uc_p(id)"}, {"ddl": "ALTER TABLE uc_t ADD constraint _uc_b unique (b)"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (3, 5, null);
+-- error: UNIQUE constraint failed
+
+insert into uc_t values (4, 6, 5);
+-- error: UNIQUE constraint failed
+
+insert into uc_t values (5, 7, 99);
+-- error: _fk_uc_t_b
+
+diff schema main;
+→ []
+
+-- Removal: every upgrade-added constraint carries its reserved name, so all drop.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t DROP CONSTRAINT _check_0"}, {"ddl": "ALTER TABLE uc_t DROP CONSTRAINT _uc_a"}, {"ddl": "ALTER TABLE uc_t DROP CONSTRAINT _uc_b"}, {"ddl": "ALTER TABLE uc_t DROP CONSTRAINT _fk_uc_t_b"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (6, -1, 99);
+insert into uc_t values (7, 5, 99);
+
+diff schema main;
+→ []
+
+-- A named constraint on a column the diff adds rides the ADD COLUMN inline
+-- only (it used to be ADDed a second time, failing the apply).
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null, c integer null constraint cpos check (c > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t ADD COLUMN c integer null constraint cpos check (c > 0)"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (8, null, null, -1);
+-- error: CHECK constraint failed: cpos
+
+diff schema main;
+→ []
+
+-- Same for an unnamed one; the engine names it `_check_d`, as CREATE TABLE does.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null, c integer null constraint cpos check (c > 0), d integer null check (d > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t ADD COLUMN d integer null check (d > 0)"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (9, null, null, null, -1);
+-- error: CHECK constraint failed: _check_d
+
+diff schema main;
+→ []
+
+-- An unnamed column-level CHECK's body change: drop + re-add under the same name.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_t { id integer primary key, a integer null, b integer null, c integer null constraint cpos check (c > 0), d integer null check (d > 1) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_t DROP CONSTRAINT _check_d"}, {"ddl": "ALTER TABLE uc_t ADD constraint _check_d check (d > 1)"}]
+
+apply schema main;
+
+-- run
+
+insert into uc_t values (10, null, null, null, 1);
+-- error: CHECK constraint failed: _check_d
+
+diff schema main;
+→ []
+
+drop table uc_t;
+drop table uc_p;
+
+-- Created fresh: a column-level unnamed CHECK / FK is stored under its
+-- auto-name and drops; a table-level CHECK and any UNIQUE are stored with
+-- no name, so dropping one from the declaration is refused, not ignored.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_f {
+		id integer primary key,
+		a integer null check (a < 100),
+		b integer null references uc_p(id),
+		check (a > 0),
+		unique (a)
+	}
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_f { id integer primary key, a integer null, b integer null, check (a > 0), unique (a) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_f DROP CONSTRAINT _check_a"}, {"ddl": "ALTER TABLE uc_f DROP CONSTRAINT _fk_uc_f_b"}]
+
+apply schema main;
+
+-- run
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_f { id integer primary key, a integer null, b integer null, unique (a) }
+}
+
+-- run
+
+diff schema main;
+-- error: Cannot drop unnamed constraint 'check (a > 0)' from table 'main.uc_f'
+
+apply schema main;
+-- error: created without a name, so no statement can drop it
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_f { id integer primary key, a integer null, b integer null, check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+-- error: Cannot drop unnamed constraint 'unique (a)' from table 'main.uc_f'
+
+-- Still declaring both: converged.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_f { id integer primary key, a integer null, b integer null, check (a > 0), unique (a) }
+}
+
+-- run
+
+diff schema main;
+→ []
+
+drop table uc_f;
+
+-- A dropped column takes its unnamed UNIQUE with it (DROP COLUMN prunes a
+-- UNIQUE over the column), so that removal is not refused.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_g { id integer primary key, a integer null, b integer null, unique (a) }
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_g { id integer primary key, b integer null }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_g DROP COLUMN a"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+drop table uc_g;
+
+-- Identical unnamed CHECKs are a multiset: a third one is exactly one ADD.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_d { id integer primary key, a integer null, check (a > 0), check (a > 0) }
+}
+
+-- run
+
+apply schema main;
+
+-- run
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_d { id integer primary key, a integer null, check (a > 0), check (a > 0), check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_d ADD constraint _check_2 check (a > 0)"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+-- Taking one away drops the named one, keeping the two no DROP can reach.
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_d { id integer primary key, a integer null, check (a > 0), check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_d DROP CONSTRAINT _check_2"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+drop table uc_d;
+
+-- A column rename the unnamed constraints reference is a rename only: the
+-- bodies are matched with the rename inverse-applied, so nothing churns.
+create table uc_r (id integer primary key, amount integer null, pid integer null, check (amount > 0), unique (amount), foreign key (pid) references uc_p(id));
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_r {
+		id integer primary key,
+		qty integer null with tags ("quereus.previous_name" = 'amount'),
+		parent_id integer null with tags ("quereus.previous_name" = 'pid'),
+		check (qty > 0),
+		unique (qty),
+		foreign key (parent_id) references uc_p(id)
+	}
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_r RENAME COLUMN amount TO qty"}, {"ddl": "ALTER TABLE uc_r RENAME COLUMN pid TO parent_id"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+insert into uc_r values (1, -1, null);
+-- error: CHECK constraint failed
+
+drop table uc_r;
+
+-- Renaming the parent table an unnamed FK references is the table rename
+-- only: the FK body is matched with the parent rename inverse-applied.
+create table uc_k (id integer primary key, pid integer null references uc_p(id));
+
+declare schema main {
+	table uc_p2 { id integer primary key } with tags ("quereus.previous_name" = 'uc_p')
+	table uc_k { id integer primary key, pid integer null references uc_p2(id) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_p RENAME TO uc_p2"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+drop table uc_k;
+alter table uc_p2 rename to uc_p;
+
+-- A declared reserved `_` name is unnamed-class: ADDed under that name, then
+-- matched by body (so dropping the name from the declaration is no change),
+-- and a body edit drops it and ADDs the new body under a fresh `_check_<n>`.
+create table uc_x (id integer primary key, a integer null);
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_x { id integer primary key, a integer null, constraint _pos check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_x ADD constraint _pos check (a > 0)"}]
+
+apply schema main;
+
+-- run
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_x { id integer primary key, a integer null, check (a > 0) }
+}
+
+-- run
+
+diff schema main;
+→ []
+
+declare schema main {
+	table uc_p { id integer primary key }
+	table uc_x { id integer primary key, a integer null, check (a > 1) }
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE uc_x DROP CONSTRAINT _pos"}, {"ddl": "ALTER TABLE uc_x ADD constraint _check_1 check (a > 1)"}]
+
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+insert into uc_x values (1, 1);
+-- error: CHECK constraint failed: _check_1
+
+drop table uc_x;
+drop table uc_p;