@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/105.1-vtab-memory-index-mutation-kills.sqllogic

@@ -0,0 +1,540 @@
+-- 105.1-vtab-memory-index-mutation-kills.sqllogic
+-- Mutation-killing tests targeting the SECONDARY-INDEX paths of packages/quereus/src/vtab/memory/
+-- (module.ts index matching / ordering, table.ts index maintenance and comparators)
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 105-vtab-memory-mutation-kills: about 25 of that file's 40 sections reach
+-- the memory module through PRIMARY KEY paths alone (NULL handling, PK ordering, full-scan
+-- fallback, savepoints, transaction isolation, ALTER / RENAME TABLE, connection lifecycle,
+-- upsert, composite PK). The sections below all build a standalone secondary index to reach
+-- the code under test, so they live here and leave the rest runnable on a backend without
+-- first-class CREATE INDEX.
+--
+-- MEMORY-ONLY, like its parent: these are white-box mutation tests against src/vtab/memory/
+-- internals (listed in MEMORY_ONLY_FILES in logic.spec.ts).
+--
+-- Section numbers keep their original 105 labels so cross-references still resolve.
+
+-- ===================================================================
+-- SECTION 5: Index equality matching / prefix matching (module.ts:325-363)
+-- ===================================================================
+
+create table idx_eq (id integer primary key, a integer, b integer, c integer);
+create index idx_ab on idx_eq (a, b);
+insert into idx_eq values (1, 10, 100, 1000), (2, 10, 200, 2000), (3, 20, 100, 3000), (4, 20, 200, 4000), (5, 30, 300, 5000);
+
+-- Exact match on full composite index (a, b)
+select id from idx_eq where a = 10 and b = 200;
+→ [{"id": 2}]
+
+-- Prefix match on first column of composite index
+select id from idx_eq where a = 20 order by id;
+→ [{"id": 3}, {"id": 4}]
+
+-- No match
+select id from idx_eq where a = 99;
+→ []
+
+-- IN on first index column
+select id from idx_eq where a in (10, 30) order by id;
+→ [{"id": 1}, {"id": 2}, {"id": 5}]
+
+-- IN on second index column with equality on first (composite)
+select id from idx_eq where a = 10 and b in (100, 200) order by id;
+→ [{"id": 1}, {"id": 2}]
+
+-- IN with single value (treated as equality)
+select id from idx_eq where a in (20) order by id;
+→ [{"id": 3}, {"id": 4}]
+
+drop table idx_eq;
+
+-- ===================================================================
+-- SECTION 6: Index range matching (module.ts:368-389)
+-- ===================================================================
+
+create table idx_range (id integer primary key, val integer);
+create index idx_val on idx_range (val);
+insert into idx_range values (1, 10), (2, 20), (3, 30), (4, 40), (5, 50);
+
+-- Greater than
+select id from idx_range where val > 25 order by id;
+→ [{"id": 3}, {"id": 4}, {"id": 5}]
+
+-- Greater than or equal
+select id from idx_range where val >= 30 order by id;
+→ [{"id": 3}, {"id": 4}, {"id": 5}]
+
+-- Less than
+select id from idx_range where val < 25 order by id;
+→ [{"id": 1}, {"id": 2}]
+
+-- Less than or equal
+select id from idx_range where val <= 20 order by id;
+→ [{"id": 1}, {"id": 2}]
+
+-- Between (range with both bounds)
+select id from idx_range where val >= 20 and val <= 40 order by id;
+→ [{"id": 2}, {"id": 3}, {"id": 4}]
+
+-- Half-open range (lower bound only)
+select id from idx_range where val > 40 order by id;
+→ [{"id": 5}]
+
+-- Half-open range (upper bound only)
+select id from idx_range where val < 20 order by id;
+→ [{"id": 1}]
+
+-- Range that matches no rows
+select id from idx_range where val > 100;
+→ []
+
+-- Range on PK column
+select id from idx_range where id > 2 and id < 5 order by id;
+→ [{"id": 3}, {"id": 4}]
+
+drop table idx_range;
+
+-- ===================================================================
+-- SECTION 7: Prefix-equality + trailing-range on composite index (module.ts:264-281)
+-- ===================================================================
+
+create table prefix_range (id integer primary key, cat integer, score integer, detail text);
+create index idx_cat_score on prefix_range (cat, score);
+insert into prefix_range values
+	(1, 1, 10, 'a'), (2, 1, 20, 'b'), (3, 1, 30, 'c'),
+	(4, 2, 15, 'd'), (5, 2, 25, 'e'), (6, 2, 35, 'f');
+
+-- Equality on first column + range on second column
+select id from prefix_range where cat = 1 and score > 15 order by id;
+→ [{"id": 2}, {"id": 3}]
+
+select id from prefix_range where cat = 2 and score <= 25 order by id;
+→ [{"id": 4}, {"id": 5}]
+
+select id from prefix_range where cat = 1 and score >= 10 and score <= 20 order by id;
+→ [{"id": 1}, {"id": 2}]
+
+drop table prefix_range;
+
+-- ===================================================================
+-- SECTION 8: Ordering from index (module.ts:414-461)
+-- ===================================================================
+
+create table idx_order (id integer primary key, name text, score integer);
+create index idx_name_asc on idx_order (name);
+create index idx_score_desc on idx_order (score desc);
+insert into idx_order values (1, 'Charlie', 90), (2, 'Alice', 80), (3, 'Bob', 95), (4, 'David', 85);
+
+-- ORDER BY indexed column ascending
+select name from idx_order order by name;
+→ [{"name": "Alice"}, {"name": "Bob"}, {"name": "Charlie"}, {"name": "David"}]
+
+-- ORDER BY indexed column descending (requires DESC index)
+select score from idx_order order by score desc;
+→ [{"score": 95}, {"score": 90}, {"score": 85}, {"score": 80}]
+
+-- ORDER BY non-indexed column still works (external sort)
+select name from idx_order order by id desc;
+→ [{"name": "David"}, {"name": "Bob"}, {"name": "Alice"}, {"name": "Charlie"}]
+
+drop table idx_order;
+
+-- Composite index ordering
+create table comp_order (id integer primary key, a integer, b integer);
+create index idx_ab on comp_order (a, b);
+insert into comp_order values (1, 1, 30), (2, 1, 10), (3, 2, 20), (4, 2, 10), (5, 1, 20);
+
+-- ORDER BY matches composite index prefix
+select id, a, b from comp_order order by a, b;
+→ [{"id": 2, "a": 1, "b": 10}, {"id": 5, "a": 1, "b": 20}, {"id": 1, "a": 1, "b": 30}, {"id": 4, "a": 2, "b": 10}, {"id": 3, "a": 2, "b": 20}]
+
+drop table comp_order;
+
+-- ===================================================================
+-- SECTION 10: Multi-column secondary indexes
+-- ===================================================================
+
+create table multi_idx (id integer primary key, x integer, y integer, z text);
+create index idx_xy on multi_idx (x, y);
+insert into multi_idx values (1, 10, 1, 'a'), (2, 10, 2, 'b'), (3, 20, 1, 'c'), (4, 20, 2, 'd'), (5, 10, 1, 'e');
+
+-- Equality on both columns
+select id from multi_idx where x = 10 and y = 1 order by id;
+→ [{"id": 1}, {"id": 5}]
+
+-- Equality on first only
+select id from multi_idx where x = 20 order by id;
+→ [{"id": 3}, {"id": 4}]
+
+-- Range on second column with equality on first
+select id from multi_idx where x = 10 and y > 1 order by id;
+→ [{"id": 2}]
+
+drop table multi_idx;
+
+-- ===================================================================
+-- SECTION 11: DESC secondary indexes (table.ts:411-428 getIndexComparator)
+-- ===================================================================
+
+create table desc_idx (id integer primary key, score integer, name text);
+create index idx_score_d on desc_idx (score desc);
+insert into desc_idx values (1, 90, 'Alice'), (2, 70, 'Bob'), (3, 85, 'Charlie'), (4, 95, 'David');
+
+-- ORDER BY score DESC should leverage the DESC index
+select name from desc_idx order by score desc;
+→ [{"name": "David"}, {"name": "Alice"}, {"name": "Charlie"}, {"name": "Bob"}]
+
+-- Range on DESC indexed column
+select name from desc_idx where score >= 85 order by score desc;
+→ [{"name": "David"}, {"name": "Alice"}, {"name": "Charlie"}]
+
+select name from desc_idx where score < 90 order by id;
+→ [{"name": "Bob"}, {"name": "Charlie"}]
+
+drop table desc_idx;
+
+-- Mixed ASC/DESC composite index
+create table mixed_dir (id integer primary key, a integer, b integer);
+create index idx_a_asc_b_desc on mixed_dir (a, b desc);
+insert into mixed_dir values (1, 1, 30), (2, 1, 10), (3, 1, 20), (4, 2, 10), (5, 2, 20);
+
+-- Equality on a, range on b (DESC)
+select id, a, b from mixed_dir where a = 1 order by a, b desc;
+→ [{"id": 1, "a": 1, "b": 30}, {"id": 3, "a": 1, "b": 20}, {"id": 2, "a": 1, "b": 10}]
+
+drop table mixed_dir;
+
+-- ===================================================================
+-- SECTION 16: Index CREATE/DROP on populated tables
+-- ===================================================================
+
+create table idx_pop (id integer primary key, category text, value integer);
+insert into idx_pop values (1, 'A', 100), (2, 'B', 200), (3, 'A', 300), (4, 'C', 150), (5, 'B', 250);
+
+-- Create index on populated table
+create index idx_cat on idx_pop (category);
+
+-- Query using the new index
+select id from idx_pop where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}]
+
+select id from idx_pop where category = 'B' order by id;
+→ [{"id": 2}, {"id": 5}]
+
+-- Create composite index on populated table
+create index idx_cat_val on idx_pop (category, value);
+
+-- Query using composite index
+select id from idx_pop where category = 'B' and value > 200;
+→ [{"id": 5}]
+
+-- Drop index and verify queries still work
+drop index idx_cat;
+select id from idx_pop where category = 'C';
+→ [{"id": 4}]
+
+-- Re-create the dropped index
+create index idx_cat on idx_pop (category);
+select id from idx_pop where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}]
+
+-- Insert after index creation
+insert into idx_pop values (6, 'A', 350);
+select id from idx_pop where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}, {"id": 6}]
+
+-- Delete and verify index consistency
+delete from idx_pop where id = 3;
+select id from idx_pop where category = 'A' order by id;
+→ [{"id": 1}, {"id": 6}]
+
+drop table idx_pop;
+
+-- ===================================================================
+-- SECTION 21: Transaction with index modifications
+-- ===================================================================
+
+create table tx_idx (id integer primary key, category text, val integer);
+insert into tx_idx values (1, 'A', 10), (2, 'B', 20), (3, 'A', 30);
+create index idx_tx_cat on tx_idx (category);
+
+-- Insert within transaction then commit — index is consistent
+begin;
+insert into tx_idx values (4, 'A', 40);
+commit;
+select id from tx_idx where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}, {"id": 4}]
+
+-- Delete committed row and verify via index
+delete from tx_idx where id = 4;
+select id from tx_idx where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}]
+
+-- Update indexed column and verify via index
+update tx_idx set category = 'C' where id = 2;
+select id from tx_idx where category = 'B';
+→ []
+select id from tx_idx where category = 'C';
+→ [{"id": 2}]
+
+-- Restore
+update tx_idx set category = 'B' where id = 2;
+select id from tx_idx where category = 'B';
+→ [{"id": 2}]
+
+drop table tx_idx;
+
+-- ===================================================================
+-- SECTION 24: Unique index constraint enforcement
+-- ===================================================================
+
+create table uniq_test (id integer primary key, email text null, name text);
+create unique index idx_email on uniq_test (email);
+insert into uniq_test values (1, 'alice@test.com', 'Alice'), (2, 'bob@test.com', 'Bob');
+
+-- Duplicate unique index value should fail
+insert into uniq_test values (3, 'alice@test.com', 'Alice2');
+-- error: UNIQUE constraint
+
+-- Unique lookup
+select name from uniq_test where email = 'bob@test.com';
+→ [{"name": "Bob"}]
+
+-- Update to a conflicting unique value should fail
+update uniq_test set email = 'alice@test.com' where id = 2;
+-- error: UNIQUE constraint
+
+-- Update unique column to a non-conflicting value should succeed
+update uniq_test set email = 'charlie@test.com' where id = 2;
+select email from uniq_test where id = 2;
+→ [{"email": "charlie@test.com"}]
+
+-- NULL values in unique index (multiple NULLs are allowed)
+insert into uniq_test values (10, null, 'Charlie');
+insert into uniq_test values (11, null, 'David');
+select count(*) as cnt from uniq_test where email is null;
+→ [{"cnt": 2}]
+
+drop table uniq_test;
+
+-- ===================================================================
+-- SECTION 25: SAVEPOINT with mutations on indexed table
+-- ===================================================================
+
+create table sp_idx (id integer primary key, category text);
+create index idx_sp_cat on sp_idx (category);
+insert into sp_idx values (1, 'A'), (2, 'B'), (3, 'A');
+
+begin;
+savepoint s1;
+insert into sp_idx values (4, 'C');
+update sp_idx set category = 'D' where id = 1;
+
+-- Index should reflect pending changes
+select id from sp_idx where category = 'C';
+→ [{"id": 4}]
+select id from sp_idx where category = 'A';
+→ [{"id": 3}]
+select id from sp_idx where category = 'D';
+→ [{"id": 1}]
+
+rollback to savepoint s1;
+
+-- After rollback, index should be consistent with pre-savepoint state
+select id from sp_idx where category = 'A' order by id;
+→ [{"id": 1}, {"id": 3}]
+select id from sp_idx where category = 'C';
+→ []
+select id from sp_idx where category = 'D';
+→ []
+
+commit;
+
+drop table sp_idx;
+
+-- ===================================================================
+-- SECTION 26: Large-ish dataset for index effectiveness
+-- ===================================================================
+
+create table bulk_t (id integer primary key, grp integer, val text);
+create index idx_grp on bulk_t (grp);
+
+-- Insert multiple groups
+insert into bulk_t values (1, 1, 'a1'), (2, 1, 'a2'), (3, 1, 'a3');
+insert into bulk_t values (4, 2, 'b1'), (5, 2, 'b2');
+insert into bulk_t values (6, 3, 'c1'), (7, 3, 'c2'), (8, 3, 'c3'), (9, 3, 'c4');
+insert into bulk_t values (10, 4, 'd1');
+
+-- Count per group using index
+select grp, count(*) as cnt from bulk_t group by grp order by grp;
+→ [{"grp": 1, "cnt": 3}, {"grp": 2, "cnt": 2}, {"grp": 3, "cnt": 4}, {"grp": 4, "cnt": 1}]
+
+-- IN on indexed column
+select id from bulk_t where grp in (1, 3) order by id;
+→ [{"id": 1}, {"id": 2}, {"id": 3}, {"id": 6}, {"id": 7}, {"id": 8}, {"id": 9}]
+
+-- Range on indexed column
+select id from bulk_t where grp >= 3 order by id;
+→ [{"id": 6}, {"id": 7}, {"id": 8}, {"id": 9}, {"id": 10}]
+
+drop table bulk_t;
+
+-- ===================================================================
+-- SECTION 31: Index on non-integer types
+-- ===================================================================
+
+create table text_idx (id integer primary key, label text null);
+create index idx_label on text_idx (label);
+insert into text_idx values (1, 'banana'), (2, 'apple'), (3, 'cherry'), (4, 'apple'), (5, null);
+
+-- Equality on text index
+select id from text_idx where label = 'apple' order by id;
+→ [{"id": 2}, {"id": 4}]
+
+-- IS NULL through index
+select id from text_idx where label is null;
+→ [{"id": 5}]
+
+-- ORDER BY text indexed column
+select label from text_idx where label is not null order by label;
+→ [{"label": "apple"}, {"label": "apple"}, {"label": "banana"}, {"label": "cherry"}]
+
+drop table text_idx;
+
+-- ===================================================================
+-- SECTION 32: Index on text column (basic)
+-- ===================================================================
+
+create table text_ci (id integer primary key, name text);
+insert into text_ci values (1, 'Alice'), (2, 'bob'), (3, 'CHARLIE');
+create index idx_name_ci on text_ci (name);
+
+-- Index works on text columns
+select id from text_ci where name = 'bob';
+→ [{"id": 2}]
+
+-- ORDER BY text indexed column
+select name from text_ci order by name;
+→ [{"name": "Alice"}, {"name": "CHARLIE"}, {"name": "bob"}]
+
+drop table text_ci;
+
+-- ===================================================================
+-- SECTION 33: ALTER TABLE + index interaction
+-- ===================================================================
+
+create table alt_idx (id integer primary key, a integer, b text);
+create index idx_a on alt_idx (a);
+insert into alt_idx values (1, 10, 'x'), (2, 20, 'y');
+
+-- ADD COLUMN — existing index should still work
+alter table alt_idx add column c integer null;
+select id from alt_idx where a = 10;
+→ [{"id": 1}]
+
+-- Insert with new column
+insert into alt_idx values (3, 10, 'z', 100);
+select id from alt_idx where a = 10 order by id;
+→ [{"id": 1}, {"id": 3}]
+
+-- RENAME COLUMN on non-indexed column — index should still work
+alter table alt_idx rename column b to label;
+select id from alt_idx where a = 20;
+→ [{"id": 2}]
+
+-- DROP COLUMN on non-indexed column — index should still work
+alter table alt_idx drop column label;
+select id from alt_idx where a = 10 order by id;
+→ [{"id": 1}, {"id": 3}]
+
+drop table alt_idx;
+
+-- ===================================================================
+-- SECTION 35: Multiple secondary indexes on same table
+-- ===================================================================
+
+create table multi_sec (id integer primary key, a integer, b text, c integer);
+create index idx_ms_a on multi_sec (a);
+create index idx_ms_b on multi_sec (b);
+create index idx_ms_c on multi_sec (c);
+insert into multi_sec values (1, 10, 'x', 100), (2, 20, 'y', 200), (3, 10, 'z', 100), (4, 30, 'x', 300);
+
+-- Use each index independently
+select id from multi_sec where a = 10 order by id;
+→ [{"id": 1}, {"id": 3}]
+
+select id from multi_sec where b = 'x' order by id;
+→ [{"id": 1}, {"id": 4}]
+
+select id from multi_sec where c = 100 order by id;
+→ [{"id": 1}, {"id": 3}]
+
+-- Multiple filter columns — planner chooses best index
+select id from multi_sec where a = 10 and c = 100 order by id;
+→ [{"id": 1}, {"id": 3}]
+
+drop table multi_sec;
+
+-- ===================================================================
+-- SECTION 38: DELETE with index and verify index consistency
+-- ===================================================================
+
+create table del_idx (id integer primary key, tag text);
+create index idx_tag on del_idx (tag);
+insert into del_idx values (1, 'A'), (2, 'B'), (3, 'A'), (4, 'B'), (5, 'C');
+
+-- Delete some rows
+delete from del_idx where tag = 'A';
+
+-- Verify through index
+select id from del_idx where tag = 'A';
+→ []
+
+select id from del_idx where tag = 'B' order by id;
+→ [{"id": 2}, {"id": 4}]
+
+select count(*) as cnt from del_idx;
+→ [{"cnt": 3}]
+
+-- Delete all remaining
+delete from del_idx;
+select count(*) as cnt from del_idx;
+→ [{"cnt": 0}]
+
+-- Insert after full delete — index should still work
+insert into del_idx values (10, 'X');
+select id from del_idx where tag = 'X';
+→ [{"id": 10}]
+
+drop table del_idx;
+
+-- ===================================================================
+-- SECTION 39: UPDATE affecting indexed columns
+-- ===================================================================
+
+create table upd_idx (id integer primary key, category text, priority integer);
+create index idx_upd_cat on upd_idx (category);
+create index idx_upd_pri on upd_idx (priority);
+insert into upd_idx values (1, 'A', 1), (2, 'A', 2), (3, 'B', 1), (4, 'B', 3);
+
+-- Update indexed column
+update upd_idx set category = 'C' where id = 1;
+
+-- Old index value should not find the row
+select id from upd_idx where category = 'A';
+→ [{"id": 2}]
+
+-- New index value should find it
+select id from upd_idx where category = 'C';
+→ [{"id": 1}]
+
+-- Update another indexed column
+update upd_idx set priority = 10 where id = 3;
+select id from upd_idx where priority = 1;
+→ [{"id": 1}]
+select id from upd_idx where priority = 10;
+→ [{"id": 3}]
+
+drop table upd_idx;