@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/10.6-distinct-edge-cases.sqllogic

@@ -0,0 +1,119 @@
+-- adapted from SQLite test/distinct.test, test/distinct2.test, test/select1.test
+-- DISTINCT edge cases not covered in 10-distinct_datatypes: select-all
+-- wildcards, joins, recursive CTEs, reordered SELECT lists, and explicit
+-- COLLATE in the projection.
+
+create table dt (id integer primary key, grp text, val integer);
+insert into dt values
+  (1, 'A', 100),
+  (2, 'A', 100),
+  (3, 'B', 200),
+  (4, 'A', 100);
+
+-- DISTINCT * — full row deduplication
+select distinct * from dt order by id;
+→ [{"id":1,"grp":"A","val":100},{"id":2,"grp":"A","val":100},{"id":3,"grp":"B","val":200},{"id":4,"grp":"A","val":100}]
+
+-- DISTINCT * after dropping the unique key — duplicate rows collapse
+select distinct grp, val from dt order by grp, val;
+→ [{"grp":"A","val":100},{"grp":"B","val":200}]
+
+-- DISTINCT with WHERE filter
+select distinct * from dt where grp = 'A' order by id;
+→ [{"id":1,"grp":"A","val":100},{"id":2,"grp":"A","val":100},{"id":4,"grp":"A","val":100}]
+
+-- DISTINCT preserves dedup regardless of SELECT-list order
+select distinct val, grp from dt order by val, grp;
+→ [{"val":100,"grp":"A"},{"val":200,"grp":"B"}]
+
+drop table dt;
+
+-- =============================================================================
+-- DISTINCT across CROSS JOIN — Cartesian product then dedup
+-- =============================================================================
+
+create table cj_a (id integer primary key, x integer);
+create table cj_b (id integer primary key, y integer);
+insert into cj_a values (1, 1), (2, 2);
+insert into cj_b values (1, 10), (2, 20), (3, 10);
+
+select distinct cj_a.x, cj_b.y
+from cj_a cross join cj_b
+order by cj_a.x, cj_b.y;
+→ [{"x":1,"y":10},{"x":1,"y":20},{"x":2,"y":10},{"x":2,"y":20}]
+
+drop table cj_b;
+drop table cj_a;
+
+-- =============================================================================
+-- DISTINCT across LEFT JOIN — NULL-padded rows participate in dedup
+-- =============================================================================
+
+create table lj_l (id integer primary key, cat text);
+create table lj_r (id integer primary key, lj_l_id integer, tag text);
+insert into lj_l values (1, 'A'), (2, 'B'), (3, 'A');
+insert into lj_r values (10, 1, 'x'), (20, 2, 'y');
+
+-- DISTINCT on the parent column: LEFT JOIN's NULL-padded right side doesn't
+-- duplicate the parent — categories collapse to A, B.
+select distinct lj_l.cat
+from lj_l left join lj_r on lj_l.id = lj_r.lj_l_id
+order by lj_l.cat;
+→ [{"cat":"A"},{"cat":"B"}]
+
+-- DISTINCT including the joined column — NULL appears once for unmatched parent (lj_l.id=3)
+select distinct lj_l.cat, lj_r.tag
+from lj_l left join lj_r on lj_l.id = lj_r.lj_l_id
+order by lj_l.cat, lj_r.tag;
+→ [{"cat":"A","tag":null},{"cat":"A","tag":"x"},{"cat":"B","tag":"y"}]
+
+drop table lj_r;
+drop table lj_l;
+
+-- =============================================================================
+-- DISTINCT inside a recursive CTE
+-- =============================================================================
+
+with recursive cnt(n) as (
+  select 1
+  union all
+  select n + 1 from cnt where n < 4
+)
+select distinct n from cnt order by n;
+→ [{"n":1},{"n":2},{"n":3},{"n":4}]
+
+-- DISTINCT applied to the body of a non-recursive CTE that emits dups
+with src(v) as (
+  select 1 union all select 2 union all select 1 union all select 3 union all select 2
+)
+select distinct v from src order by v;
+→ [{"v":1},{"v":2},{"v":3}]
+
+-- =============================================================================
+-- DISTINCT with explicit COLLATE in the projection
+-- =============================================================================
+
+create table cs (id integer primary key, name text);
+insert into cs values (1, 'Bob'), (2, 'bob'), (3, 'Alice'), (4, 'BOB');
+
+-- COLLATE BINARY (default) keeps case-distinct values
+select distinct name from cs order by name;
+→ [{"name":"Alice"},{"name":"BOB"},{"name":"Bob"},{"name":"bob"}]
+
+-- COLLATE NOCASE in the projection collapses case-equivalent strings
+select distinct name collate nocase as name from cs order by name collate nocase;
+→ [{"name":"Alice"},{"name":"Bob"}]
+
+drop table cs;
+
+-- =============================================================================
+-- DISTINCT with duplicate column reference — same column projected twice
+-- =============================================================================
+
+create table dc (id integer primary key, x integer);
+insert into dc values (1, 100), (2, 100), (3, 200);
+
+select distinct x, x from dc order by x;
+→ [{"x":100,"x:1":100},{"x":200,"x:1":200}]
+
+drop table dc;

package/test/logic/100-predicate-normalization-edge-cases.sqllogic

@@ -0,0 +1,238 @@
+-- predicate-normalization-edge-cases.sqllogic
+-- Tests for predicate normalization: De Morgan, double/triple negation,
+-- NOT on comparisons, OR flattening, OR-to-IN collapse, BETWEEN, IS NULL, etc.
+
+-- =============================================================================
+-- Setup
+-- =============================================================================
+
+create table norm (id integer primary key, a integer null, b integer null, c text null);
+insert into norm values (1, 10, 100, 'alpha'), (2, 20, 200, 'beta'), (3, 30, 300, null), (4, null, 400, 'delta'), (5, 50, null, 'epsilon');
+
+-- =============================================================================
+-- De Morgan's laws
+-- =============================================================================
+
+-- De Morgan with AND: NOT (a > 10 AND b > 200) → a <= 10 OR b <= 200
+-- id=1: not(false and false)=true; id=2: not(true and false)=true;
+-- id=3: not(true and true)=false; id=4: not(null and true)=not(null)=null; id=5: not(true and null)=not(null)=null
+select id from norm where not (a > 10 and b > 200) order by id;
+→ [{"id":1},{"id":2}]
+
+-- De Morgan with OR: NOT (a = 10 OR a = 20) → a != 10 AND a != 20
+-- id=3: a=30 passes; id=5: a=50 passes; id=4: a=null → null
+select id from norm where not (a = 10 or a = 20) order by id;
+→ [{"id":3},{"id":5}]
+
+-- =============================================================================
+-- Double and triple negation
+-- =============================================================================
+
+-- Double negation: NOT NOT (a > 20) → a > 20
+select id from norm where not not (a > 20) order by id;
+→ [{"id":3},{"id":5}]
+
+-- Triple negation: NOT NOT NOT (a > 20) → NOT (a > 20) → a <= 20
+select id from norm where not not not (a > 20) order by id;
+→ [{"id":1},{"id":2}]
+
+-- =============================================================================
+-- NOT on comparison operators
+-- =============================================================================
+
+-- NOT (a > 20) → a <= 20
+select id from norm where not (a > 20) order by id;
+→ [{"id":1},{"id":2}]
+
+-- NOT (a >= 20) → a < 20
+select id from norm where not (a >= 20) order by id;
+→ [{"id":1}]
+
+-- NOT (a < 30) → a >= 30
+select id from norm where not (a < 30) order by id;
+→ [{"id":3},{"id":5}]
+
+-- NOT (a <= 20) → a > 20
+select id from norm where not (a <= 20) order by id;
+→ [{"id":3},{"id":5}]
+
+-- =============================================================================
+-- OR flattening and OR-to-IN collapse
+-- =============================================================================
+
+-- OR flattening: nested OR groups flatten into a single OR
+select id from norm where (a = 10 or a = 20) or a = 30 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- OR-to-IN collapse: a = 10 OR a = 20 OR a = 30 → a IN (10,20,30)
+select id from norm where a = 10 or a = 20 or a = 30 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- =============================================================================
+-- BETWEEN and NOT BETWEEN
+-- =============================================================================
+
+-- BETWEEN: a between 20 and 30 → a >= 20 AND a <= 30
+select id from norm where a between 20 and 30 order by id;
+→ [{"id":2},{"id":3}]
+
+-- NOT BETWEEN: not (a between 20 and 40) → a < 20 OR a > 40
+-- id=1: a=10 outside; id=5: a=50 outside; id=4: a=null → null
+select id from norm where not (a between 20 and 40) order by id;
+→ [{"id":1},{"id":5}]
+
+-- =============================================================================
+-- NOT on IS NULL / IS NOT NULL
+-- =============================================================================
+
+-- NOT IS NULL → IS NOT NULL
+select id from norm where not (c is null) order by id;
+→ [{"id":1},{"id":2},{"id":4},{"id":5}]
+
+-- NOT IS NOT NULL → IS NULL
+select id from norm where not (c is not null) order by id;
+→ [{"id":3}]
+
+-- =============================================================================
+-- Complex nested predicates
+-- =============================================================================
+
+-- NOT ((a > 10 AND b < 300) OR c IS NULL)
+-- id=1: not((false and true) or false) = not(false) = true
+-- id=2: not((true and true) or false) = not(true) = false
+-- id=3: not((true and false) or true) = not(true) = false
+-- id=4: not((null and false) or false) = not(false) = true
+-- id=5: not((true and null) or false) = not(null) = null
+select id from norm where not ((a > 10 and b < 300) or c is null) order by id;
+→ [{"id":1},{"id":4}]
+
+-- Mixed NOT with AND/OR: NOT (a = 10) AND NOT (b = 200)
+-- Only id=3 passes (a=30≠10, b=300≠200); id=4 and id=5 have NULLs
+select id from norm where not (a = 10) and not (b = 200) order by id;
+→ [{"id":3}]
+
+-- =============================================================================
+-- Reversed operand order
+-- =============================================================================
+
+-- OR with reversed operands: literal = column pattern
+select id from norm where 10 = a or 20 = a order by id;
+→ [{"id":1},{"id":2}]
+
+-- =============================================================================
+-- Deeply nested AND flattening
+-- =============================================================================
+
+-- Nested AND: a > 5 AND (b > 50 AND (a < 100 AND b < 500)) flattens to four ANDs
+-- id=1: all true; id=2: all true; id=3: all true; id=4: a=null; id=5: b=null
+select id from norm where a > 5 and (b > 50 and (a < 100 and b < 500)) order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- =============================================================================
+-- OR-to-IN with mixed operand order (lit=col and col=lit)
+-- =============================================================================
+
+-- Mixed literal=column and column=literal patterns should all resolve correctly
+-- id=1: 10=a true; id=2: a=20 true; id=3: 30=a true
+select id from norm where 10 = a or a = 20 or 30 = a order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- =============================================================================
+-- OR-to-IN with different columns should NOT collapse
+-- =============================================================================
+
+-- Different columns in OR disjuncts: no IN collapse, but correct results
+-- id=1: a=10 true; id=2: b=200 true; others: a≠10 and b≠200 or null
+select id from norm where a = 10 or b = 200 order by id;
+→ [{"id":1},{"id":2}]
+
+-- =============================================================================
+-- OR-to-IN with non-equality operators
+-- =============================================================================
+
+-- Non-equality (>) should not trigger IN collapse
+-- id=2: a=20>10; id=3: a=30>10; id=5: a=50>10; id=4: a=null
+select id from norm where a > 10 or a > 20 order by id;
+→ [{"id":2},{"id":3},{"id":5}]
+
+-- =============================================================================
+-- OR-to-IN with non-binary disjunct (BETWEEN)
+-- =============================================================================
+
+-- BETWEEN is not a BinaryOp; should not trigger IN collapse
+-- id=1: a=10 true; id=2: a=20 in [20,30]; id=3: a=30 in [20,30]
+select id from norm where a = 10 or a between 20 and 30 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- =============================================================================
+-- Deeply nested OR flattening (4-level)
+-- =============================================================================
+
+-- Four nested ORs: ((a=10 OR a=20) OR (a=30 OR a=50)) flattens completely
+select id from norm where ((a = 10 or a = 20) or (a = 30 or a = 50)) order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":5}]
+
+-- =============================================================================
+-- NOT over IS NOT NULL
+-- =============================================================================
+
+-- NOT (a IS NOT NULL) should behave like IS NULL
+-- id=4: a=null
+select id from norm where not (a is not null) order by id;
+→ [{"id":4}]
+
+-- NOT (b IS NOT NULL) should behave like IS NULL
+-- id=5: b=null
+select id from norm where not (b is not null) order by id;
+→ [{"id":5}]
+
+-- =============================================================================
+-- NOT over non-invertible binary (LIKE)
+-- =============================================================================
+
+-- NOT (c LIKE 'alpha') should negate the LIKE result
+-- id=2: beta≠alpha; id=3: null→null; id=4: delta≠alpha; id=5: epsilon≠alpha
+select id from norm where not (c like 'alpha') order by id;
+→ [{"id":2},{"id":4},{"id":5}]
+
+-- =============================================================================
+-- OR-to-IN boundary: 33 disjuncts (exceeds 32 limit)
+-- =============================================================================
+
+-- 33 disjuncts should not collapse to IN but still return correct results
+-- Only a=10 (id=1), a=20 (id=2), a=30 (id=3), a=50 (id=5) match from our data
+select id from norm where a=1 or a=2 or a=3 or a=4 or a=5 or a=6 or a=7 or a=8 or a=9 or a=10 or a=11 or a=12 or a=13 or a=14 or a=15 or a=16 or a=17 or a=18 or a=19 or a=20 or a=21 or a=22 or a=23 or a=24 or a=25 or a=26 or a=27 or a=28 or a=29 or a=30 or a=31 or a=32 or a=33 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- =============================================================================
+-- NOT BETWEEN double toggle
+-- =============================================================================
+
+-- NOT NOT BETWEEN: double NOT on BETWEEN should cancel out
+-- Equivalent to a BETWEEN 20 AND 30
+select id from norm where not not (a between 20 and 30) order by id;
+→ [{"id":2},{"id":3}]
+
+-- =============================================================================
+-- De Morgan with nested OR-to-IN
+-- =============================================================================
+
+-- NOT (a = 10 AND b = 100): De Morgan → a != 10 OR b != 100
+-- id=1: a=10,b=100 → false; id=2: a≠10 → true; id=3: a≠10 → true; id=4: b≠100 → true; id=5: a≠10 → true
+select id from norm where not (a = 10 and b = 100) order by id;
+→ [{"id":2},{"id":3},{"id":4},{"id":5}]
+
+-- =============================================================================
+-- Mixed operand order with more values
+-- =============================================================================
+
+-- Alternating lit=col and col=lit patterns
+-- id=1: 10=a; id=2: a=20; id=5: 50=a
+select id from norm where 10 = a or a = 20 or 50 = a order by id;
+→ [{"id":1},{"id":2},{"id":5}]
+
+-- =============================================================================
+-- Cleanup
+-- =============================================================================
+
+drop table norm;

package/test/logic/100.1-where-extras.sqllogic

@@ -0,0 +1,163 @@
+-- where-extras.sqllogic - WHERE-clause shapes not exercised by 100-predicate-normalization
+-- Distilled from SQLite test/where.test, where4.test, where7.test, where8.test, where9.test
+
+create table we (id integer primary key, a integer null, b integer null, c integer null);
+insert into we values
+  (1, 10, 100, 1),
+  (2, 20, 200, 2),
+  (3, 30, 300, 3),
+  (4, 40, 400, 4),
+  (5, 50, 500, 5),
+  (6, null, null, null);
+
+-- =============================================================================
+-- Constant WHERE: short-circuit always-true / always-false predicates
+-- =============================================================================
+
+select count(*) as cnt from we where 1;
+→ [{"cnt":6}]
+
+select count(*) as cnt from we where 0;
+→ [{"cnt":0}]
+
+select count(*) as cnt from we where true;
+→ [{"cnt":6}]
+
+select count(*) as cnt from we where false;
+→ [{"cnt":0}]
+
+select count(*) as cnt from we where 1 = 1;
+→ [{"cnt":6}]
+
+select count(*) as cnt from we where 1 = 0;
+→ [{"cnt":0}]
+
+-- Constant comparison combined with column predicate
+select id from we where 1 = 1 and a > 30 order by id;
+→ [{"id":4},{"id":5}]
+
+select id from we where 1 = 0 or a = 10 order by id;
+→ [{"id":1}]
+
+-- =============================================================================
+-- AND combined with multi-branch OR (x AND (y OR z))
+-- =============================================================================
+
+select id from we where a > 15 and (b = 200 or b = 400) order by id;
+→ [{"id":2},{"id":4}]
+
+select id from we where a > 15 and (b = 200 or c >= 4) order by id;
+→ [{"id":2},{"id":4},{"id":5}]
+
+-- (x OR y) AND z: distributes correctly
+select id from we where (a = 10 or a = 30) and b > 50 order by id;
+→ [{"id":1},{"id":3}]
+
+-- =============================================================================
+-- Composite OR over (a AND b) tuples
+-- =============================================================================
+
+select id from we where (a = 10 and b = 100) or (a = 30 and b = 300) order by id;
+→ [{"id":1},{"id":3}]
+
+-- Tuple OR where one disjunct fails the b test
+select id from we where (a = 10 and b = 999) or (a = 30 and b = 300) order by id;
+→ [{"id":3}]
+
+-- =============================================================================
+-- Multi-range OR (BETWEEN inside OR)
+-- =============================================================================
+
+select id from we where a between 10 and 20 or a between 40 and 50 order by id;
+→ [{"id":1},{"id":2},{"id":4},{"id":5}]
+
+select id from we where (a between 10 and 20) or (b between 300 and 400) order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- BETWEEN inside OR mixed with equality
+select id from we where a = 50 or a between 15 and 25 order by id;
+→ [{"id":2},{"id":5}]
+
+-- =============================================================================
+-- Three-column AND/OR composite
+-- =============================================================================
+
+select id from we where a > 10 and (b = 100 or b = 200 or c >= 4) order by id;
+→ [{"id":2},{"id":4},{"id":5}]
+
+select id from we where a > 10 and (b > 250 and c < 5) order by id;
+→ [{"id":3},{"id":4}]
+
+-- =============================================================================
+-- OR with IS NULL: non-null disjunct wins, null rows kept via IS NULL
+-- =============================================================================
+
+select id from we where a > 25 or a is null order by id;
+→ [{"id":3},{"id":4},{"id":5},{"id":6}]
+
+-- IS NULL combined with AND
+select id from we where a is null or (b > 100 and c < 4) order by id;
+→ [{"id":2},{"id":3},{"id":6}]
+
+-- =============================================================================
+-- IN list deduplication: duplicate values produce no duplicate rows
+-- =============================================================================
+
+select id from we where a in (10, 10, 30, 30, 30) order by id;
+→ [{"id":1},{"id":3}]
+
+-- =============================================================================
+-- Reordered ON-clause conjunction equivalence (LEFT JOIN)
+-- =============================================================================
+
+create table wj_l (id integer primary key, k integer);
+create table wj_r (id integer primary key, k integer, tag integer);
+insert into wj_l values (1, 1), (2, 2);
+insert into wj_r values (10, 1, 1), (20, 1, 3), (30, 2, 1), (40, 2, 3);
+
+-- ON term order should not affect result
+select wj_l.id as lid, wj_r.id as rid from wj_l left join wj_r on wj_l.k = wj_r.k and wj_r.tag = 1 order by lid, rid;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":30}]
+
+select wj_l.id as lid, wj_r.id as rid from wj_l left join wj_r on wj_r.tag = 1 and wj_r.k = wj_l.k order by lid, rid;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":30}]
+
+-- The indexed variant of this equivalence (an index on the ON columns must not
+-- change the answer) lives in 100.1.1-where-join-on-order-indexed.
+
+drop table wj_l;
+drop table wj_r;
+
+drop table we;
+
+-- =============================================================================
+-- same-table column-column equality: must not crash (regression: seek crash)
+-- A col = same_col predicate is a per-row filter, never a seek key.
+-- =============================================================================
+
+create table samecolpk (b text primary key, c text);
+insert into samecolpk values ('u', 'u'), ('v', 'w'), ('x', 'x');
+
+-- simple PK: matching rows returned, no crash
+select b from samecolpk where b = c order by b;
+→ [{"b":"u"},{"b":"x"}]
+
+-- with inequality too
+select b from samecolpk where b = c and c != 'x';
+→ [{"b":"u"}]
+
+drop table samecolpk;
+
+-- composite PK: b=c with the other key column pinned must not crash
+create table samecolcomp (b text, c text, x integer, primary key (b, x));
+insert into samecolcomp values ('u','u',1), ('u','u',2), ('v','v',1), ('w','v',1);
+
+-- both pk columns specified but b=c is still a per-row filter
+select b, c, x from samecolcomp where b = c and x = 1 order by b;
+→ [{"b":"u","c":"u","x":1},{"b":"v","c":"v","x":1}]
+
+-- without x pin: b=c alone as filter
+select b, c, x from samecolcomp where b = c order by b, x;
+→ [{"b":"u","c":"u","x":1},{"b":"u","c":"u","x":2},{"b":"v","c":"v","x":1}]
+
+drop table samecolcomp;

package/test/logic/100.1.1-where-join-on-order-indexed.sqllogic

@@ -0,0 +1,35 @@
+-- 100.1.1-where-join-on-order-indexed.sqllogic
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 100.1-where-extras: that file's subject is WHERE-predicate shapes,
+-- and its reordered-ON-clause section already proves term-order equivalence without
+-- any index. The one create/drop index pair below is a robustness check — "an index
+-- on the ON columns must not change the answer" — not index behavior, so it moves
+-- here rather than making the whole WHERE file unrunnable on a backend without
+-- first-class CREATE INDEX.
+--
+-- Subject: a LEFT JOIN whose ON conjunction can be served by a composite index on
+-- the right-hand table returns the same rows as the unindexed plan.
+
+create table wj_l (id integer primary key, k integer);
+create table wj_r (id integer primary key, k integer, tag integer);
+insert into wj_l values (1, 1), (2, 2);
+insert into wj_r values (10, 1, 1), (20, 1, 3), (30, 2, 1), (40, 2, 3);
+
+-- Baseline: unindexed, both ON term orders.
+select wj_l.id as lid, wj_r.id as rid from wj_l left join wj_r on wj_l.k = wj_r.k and wj_r.tag = 1 order by lid, rid;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":30}]
+
+-- Index presence on the ON columns must not change results
+create index wj_r_k_tag on wj_r(k, tag);
+
+select wj_l.id as lid, wj_r.id as rid from wj_l left join wj_r on wj_l.k = wj_r.k and wj_r.tag = 1 order by lid, rid;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":30}]
+
+select wj_l.id as lid, wj_r.id as rid from wj_l left join wj_r on wj_r.tag = 1 and wj_r.k = wj_l.k order by lid, rid;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":30}]
+
+drop index wj_r_k_tag;
+drop table wj_l;
+drop table wj_r;