@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/01.6-update-extras.sqllogic

@@ -0,0 +1,118 @@
+-- adapted from SQLite test/update.test, test/update2.test
+-- UPDATE feature variants beyond the simple form covered in 01-basic / 42-returning.
+-- Quereus has no rowids, no UPDATE LIMIT/ORDER BY, no INDEXED BY.
+
+-- ===================================
+-- 1. UPDATE all rows (no WHERE)
+-- ===================================
+
+create table all_rows (id integer primary key, status text);
+insert into all_rows values (1, 'pending'), (2, 'pending'), (3, 'pending');
+
+update all_rows set status = 'complete';
+
+select count(*) as cnt from all_rows where status = 'complete';
+→ [{"cnt":3}]
+
+drop table all_rows;
+
+-- ===================================
+-- 2. UPDATE with subquery in SET (scalar subquery)
+-- ===================================
+
+create table src_lookup (id integer primary key, val text);
+create table tgt_lookup (id integer primary key, name text null);
+insert into src_lookup values (1, 'alpha'), (2, 'beta');
+insert into tgt_lookup values (1, null), (2, null);
+
+update tgt_lookup set name = (select val from src_lookup where src_lookup.id = tgt_lookup.id);
+select id, name from tgt_lookup order by id;
+→ [{"id":1,"name":"alpha"},{"id":2,"name":"beta"}]
+
+drop table tgt_lookup;
+drop table src_lookup;
+
+-- ===================================
+-- 3. UPDATE with multiple columns in SET, mixed expressions
+-- ===================================
+
+create table multi_set (id integer primary key, x integer, y integer);
+insert into multi_set values (1, 10, 20), (2, 30, 40);
+
+update multi_set set x = x + 1, y = y * 2 where id = 1;
+
+select id, x, y from multi_set order by id;
+→ [{"id":1,"x":11,"y":40},{"id":2,"x":30,"y":40}]
+
+drop table multi_set;
+
+-- ===================================
+-- 4. UPDATE with column-list assignment from subquery: (a, b) = (select x, y)
+-- ===================================
+
+create table col_list (id integer primary key, a text, b text);
+insert into col_list values (1, 'x', 'y');
+
+-- column-list SET assignment is not supported by the parser
+update col_list set (a, b) = (select 'new_a', 'new_b') where id = 1;
+-- error: Expected column name
+
+drop table col_list;
+
+-- ===================================
+-- 5. UPDATE with NOT condition in WHERE
+-- ===================================
+
+create table neg_pred (id integer primary key, n integer);
+insert into neg_pred values (1, 10), (2, 20), (3, 30), (4, 40), (5, 50);
+
+update neg_pred set n = 0 where not (id <= 3);
+
+select id, n from neg_pred order by id;
+→ [{"id":1,"n":10},{"id":2,"n":20},{"id":3,"n":30},{"id":4,"n":0},{"id":5,"n":0}]
+
+drop table neg_pred;
+
+-- ===================================
+-- 6. UPDATE with OR conditions in WHERE
+-- ===================================
+
+create table or_pred (id integer primary key, a integer, b integer);
+insert into or_pred values (1, 5, 100), (2, 10, 50), (3, 50, 5), (4, 1, 1);
+
+update or_pred set a = a + 1000 where a > 8 or b > 80;
+
+select id, a from or_pred order by id;
+→ [{"id":1,"a":1005},{"id":2,"a":1010},{"id":3,"a":1050},{"id":4,"a":1}]
+
+drop table or_pred;
+
+-- ===================================
+-- 7. UPDATE on PRIMARY KEY column (key change)
+-- ===================================
+
+create table pk_change (id integer primary key, name text);
+insert into pk_change values (1, 'one'), (2, 'two');
+
+update pk_change set id = 99 where name = 'two';
+
+select id, name from pk_change order by id;
+→ [{"id":1,"name":"one"},{"id":99,"name":"two"}]
+
+drop table pk_change;
+
+-- ===================================
+-- 8. UPDATE assigning the same column twice is rejected (no silent last-wins)
+-- ===================================
+
+create table dup_set (id integer primary key, b integer);
+insert into dup_set values (1, 10);
+
+update dup_set set b = 1, b = 2 where id = 1;
+-- error: duplicate assignment
+
+-- the rejected UPDATE made no change.
+select id, b from dup_set order by id;
+→ [{"id":1,"b":10}]
+
+drop table dup_set;

package/test/logic/01.7-update-from.sqllogic

@@ -0,0 +1,67 @@
+-- UPDATE ... FROM (PostgreSQL/SQLite-3.33+ syntax) is not supported by Quereus.
+-- The parser rejects the FROM clause after SET. This file pins that rejection.
+
+-- ===================================
+-- 1. UPDATE ... FROM single table (basic equi-join) — not supported
+-- ===================================
+
+create table tgt (id integer primary key, val text);
+create table src (id integer primary key, newval text);
+insert into tgt values (1, 'old1'), (2, 'old2'), (3, 'unchanged');
+insert into src values (1, 'new1'), (2, 'new2');
+
+update tgt set val = src.newval from src where tgt.id = src.id;
+-- error: Expected statement type
+
+drop table src;
+drop table tgt;
+
+-- ===================================
+-- 2. UPDATE ... FROM with subquery in FROM — not supported
+-- ===================================
+
+create table grades (student_id integer primary key, total integer);
+create table scores (id integer primary key, student_id integer, exam integer);
+insert into grades values (1, 0), (2, 0), (3, 0);
+insert into scores values (1, 1, 80), (2, 1, 90), (3, 2, 75), (4, 2, 85), (5, 3, 60);
+
+update grades set total = s.tot
+   from (select student_id, sum(exam) as tot from scores group by student_id) s
+   where grades.student_id = s.student_id;
+-- error: Expected statement type
+
+drop table scores;
+drop table grades;
+
+-- ===================================
+-- 3. UPDATE ... FROM with CTE — not supported
+-- ===================================
+
+create table sales (id integer primary key, amount integer, multiplier real null);
+insert into sales values (1, 100, null), (2, 200, null), (3, 300, null);
+
+with mult(id, m) as (values (1, 1.5), (2, 2.0), (3, 3.0))
+   update sales set multiplier = mult.m from mult where sales.id = mult.id;
+-- error: Expected statement type
+
+drop table sales;
+
+-- ===================================
+-- 4. UPDATE ... FROM with multi-table join in FROM — not supported
+-- ===================================
+
+create table emp (id integer primary key, dept_id integer, salary integer);
+create table dept (id integer primary key, region_id integer);
+create table region (id integer primary key, bonus_pct integer);
+insert into emp values (1, 10, 1000), (2, 10, 2000), (3, 20, 3000);
+insert into dept values (10, 100), (20, 200);
+insert into region values (100, 10), (200, 20);
+
+update emp set salary = salary + (salary * region.bonus_pct / 100)
+   from dept, region
+   where emp.dept_id = dept.id and dept.region_id = region.id;
+-- error: Expected statement type
+
+drop table region;
+drop table dept;
+drop table emp;

package/test/logic/01.8-delete-extras.sqllogic

@@ -0,0 +1,122 @@
+-- adapted from SQLite test/delete.test, test/delete4.test
+-- DELETE feature variants beyond the simple form covered in 01-basic / 02-smoke.
+-- Quereus has no rowids and no DELETE LIMIT/ORDER BY; the rowid-bound DELETE
+-- variants from SQLite are n/a — the multi-row delete via PK is the surface here.
+
+-- ===================================
+-- 1. DELETE with EXISTS subquery
+-- ===================================
+
+create table del_parent (id integer primary key, val text);
+create table del_child (id integer primary key, parent_id integer);
+insert into del_parent values (1, 'a'), (2, 'b'), (3, 'c');
+insert into del_child values (10, 1), (20, 2);
+
+delete from del_parent where exists (select 1 from del_child where del_child.parent_id = del_parent.id);
+select id, val from del_parent order by id;
+→ [{"id":3,"val":"c"}]
+
+drop table del_child;
+drop table del_parent;
+
+-- ===================================
+-- 2. DELETE with NOT EXISTS subquery
+-- ===================================
+
+create table orders (id integer primary key, customer_id integer);
+create table customers (id integer primary key, active integer);
+insert into customers values (1, 1), (2, 0);
+insert into orders values (10, 1), (20, 1), (30, 2);
+
+delete from orders where not exists (select 1 from customers where customers.id = orders.customer_id and customers.active = 1);
+select id, customer_id from orders order by id;
+→ [{"id":10,"customer_id":1},{"id":20,"customer_id":1}]
+
+drop table orders;
+drop table customers;
+
+-- ===================================
+-- 3. DELETE with NOT condition in WHERE
+-- ===================================
+
+create table del_neg (vkey integer primary key, c1 integer);
+insert into del_neg values (1, 10), (2, 20), (3, 30), (4, 40), (5, 50);
+
+delete from del_neg where not (vkey <= 3);
+
+select vkey from del_neg order by vkey;
+→ [{"vkey":1},{"vkey":2},{"vkey":3}]
+
+drop table del_neg;
+
+-- ===================================
+-- 4. DELETE with OR conditions across columns
+-- ===================================
+
+create table del_or (id integer primary key, a text, b text);
+insert into del_or values (1, 'one', 'i'), (2, 'two', 'ii'), (3, 'three', 'iii'), (4, 'four', 'iv');
+
+delete from del_or where a = 'two' or b = 'iv';
+
+select id from del_or order by id;
+→ [{"id":1},{"id":3}]
+
+drop table del_or;
+
+-- ===================================
+-- 5. DELETE with multi-column AND on non-PK columns
+-- ===================================
+
+create table inventory (id integer primary key, loc text not null, sku text not null, qty integer);
+insert into inventory values (1, 'W1', 'A1', 10), (2, 'W1', 'A2', 20), (3, 'W2', 'A1', 30);
+
+delete from inventory where loc = 'W1' and sku = 'A1';
+
+select id from inventory order by id;
+→ [{"id":2},{"id":3}]
+
+drop table inventory;
+
+-- ===================================
+-- 6. DELETE with self-referential EXISTS (delete rows that have a "next" sibling)
+-- ===================================
+
+create table seq (x integer primary key);
+insert into seq values (1), (2), (3), (4), (5);
+
+delete from seq where exists (select 1 from seq as s2 where s2.x = seq.x + 1);
+select x from seq order by x;
+→ [{"x":5}]
+
+drop table seq;
+
+-- ===================================
+-- 7. DELETE all rows from a composite-PK table
+-- ===================================
+
+create table comp_pk (a integer, b integer, val text, primary key (a, b));
+insert into comp_pk values (1, 2, 'p'), (1, 3, 'q'), (2, 4, 'r'), (3, 5, 's');
+
+delete from comp_pk;
+
+select count(*) as cnt from comp_pk;
+→ [{"cnt":0}]
+
+drop table comp_pk;
+
+-- ===================================
+-- 8. DELETE with subquery driving the IN list
+-- ===================================
+
+create table flag_table (id integer primary key, flag integer);
+create table data_table (id integer primary key, val text);
+insert into flag_table values (1, 0), (2, 1), (3, 0), (4, 1);
+insert into data_table values (1, 'a'), (2, 'b'), (3, 'c'), (4, 'd');
+
+delete from data_table where id in (select id from flag_table where flag = 1);
+
+select id, val from data_table order by id;
+→ [{"id":1,"val":"a"},{"id":3,"val":"c"}]
+
+drop table flag_table;
+drop table data_table;

package/test/logic/01.8.1-delete-range-cow.sqllogic

@@ -0,0 +1,115 @@
+-- Regression for the silent under-delete on a non-front-anchored range DELETE.
+-- Root cause was an inheritree copy-on-write delete bug: deleting a key that triggers
+-- a sibling borrow/merge during rebalance orphaned the freshly-cloned node, dropping
+-- deletions and producing phantom-repeated keys. See delete-range-predicate-under-deletes.
+--
+-- A front-anchored `id <= k` delete only ever merges/borrows with a RIGHT sibling and so
+-- dodged the bug; these cases therefore use tail / interleaved / between predicates, and
+-- a table big enough (n = 200, well past the 64-entry node capacity) that the delete set
+-- forces a real b-tree structural change mid-delete.
+--
+-- Each case asserts matched == deleted via the surviving count, and guards against the
+-- phantom-repeated-key corruption two ways: count(*) == count(distinct id), and a
+-- payload-integrity probe (`v` must equal `id * 10` for every surviving row — a phantom
+-- alias would surface a mismatched payload).
+
+-- ===================================
+-- 1. Tail predicate: delete id > 100
+-- ===================================
+
+create table cow_tail (id integer primary key, v integer);
+insert into cow_tail select value, value * 10 from generate_series(1, 200);
+
+delete from cow_tail where id > 100;
+
+select count(*) as cnt, count(distinct id) as dist, min(id) as mn, max(id) as mx, sum(id) as s from cow_tail;
+→ [{"cnt":100,"dist":100,"mn":1,"mx":100,"s":5050}]
+
+-- No survivor carries a mismatched payload (phantom alias guard).
+select count(*) as bad from cow_tail where v <> id * 10;
+→ [{"bad":0}]
+
+-- Every deleted key is actually gone.
+select count(*) as still_there from cow_tail where id > 100;
+→ [{"still_there":0}]
+
+drop table cow_tail;
+
+-- ===================================
+-- 2. Interleaved predicate: delete id % 2 = 0
+-- ===================================
+
+create table cow_even (id integer primary key, v integer);
+insert into cow_even select value, value * 10 from generate_series(1, 200);
+
+delete from cow_even where id % 2 = 0;
+
+-- Survivors are the 100 odd ids 1,3,..,199; sum of first 100 odds = 100^2 = 10000.
+select count(*) as cnt, count(distinct id) as dist, min(id) as mn, max(id) as mx, sum(id) as s from cow_even;
+→ [{"cnt":100,"dist":100,"mn":1,"mx":199,"s":10000}]
+
+select count(*) as bad from cow_even where v <> id * 10;
+→ [{"bad":0}]
+
+-- No surviving id is even.
+select count(*) as evens_left from cow_even where id % 2 = 0;
+→ [{"evens_left":0}]
+
+drop table cow_even;
+
+-- ===================================
+-- 3. Between predicate: delete id between 51 and 150
+-- ===================================
+
+create table cow_band (id integer primary key, v integer);
+insert into cow_band select value, value * 10 from generate_series(1, 200);
+
+delete from cow_band where id between 51 and 150;
+
+-- Survivors are 1..50 and 151..200 (100 rows); sum = 20100 - sum(51..150) = 20100 - 10050.
+select count(*) as cnt, count(distinct id) as dist, min(id) as mn, max(id) as mx, sum(id) as s from cow_band;
+→ [{"cnt":100,"dist":100,"mn":1,"mx":200,"s":10050}]
+
+select count(*) as bad from cow_band where v <> id * 10;
+→ [{"bad":0}]
+
+-- The whole deleted band is gone.
+select count(*) as band_left from cow_band where id between 51 and 150;
+→ [{"band_left":0}]
+
+drop table cow_band;
+
+-- ===================================
+-- 4. Scattered predicate: delete id % 3 = 0 (66 keys spread across the tree)
+-- ===================================
+
+create table cow_third (id integer primary key, v integer);
+insert into cow_third select value, value * 10 from generate_series(1, 200);
+
+delete from cow_third where id % 3 = 0;
+
+-- 66 multiples of 3 in 1..200 are removed, leaving 134.
+select count(*) as cnt, count(distinct id) as dist from cow_third;
+→ [{"cnt":134,"dist":134}]
+
+select count(*) as bad from cow_third where v <> id * 10;
+→ [{"bad":0}]
+
+select count(*) as thirds_left from cow_third where id % 3 = 0;
+→ [{"thirds_left":0}]
+
+drop table cow_third;
+
+-- ===================================
+-- 5. No-match predicate over a large table is a clean no-op
+-- ===================================
+
+create table cow_nomatch (id integer primary key, v integer);
+insert into cow_nomatch select value, value * 10 from generate_series(1, 200);
+
+delete from cow_nomatch where id > 1000;
+
+select count(*) as cnt, count(distinct id) as dist, sum(id) as s from cow_nomatch;
+→ [{"cnt":200,"dist":200,"s":20100}]
+
+drop table cow_nomatch;

package/test/logic/01.9-query-expr-dml-gates.sqllogic

@@ -0,0 +1,32 @@
+-- query-expr-dml-gates.sqllogic — pins the remaining gates around DML in
+-- relation positions after the dml-in-expression-position ticket landed.
+--
+-- The parser-side gate (DML in a non-top-level relation position must carry
+-- RETURNING) survives untouched. The planner-side gate that blocked DML in
+-- scalar / IN / EXISTS / compound-leg / CTE-body positions is gone — those
+-- positions now execute under full-drain + run-once semantics (see the
+-- companion 01.9-query-expr-dml.sqllogic file for executable cases).
+-- The only remaining planner-side gate is "DML as a view body", which is
+-- permanently rejected (a view re-evaluates per reference; replaying writes
+-- on every read is incoherent with view semantics).
+
+create table t (id integer primary key, name text);
+
+-- ===================================
+-- Parser-side gate: DML in a relation position without RETURNING
+-- ===================================
+
+select * from (insert into t values (1, 'a')) as s;
+-- error: must have a RETURNING clause
+
+select 1 + (insert into t values (2, 'b'));
+-- error: must have a RETURNING clause
+
+-- ===================================
+-- Planner-side gate: DML as a view body is rejected at creation time
+-- ===================================
+
+create view v_dml as insert into t values (6, 'f') returning id;
+-- error: cannot be used as a view body
+
+drop table t;

package/test/logic/01.9-query-expr-dml.sqllogic

@@ -0,0 +1,171 @@
+-- query-expr-dml.sqllogic — exercises DML with RETURNING in every relation
+-- position that the dml-in-expression-position ticket unlocked: scalar / IN /
+-- EXISTS / compound-leg / CTE-body / FROM-source / INSERT-source.
+--
+-- Two contracts the emitters apply on impure (DML-bearing) inners:
+--   - full-drain: every row of the inner is consumed, so every write fires
+--     (no short-circuit on first row, on match, or on EXISTS=true).
+--   - run-once: when an outer expression is re-evaluated (correlated
+--     subquery / per-row scan), the inner DML executes exactly once per
+--     statement execution. The memoized result is replayed thereafter.
+
+-- ===================================
+-- 1. EXISTS over a DML inner: fully drains (no short-circuit on first row)
+-- ===================================
+
+create table log_e (v integer);
+select exists (insert into log_e values (1), (2), (3) returning v);
+→ [{"exists (insert into log_e values (1), (2), (3) returning v)":true}]
+select count(*) as c from log_e;
+→ [{"c":3}]
+drop table log_e;
+
+-- ===================================
+-- 2. IN over a DML inner: fully drains (no short-circuit on first match)
+-- ===================================
+
+create table log_i (v integer);
+select 1 in (insert into log_i values (1), (2), (3) returning v) as found;
+→ [{"found":true}]
+select count(*) as c from log_i;
+→ [{"c":3}]
+drop table log_i;
+
+-- ===================================
+-- 3. Scalar subquery over a DML inner: drains every row, scalar = first
+-- ===================================
+
+create table log_s (v integer);
+select (insert into log_s values (10), (20), (30) returning v) as first_v;
+→ [{"first_v":10}]
+select count(*) as c, sum(v) as total from log_s;
+→ [{"c":3,"total":60}]
+drop table log_s;
+
+-- ===================================
+-- 4. Run-once fence: correlated outer evaluating per row fires DML once
+-- ===================================
+-- Without the run-once fence the EXISTS inner would re-fire per outer row.
+-- With it, the inner DML runs exactly once regardless of outer cardinality.
+
+create table outer_t (o integer);
+insert into outer_t values (1), (2), (3), (4), (5);
+create table log_o (v integer);
+
+select o, exists (insert into log_o values (100) returning v) as ex
+from outer_t order by o;
+→ [{"o":1,"ex":true},{"o":2,"ex":true},{"o":3,"ex":true},{"o":4,"ex":true},{"o":5,"ex":true}]
+select count(*) as c from log_o;
+→ [{"c":1}]
+drop table outer_t;
+drop table log_o;
+
+-- ===================================
+-- 5. DML in a compound-set leg: VALUES UNION ALL (insert … returning …)
+-- ===================================
+
+create table log_c (v integer);
+values (1) union all (insert into log_c values (2) returning v);
+→ [{"column_0":1},{"column_0":2}]
+select v from log_c;
+→ [{"v":2}]
+drop table log_c;
+
+-- ===================================
+-- 6. DML in a CTE body
+-- ===================================
+
+create table log_cte (v integer);
+with x(v) as (insert into log_cte values (1), (2) returning v)
+select v from x order by v;
+→ [{"v":1},{"v":2}]
+select count(*) as c from log_cte;
+→ [{"c":2}]
+drop table log_cte;
+
+-- ===================================
+-- 7. DML as INSERT source (outer insert consumes inner RETURNING rows)
+-- ===================================
+
+create table src_t (v integer);
+create table dst_t (v integer);
+insert into src_t values (10), (20), (30);
+insert into dst_t insert into src_t values (1), (2) returning v;
+select v from dst_t order by v;
+→ [{"v":1},{"v":2}]
+select v from src_t order by v;
+→ [{"v":1},{"v":2},{"v":10},{"v":20},{"v":30}]
+drop table src_t;
+drop table dst_t;
+
+-- ===================================
+-- 8. Conflict-resolution scoping: outer OR REPLACE does NOT propagate inward
+-- ===================================
+-- The outer INSERT's OR REPLACE applies only to the outer's conflicts. The
+-- inner INSERT carries its own (default) conflict resolution. We pin this by
+-- running an inner INSERT whose values would conflict with a pre-existing row
+-- in the inner table; the inner must error with its own default (ABORT),
+-- regardless of the outer OR REPLACE.
+
+create table inner_pk (id integer primary key, v text);
+create table outer_pk (id integer primary key, v text);
+insert into inner_pk values (1, 'pre');
+
+insert or replace into outer_pk
+  insert into inner_pk values (1, 'dup') returning id, v;
+-- error: constraint
+
+select v from inner_pk where id = 1;
+→ [{"v":"pre"}]
+drop table inner_pk;
+drop table outer_pk;
+
+-- ===================================
+-- 8b. UPDATE in EXISTS position fires its writes (parallel to case 1)
+-- ===================================
+
+create table upd_e (id integer primary key, v integer);
+insert into upd_e values (1, 10), (2, 20), (3, 30);
+select exists (update upd_e set v = v + 1 returning v) as ex;
+→ [{"ex":true}]
+select v from upd_e order by id;
+→ [{"v":11},{"v":21},{"v":31}]
+drop table upd_e;
+
+-- ===================================
+-- 8c. DELETE as scalar subquery returns the deleted row's value
+-- ===================================
+-- Single-row DELETE keeps the scalar deterministic without relying on order
+-- of returned rows for multi-row DML in scalar position.
+
+create table del_s (id integer primary key, v integer);
+insert into del_s values (1, 100), (2, 200), (3, 300);
+select (delete from del_s where id = 2 returning v) as deleted;
+→ [{"deleted":200}]
+select v from del_s order by id;
+→ [{"v":100},{"v":300}]
+drop table del_s;
+
+-- ===================================
+-- 9. View bodied as VALUES is unupdateable (FD-driven path)
+-- ===================================
+
+create view v_vals as values (1, 'a'), (2, 'b');
+select * from v_vals order by column_0;
+→ [{"column_0":1,"column_1":"a"},{"column_0":2,"column_1":"b"}]
+insert into v_vals values (3, 'c');
+-- error:
+drop view v_vals;
+
+-- ===================================
+-- 10. DML in CHECK constraint is rejected by the determinism enforcer
+-- ===================================
+-- Constraint validation is lazy (built on first INSERT planning), so the
+-- CREATE TABLE itself succeeds; the INSERT triggers the determinism check.
+
+create table src_d (v integer);
+create table t_check (id integer primary key, x integer check ((select v from (insert into src_d values (1) returning v)) is not null));
+insert into t_check values (1, 1);
+-- error: non-deterministic
+drop table t_check;
+drop table src_d;