@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/50.2.1-declare-schema-index-renames.sqllogic

@@ -0,0 +1,173 @@
+-- 50.2.1-declare-schema-index-renames.sqllogic
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 50.2-declare-schema-renames: the declarative-schema rename/diff engine
+-- treats tables, views and indexes as three parallel object kinds, and 50.2 exercises the
+-- whole engine (hint resolution, drop+create ordering, in-diff column and table renames,
+-- rename policies, ambiguity guards) on the table and view kinds with no index DDL.
+-- These four sections are the INDEX-kind instances, so they live here.
+--
+-- Section numbers keep their original 50.2 labels so cross-references still resolve.
+--
+-- Subject: a hinted index rename becomes DROP INDEX + recreate, orders correctly against
+-- an in-diff column or table rename of its source, and does not trip the require-hint
+-- guard.
+
+-- ===================================
+-- 17. Hinted INDEX rename, body unchanged → drop + recreate
+-- ===================================
+
+create table ir_t (id integer primary key, category text);
+create index ix_old on ir_t (category);
+
+declare schema main {
+	table ir_t {
+		id integer primary key,
+		category text
+	}
+
+	index ix_new on ir_t (category) with tags ("quereus.previous_name" = 'ix_old')
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "DROP INDEX IF EXISTS ix_old"}, {"ddl": "create index ix_new on ir_t (category) with tags (\"quereus.previous_name\" = 'ix_old')"}]
+
+apply schema main;
+
+-- run
+
+select name, tbl_name from schema() where type = 'index';
+→ [{"name": "ix_new", "tbl_name": "ir_t"}]
+
+diff schema main;
+→ []
+
+drop index ix_new;
+drop table ir_t;
+
+-- ===================================
+-- 20. Hinted INDEX rename + in-diff COLUMN rename of its table
+-- ===================================
+
+create table irc_t (id integer primary key, amount integer not null);
+create index irc_old on irc_t (amount);
+
+declare schema main {
+	table irc_t {
+		id integer primary key,
+		qty integer not null with tags ("quereus.previous_name" = 'amount')
+	}
+
+	index irc_new on irc_t (qty) with tags ("quereus.previous_name" = 'irc_old')
+}
+
+-- run
+
+-- The recreate names the OLD column (RENAME COLUMN runs after creates); the
+-- propagation rewrites the fresh index's columns.
+diff schema main;
+→ [{"ddl": "DROP INDEX IF EXISTS irc_old"}, {"ddl": "create index irc_new on irc_t (amount) with tags (\"quereus.previous_name\" = 'irc_old')"}, {"ddl": "ALTER TABLE irc_t RENAME COLUMN amount TO qty"}]
+
+apply schema main;
+
+-- run
+
+select name from schema() where type = 'index';
+→ [{"name": "irc_new"}]
+
+diff schema main;
+→ []
+
+drop index irc_new;
+drop table irc_t;
+
+-- ===================================
+-- 21. require-hint: hinted view + index renames apply cleanly
+-- ===================================
+
+-- A hinted rename's drop+create pair is deliberate, not an ambiguous unhinted
+-- rename — it must not trip the require-hint guard (excluded from the counts,
+-- like the body-change recreates of §14).
+
+create table rh2_t (id integer primary key, v integer);
+create view rh2_vold as select id, v from rh2_t;
+create index rh2_ixold on rh2_t (v);
+
+declare schema main {
+	table rh2_t {
+		id integer primary key,
+		v integer
+	}
+
+	view rh2_vnew as select id, v from rh2_t with tags ("quereus.previous_name" = 'rh2_vold')
+
+	index rh2_ixnew on rh2_t (v) with tags ("quereus.previous_name" = 'rh2_ixold')
+}
+
+-- run
+
+apply schema main options (rename_policy = 'require-hint');
+
+-- run
+
+diff schema main;
+→ []
+
+select name from schema() where type = 'view';
+→ [{"name": "rh2_vnew"}]
+
+select name from schema() where type = 'index';
+→ [{"name": "rh2_ixnew"}]
+
+drop view rh2_vnew;
+drop index rh2_ixnew;
+drop table rh2_t;
+
+-- ===================================
+-- 22. Hinted VIEW + INDEX rename + in-diff TABLE rename of their source
+-- ===================================
+
+-- The recreates keep the DECLARED table name (no inverse table pass): table
+-- renames emit FIRST in migration order, so the new name is live by the time
+-- the view/index creates plan their bodies.
+
+create table src_old (id integer primary key, v integer);
+create view trv_old as select id, v from src_old;
+create index tri_old on src_old (v);
+insert into src_old values (1, 10);
+
+declare schema main {
+	table src_new {
+		id integer primary key,
+		v integer
+	} with tags ("quereus.previous_name" = 'src_old')
+
+	view trv_new as select id, v from src_new with tags ("quereus.previous_name" = 'trv_old')
+
+	index tri_new on src_new (v) with tags ("quereus.previous_name" = 'tri_old')
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE src_old RENAME TO src_new"}, {"ddl": "DROP VIEW IF EXISTS trv_old"}, {"ddl": "DROP INDEX IF EXISTS tri_old"}, {"ddl": "create view trv_new as select id, v from src_new with tags (\"quereus.previous_name\" = 'trv_old')"}, {"ddl": "create index tri_new on src_new (v) with tags (\"quereus.previous_name\" = 'tri_old')"}]
+
+apply schema main;
+
+-- run
+
+select * from trv_new order by id;
+→ [{"id": 1, "v": 10}]
+
+select name, tbl_name from schema() where type = 'index';
+→ [{"name": "tri_new", "tbl_name": "src_new"}]
+
+diff schema main;
+→ []
+
+drop view trv_new;
+drop index tri_new;
+drop table src_new;

package/test/logic/50.3-declare-schema-duplicate-names.sqllogic

@@ -0,0 +1,280 @@
+-- 50.3-declare-schema-duplicate-names.sqllogic
+--
+-- A declared schema names each object once (docs/invariants.md SCH-003).
+-- Every `declared*` map in the differ's collection loop is keyed schema-wide by
+-- lowercased name, so a repeated declaration used to silently last-writer-wins:
+-- the first declaration never reached the migration and no diagnostic fired.
+
+-- ===================================
+-- 1. Same-kind duplicates
+-- ===================================
+
+declare schema dup_table using (default_vtab_module = 'memory') {
+	table t1 {
+		id integer primary key,
+		a text
+	}
+
+	table t1 {
+		id integer primary key,
+		b text
+	}
+}
+
+-- run
+
+diff schema dup_table;
+-- error: Table 't1' is declared more than once in schema 'dup_table'
+
+-- `apply schema` surfaces the same rejection, before any DDL runs.
+apply schema dup_table;
+-- error: Table 't1' is declared more than once in schema 'dup_table'
+
+-- Names compare case-insensitively.
+declare schema dup_table_case using (default_vtab_module = 'memory') {
+	table T1 {
+		id integer primary key,
+		a text
+	}
+
+	table t1 {
+		id integer primary key,
+		b text
+	}
+}
+
+-- run
+
+diff schema dup_table_case;
+-- error: Table 't1' is declared more than once in schema 'dup_table_case'
+
+declare schema dup_view using (default_vtab_module = 'memory') {
+	table t1 {
+		id integer primary key,
+		a text
+	}
+
+	view v as select id as x from t1
+
+	view v as select a as y from t1
+}
+
+-- run
+
+diff schema dup_view;
+-- error: View 'v' is declared more than once in schema 'dup_view'
+
+-- Both materialized-view bodies are FROM-less on purpose: a `materialized view`
+-- item written directly after an item whose body ends at a FROM source is
+-- misparsed (`materialized` is taken as a table alias) — see ticket
+-- bug-declare-schema-materialized-swallowed-as-table-alias.
+declare schema dup_mv using (default_vtab_module = 'memory') {
+	materialized view mv as select 1 as one
+
+	materialized view mv as select 2 as two
+}
+
+-- run
+
+diff schema dup_mv;
+-- error: Materialized view 'mv' is declared more than once in schema 'dup_mv'
+
+-- Assertions live in main.
+declare schema main {
+	table dup_assert_t {
+		id integer primary key,
+		n integer
+	}
+
+	assertion ck check (not exists (select 1 from dup_assert_t where n < 0))
+
+	assertion ck check (not exists (select 1 from dup_assert_t where n < 1))
+}
+
+-- run
+
+diff schema main;
+-- error: Assertion 'ck' is declared more than once in schema 'main'
+
+-- ===================================
+-- 2. Cross-kind duplicates (table / view / materialized view share one namespace)
+-- ===================================
+
+-- `Schema.addView` rejects a view whose name a table already holds, so this
+-- declaration could never apply — it used to emit both CREATEs, run the table
+-- create, then fail deep in the migration loop leaving the table behind.
+declare schema dup_cross using (default_vtab_module = 'memory') {
+	table dual {
+		id integer primary key
+	}
+
+	view dual as select 1 as one
+}
+
+-- run
+
+diff schema dup_cross;
+-- error: 'dual' is declared as both a table and a view in schema 'dup_cross'
+
+-- Kinds are named in declaration order.
+declare schema dup_cross_rev using (default_vtab_module = 'memory') {
+	view dual as select 1 as one
+
+	table dual {
+		id integer primary key
+	}
+}
+
+-- run
+
+diff schema dup_cross_rev;
+-- error: 'dual' is declared as both a view and a table in schema 'dup_cross_rev'
+
+declare schema dup_cross_mv using (default_vtab_module = 'memory') {
+	table mv {
+		id integer primary key
+	}
+
+	materialized view mv as select 1 as one
+}
+
+-- run
+
+diff schema dup_cross_mv;
+-- error: 'mv' is declared as both a table and a materialized view in schema 'dup_cross_mv'
+
+-- ===================================
+-- 3. Duplicate seed blocks (rejected at declare time, not diff time)
+-- ===================================
+
+-- Seed rows are stored one block per table, so a second block for the same table
+-- used to discard the first block's rows. The differ never sees seed items, so
+-- the guard runs when the declaration is stored — nothing is stored at all.
+declare schema dup_seed using (default_vtab_module = 'memory') {
+	table t {
+		id integer primary key,
+		n integer
+	}
+
+	seed t (
+		(1, 10)
+	)
+
+	seed t (
+		(2, 20)
+	)
+}
+-- error: Seed data for table 't' is declared more than once in schema 'dup_seed'
+
+-- The rejected declaration was not stored.
+diff schema dup_seed;
+-- error: No declared schema found for 'dup_seed'
+
+-- Target table names compare case-insensitively here too.
+declare schema dup_seed_case using (default_vtab_module = 'memory') {
+	table t {
+		id integer primary key,
+		n integer
+	}
+
+	seed T (
+		(1, 10)
+	)
+
+	seed t (
+		(2, 20)
+	)
+}
+-- error: Seed data for table 't' is declared more than once in schema 'dup_seed_case'
+
+-- A rejected declaration leaves an EARLIER good one for the same schema intact:
+-- the guard runs before `clearSeedData` and `setDeclaredSchema`, so neither the
+-- stored declaration nor the stored seed rows are touched.
+declare schema seed_keep using (default_vtab_module = 'memory') {
+	table t {
+		id integer primary key,
+		n integer
+	}
+
+	seed t (
+		(1, 10)
+	)
+}
+
+-- run
+
+apply schema seed_keep with seed;
+
+-- run
+
+declare schema seed_keep using (default_vtab_module = 'memory') {
+	table t {
+		id integer primary key,
+		n integer
+	}
+
+	seed t (
+		(2, 20)
+	)
+
+	seed t (
+		(3, 30)
+	)
+}
+-- error: Seed data for table 't' is declared more than once in schema 'seed_keep'
+
+-- The prior declaration survives (the diff still converges) ...
+diff schema seed_keep;
+→ []
+
+-- ... and so do its stored seed rows: wipe the table and re-seed from the store.
+delete from seed_keep.t;
+
+-- run
+
+apply schema seed_keep with seed;
+
+-- run
+
+select n from seed_keep.t;
+→ [{"n":10}]
+
+-- ===================================
+-- 4. Positive control — distinct names apply cleanly
+-- ===================================
+
+declare schema dup_ok using (default_vtab_module = 'memory') {
+	table t1 {
+		id integer primary key,
+		a text
+	}
+
+	table t2 {
+		id integer primary key,
+		b text
+	}
+
+	seed t1 (
+		(1, 'alpha')
+	)
+
+	seed t2 (
+		(2, 'beta')
+	)
+}
+
+-- run
+
+apply schema dup_ok with seed;
+
+-- run
+
+select a from dup_ok.t1 where id = 1;
+→ [{"a":"alpha"}]
+
+select b from dup_ok.t2 where id = 2;
+→ [{"b":"beta"}]
+
+-- Re-applying stays clean: the declaration is unambiguous, so the diff converges.
+diff schema dup_ok;
+→ []

package/test/logic/50.4-declare-schema-apply-restore.sqllogic

@@ -0,0 +1,192 @@
+-- Declarative schema: a migration that fails partway is unwound, so the catalog is back where
+-- the apply found it. Tightening a named constraint whose new body the existing rows violate
+-- is the motivating case: the plan is DROP CONSTRAINT + ADD CONSTRAINT, the re-add fails its
+-- existing-row validation, and the undo journal re-adds the OLD constraint — which must not
+-- only be back in the catalog but still be enforced. Runs on both backends
+-- (see docs/schema.md § Failure and restoration; the executor is runBatchedMigrationLoop).
+
+-- ===================================
+-- 1. CHECK tightened against a violating row
+-- ===================================
+
+create table t_ck (id integer primary key, v integer, constraint ck_v check (v > 0));
+insert into t_ck values (1, 5);
+
+declare schema main {
+	table t_ck {
+		id integer primary key,
+		v integer,
+		constraint ck_v check (v > 10)
+	}
+}
+
+-- run
+
+diff schema main;
+→ [{"ddl": "ALTER TABLE t_ck DROP CONSTRAINT ck_v"}, {"ddl": "ALTER TABLE t_ck ADD constraint ck_v check (v > 10)"}]
+
+-- The re-add fails over the row v = 5; the DROP that preceded it is undone.
+apply schema main;
+-- error: ck_v
+
+-- The row is untouched, the old rule is back, and it is still enforced.
+select v from t_ck;
+→ [{"v": 5}]
+
+insert into t_ck values (2, -1);
+-- error: CHECK constraint failed
+
+insert into t_ck values (2, 7);
+
+-- run
+
+-- Re-diffing produces the original plan again: nothing about the failure was cached.
+diff schema main;
+→ [{"ddl": "ALTER TABLE t_ck DROP CONSTRAINT ck_v"}, {"ddl": "ALTER TABLE t_ck ADD constraint ck_v check (v > 10)"}]
+
+drop table t_ck;
+
+-- ===================================
+-- 2. UNIQUE tightened against duplicate rows
+-- ===================================
+
+create table t_uq (id integer primary key, a integer, b integer, constraint uq_ab unique (a, b));
+insert into t_uq values (1, 1, 1), (2, 1, 2);
+
+declare schema main {
+	table t_uq {
+		id integer primary key,
+		a integer,
+		b integer,
+		constraint uq_ab unique (a)
+	}
+}
+
+-- run
+
+apply schema main;
+-- error: uq_ab
+
+-- The old two-column rule is back: a duplicate (a, b) is refused, a duplicate a alone is not.
+insert into t_uq values (3, 1, 1);
+-- error: UNIQUE constraint failed
+
+insert into t_uq values (3, 1, 3);
+
+-- run
+
+select count(*) as n from t_uq;
+→ [{"n": 3}]
+
+drop table t_uq;
+
+-- ===================================
+-- 3. FOREIGN KEY re-targeted at a column the child rows do not match
+-- ===================================
+
+create table p (id integer primary key, alt integer, constraint uq_alt unique (alt));
+insert into p values (1, 100);
+create table c (id integer primary key, pid integer, constraint fk_p foreign key (pid) references p(id));
+insert into c values (1, 1);
+
+declare schema main {
+	table p {
+		id integer primary key,
+		alt integer,
+		constraint uq_alt unique (alt)
+	}
+	table c {
+		id integer primary key,
+		pid integer,
+		constraint fk_p foreign key (pid) references p(alt)
+	}
+}
+
+-- run
+
+-- pid = 1 is a p.id, not a p.alt, so the re-add fails and the old reference is restored.
+apply schema main;
+-- error: fk_p
+
+insert into c values (2, 999);
+-- error: constraint failed: fk_p
+
+insert into c values (2, 1);
+
+-- run
+
+select count(*) as n from c;
+→ [{"n": 2}]
+
+drop table c;
+drop table p;
+
+-- ===================================
+-- 4. A multi-step plan: the steps that landed before the failure are taken back
+-- ===================================
+
+create table t (id integer primary key, v text null);
+insert into t values (1, 'a');
+
+declare schema main {
+	table t {
+		id integer primary key,
+		v text null,
+		w integer not null
+	}
+	table n1 {
+		id integer primary key
+	}
+}
+
+-- run
+
+-- create table n1 lands, then ALTER TABLE t ADD COLUMN w fails over the existing row.
+diff schema main;
+→ [{"ddl": "create table n1 (id integer primary key)"}, {"ddl": "ALTER TABLE t ADD COLUMN w integer not null"}]
+
+apply schema main;
+-- error: NOT NULL constraint failed
+
+-- n1 is gone again and t has no w.
+select * from n1;
+-- error: not found
+
+select * from t;
+→ [{"id": 1, "v": "a"}]
+
+diff schema main;
+→ [{"ddl": "create table n1 (id integer primary key)"}, {"ddl": "ALTER TABLE t ADD COLUMN w integer not null"}]
+
+-- ===================================
+-- 5. The same failure inside an explicit transaction: savepoint-like
+-- ===================================
+
+begin;
+insert into t values (2, 'b');
+apply schema main;
+-- error: NOT NULL constraint failed
+
+-- The transaction is still open and usable after the restored failure.
+insert into t values (3, 'c');
+commit;
+
+-- run
+
+select id from t order by id;
+→ [{"id": 1}, {"id": 2}, {"id": 3}]
+
+select * from n1;
+-- error: not found
+
+-- Once the violating rows are gone the same declaration applies cleanly.
+delete from t;
+apply schema main;
+
+-- run
+
+diff schema main;
+→ []
+
+drop table n1;
+drop table t;