@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/21-null-edge-cases.sqllogic

@@ -0,0 +1,227 @@
+-- null-edge-cases.sqllogic - Systematic NULL behavior tests across SQL positions
+
+-- =============================================================================
+-- Setup
+-- =============================================================================
+
+create table n1 (id integer primary key, val integer null, txt text null);
+insert into n1 values (1, 10, 'a'), (2, null, 'b'), (3, 30, null), (4, null, null);
+
+-- =============================================================================
+-- NULL in join keys
+-- =============================================================================
+
+create table n2 (id integer primary key, ref integer null);
+insert into n2 values (1, 10), (2, null), (3, 30);
+
+-- INNER JOIN: NULL keys should NOT match
+select n1.id, n1.val, n2.id, n2.ref from n1 inner join n2 on n1.val = n2.ref order by n1.id;
+→ [{"id":1,"val":10,"id:1":1,"ref":10},{"id":3,"val":30,"id:1":3,"ref":30}]
+
+-- LEFT JOIN: rows with null val get null on right side
+select n1.id, n1.val, n2.id, n2.ref from n1 left join n2 on n1.val = n2.ref order by n1.id;
+→ [{"id":1,"val":10,"id:1":1,"ref":10},{"id":2,"val":null,"id:1":null,"ref":null},{"id":3,"val":30,"id:1":3,"ref":30},{"id":4,"val":null,"id:1":null,"ref":null}]
+
+-- Both sides NULL: verify NULLs don't join (NULL ≠ NULL)
+select count(*) as cnt from n1 inner join n2 on n1.val = n2.ref;
+→ [{"cnt":2}]
+
+drop table n2;
+
+-- =============================================================================
+-- NULL in GROUP BY key
+-- =============================================================================
+
+-- NULLs grouped together into one group (NULLs first in default ordering)
+select val, count(*) as cnt from n1 group by val order by val;
+→ [{"val":null,"cnt":2},{"val":10,"cnt":1},{"val":30,"cnt":1}]
+
+-- =============================================================================
+-- NULL in ORDER BY
+-- =============================================================================
+
+-- Default ASC: NULLs come first
+select id, val from n1 order by val, id;
+→ [{"id":2,"val":null},{"id":4,"val":null},{"id":1,"val":10},{"id":3,"val":30}]
+
+-- NULLS FIRST explicit (same as default ASC)
+select id, val from n1 order by val nulls first, id;
+→ [{"id":2,"val":null},{"id":4,"val":null},{"id":1,"val":10},{"id":3,"val":30}]
+
+-- NULLS LAST moves NULLs to end
+select id, val from n1 order by val nulls last, id;
+→ [{"id":1,"val":10},{"id":3,"val":30},{"id":2,"val":null},{"id":4,"val":null}]
+
+-- DESC with NULLS FIRST on text column
+select id, txt from n1 order by txt desc nulls first, id;
+→ [{"id":3,"txt":null},{"id":4,"txt":null},{"id":2,"txt":"b"},{"id":1,"txt":"a"}]
+
+-- DESC with NULLS LAST moves NULLs to end
+select id, val from n1 order by val desc nulls last, id;
+→ [{"id":3,"val":30},{"id":1,"val":10},{"id":2,"val":null},{"id":4,"val":null}]
+
+-- DESC with NULLS LAST on text column
+select id, txt from n1 order by txt desc nulls last, id;
+→ [{"id":2,"txt":"b"},{"id":1,"txt":"a"},{"id":3,"txt":null},{"id":4,"txt":null}]
+
+-- =============================================================================
+-- NULL in CASE WHEN
+-- =============================================================================
+
+-- NULL condition is falsy → else branch
+select case when null then 'yes' else 'no' end as r;
+→ [{"r":"no"}]
+
+-- IS NULL in CASE WHEN
+select id, case when val is null then 'missing' else 'present' end as status from n1 order by id;
+→ [{"id":1,"status":"present"},{"id":2,"status":"missing"},{"id":3,"status":"present"},{"id":4,"status":"missing"}]
+
+-- Simple CASE: NULL ≠ NULL so 'no match'
+select case null when null then 'match' else 'no match' end as r;
+→ [{"r":"no match"}]
+
+-- CASE with NULL result branch
+select id, case when id = 2 then null else val end as r from n1 order by id;
+→ [{"id":1,"r":10},{"id":2,"r":null},{"id":3,"r":30},{"id":4,"r":null}]
+
+-- =============================================================================
+-- NULL in IN list and as IN operand
+-- =============================================================================
+
+-- NULL in IN list doesn't match NULL vals; only exact matches
+select id, val from n1 where val in (10, null, 30) order by id;
+→ [{"id":1,"val":10},{"id":3,"val":30}]
+
+-- NOT IN with NULL in list: returns no rows
+-- val NOT IN (10, NULL) → val<>10 AND val<>NULL → unknown for all non-10 values
+select id, val from n1 where val not in (10, null) order by id;
+→ []
+
+-- NULL as IN operand: always unknown
+select * from n1 where null in (1, 2, 3);
+→ []
+
+-- =============================================================================
+-- NULL in aggregate arguments
+-- =============================================================================
+
+-- count(col) skips NULLs
+select count(val) as cnt from n1;
+→ [{"cnt":2}]
+
+-- count(*) counts all rows
+select count(*) as cnt from n1;
+→ [{"cnt":4}]
+
+-- sum skips NULLs
+select sum(val) as s from n1;
+→ [{"s":40}]
+
+-- avg skips NULLs (40/2 = 20)
+select avg(val) as a from n1;
+→ [{"a":20}]
+
+-- min skips NULLs
+select min(val) as mn from n1;
+→ [{"mn":10}]
+
+-- max skips NULLs
+select max(val) as mx from n1;
+→ [{"mx":30}]
+
+-- group_concat skips NULLs
+select group_concat(txt, ',') as g from n1;
+→ [{"g":"a,b"}]
+
+-- =============================================================================
+-- NULL in window functions
+-- =============================================================================
+
+-- PARTITION BY groups NULLs together
+select id, val, row_number() over (partition by val order by id) as rn from n1 order by id;
+→ [{"id":1,"val":10,"rn":1},{"id":2,"val":null,"rn":1},{"id":3,"val":30,"rn":1},{"id":4,"val":null,"rn":2}]
+
+-- RANK with NULLs: null vals get same rank
+select id, val, rank() over (order by val) as rnk from n1 order by id;
+→ [{"id":1,"val":10,"rnk":3},{"id":2,"val":null,"rnk":1},{"id":3,"val":30,"rnk":4},{"id":4,"val":null,"rnk":1}]
+
+-- =============================================================================
+-- NULL in COALESCE chains
+-- =============================================================================
+
+select coalesce(null) as r;
+→ [{"r":null}]
+
+select coalesce(null, null, null) as r;
+→ [{"r":null}]
+
+select coalesce(null, null, 'found') as r;
+→ [{"r":"found"}]
+
+-- Per-row cascade: first non-null wins
+select id, coalesce(val, txt, 'default') as r from n1 order by id;
+→ [{"id":1,"r":10},{"id":2,"r":"b"},{"id":3,"r":30},{"id":4,"r":"default"}]
+
+-- =============================================================================
+-- NULL with every comparison operator
+-- =============================================================================
+
+select null = null as r;
+→ [{"r":null}]
+
+select null <> null as r;
+→ [{"r":null}]
+
+select null < 1 as r;
+→ [{"r":null}]
+
+select null > 1 as r;
+→ [{"r":null}]
+
+select null <= 1 as r;
+→ [{"r":null}]
+
+select null >= 1 as r;
+→ [{"r":null}]
+
+select null is null as r;
+→ [{"r":true}]
+
+select null is not null as r;
+→ [{"r":false}]
+
+select 1 is null as r;
+→ [{"r":false}]
+
+select 1 is not null as r;
+→ [{"r":true}]
+
+-- =============================================================================
+-- NULL in DISTINCT
+-- =============================================================================
+
+-- NULLs are equal for DISTINCT: only one NULL in output
+select distinct val from n1 order by val;
+→ [{"val":null},{"val":10},{"val":30}]
+
+-- =============================================================================
+-- NULL in subqueries
+-- =============================================================================
+
+-- EXISTS with subquery returning null row: true (row exists, value doesn't matter)
+select exists (select null) as r;
+→ [{"r":true}]
+
+-- Scalar subquery returning null
+select (select null) as r;
+→ [{"r":null}]
+
+-- IN with null subquery result: unknown
+select 1 in (select null) as r;
+→ [{"r":null}]
+
+-- =============================================================================
+-- Cleanup
+-- =============================================================================
+
+drop table n1;

package/test/logic/21.1-where-null-comparisons.sqllogic

@@ -0,0 +1,151 @@
+-- where-null-comparisons.sqllogic - WHERE-clause three-valued logic for NULL operands
+-- Distilled from SQLite test/where5.test and test/null.test
+
+create table wn (id integer primary key, val integer null, txt text null);
+insert into wn values (1, 10, 'a'), (2, null, 'b'), (3, 30, null), (4, null, null);
+
+-- =============================================================================
+-- col <op> NULL is unknown -> WHERE filters out all rows
+-- =============================================================================
+
+select id from wn where val = null order by id;
+→ []
+
+select id from wn where val != null order by id;
+→ []
+
+select id from wn where val <> null order by id;
+→ []
+
+select id from wn where val < null order by id;
+→ []
+
+select id from wn where val <= null order by id;
+→ []
+
+select id from wn where val > null order by id;
+→ []
+
+select id from wn where val >= null order by id;
+→ []
+
+select id from wn where txt = null order by id;
+→ []
+
+-- =============================================================================
+-- NULL <op> col / NULL <op> NULL is unknown -> no rows
+-- =============================================================================
+
+select id from wn where null = val order by id;
+→ []
+
+select id from wn where null < val order by id;
+→ []
+
+select id from wn where null = null order by id;
+→ []
+
+select id from wn where null != null order by id;
+→ []
+
+-- Bare NULL in WHERE is falsy
+select id from wn where null order by id;
+→ []
+
+-- NOT NULL in WHERE is also unknown -> no rows
+select id from wn where not null order by id;
+→ []
+
+-- =============================================================================
+-- Arithmetic propagating NULL into a comparison
+-- =============================================================================
+
+select id from wn where val + null > 5 order by id;
+→ []
+
+select id from wn where val + null is null order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+select id from wn where (val * 0) = null order by id;
+→ []
+
+-- =============================================================================
+-- NOT around a NULL-producing comparison stays unknown
+-- =============================================================================
+
+select id from wn where not (val = null) order by id;
+→ []
+
+select id from wn where not (val < null) order by id;
+→ []
+
+select id from wn where not (val + null > 5) order by id;
+→ []
+
+-- =============================================================================
+-- IS / IS NOT are null-safe and produce TRUE/FALSE, never NULL
+-- =============================================================================
+
+select id from wn where val is null order by id;
+→ [{"id":2},{"id":4}]
+
+select id from wn where val is not null order by id;
+→ [{"id":1},{"id":3}]
+
+-- (Quereus parser restricts IS to IS NULL / IS NOT NULL — null-safe equality form not supported)
+
+-- IS NULL inside a NOT is still TRUE/FALSE
+select id from wn where not (val is null) order by id;
+→ [{"id":1},{"id":3}]
+
+select id from wn where not (val is not null) order by id;
+→ [{"id":2},{"id":4}]
+
+-- =============================================================================
+-- Compound with AND/OR: unknown short-circuits AND but not OR-with-true
+-- =============================================================================
+
+-- val > 5 AND val = NULL: AND of (true|null) and unknown -> all unknown
+select id from wn where val > 5 and val = null order by id;
+→ []
+
+-- val > 5 OR val = NULL: OR of (true|null) and unknown -> id=1,3 keep true; id=2,4 stay null
+select id from wn where val > 5 or val = null order by id;
+→ [{"id":1},{"id":3}]
+
+-- TRUE OR unknown -> TRUE: id=1 wins via val=10; rest stay unknown
+select id from wn where val = 10 or val = null order by id;
+→ [{"id":1}]
+
+-- =============================================================================
+-- NULL comparisons against key columns must not become seek bounds
+-- (key ordering sorts NULL below everything, so a pushed `> NULL` lower bound
+-- would wrongly match every row)
+-- =============================================================================
+
+select id from wn where id > null order by id;
+→ []
+
+select id from wn where null < id order by id;
+→ []
+
+select id from wn where id >= null order by id;
+→ []
+
+select id from wn where id between null and 3 order by id;
+→ []
+
+select id from wn where id between 1 and null order by id;
+→ []
+
+select id from wn where (+ null) < id order by id;
+→ []
+
+-- Sanity: non-NULL bounds on the same column still seek correctly
+select id from wn where id > 3 order by id;
+→ [{"id":4}]
+
+-- The same assertions against a SECONDARY-INDEXED column live in
+-- 21.1.1-where-null-comparisons-secondary-index (they need standalone CREATE INDEX).
+
+drop table wn;

package/test/logic/21.1.1-where-null-comparisons-secondary-index.sqllogic

@@ -0,0 +1,35 @@
+-- 21.1.1-where-null-comparisons-secondary-index.sqllogic
+--
+-- requires-capability: standalone-index-ddl
+--
+-- Carved out of 21.1-where-null-comparisons: that file's three-valued-logic
+-- coverage, including "a NULL bound must not become a seek bound", is already
+-- made against the PRIMARY KEY column with no index DDL. This section repeats the
+-- same assertions one level down, on a column reachable only through a standalone
+-- secondary index, so it moves here instead of costing a backend without
+-- first-class CREATE INDEX the whole NULL-comparison file.
+--
+-- Subject: a NULL comparison against a SECONDARY-INDEXED column must not be pushed
+-- down as a seek bound either (key ordering sorts NULL below everything, so a
+-- pushed `> NULL` lower bound would wrongly match every row).
+
+create table wn (id integer primary key, val integer null, txt text null);
+insert into wn values (1, 10, 'a'), (2, null, 'b'), (3, 30, null), (4, null, null);
+
+create index wn_val on wn (val);
+
+select id from wn where val > null order by id;
+→ []
+
+select id from wn where null < val order by id;
+→ []
+
+select id from wn where val between null and 30 order by id;
+→ []
+
+-- Sanity: non-NULL bounds on the same column still seek correctly
+select id from wn where val between 10 and 30 order by id;
+→ [{"id":1},{"id":3}]
+
+drop index wn_val;
+drop table wn;

package/test/logic/21.2-between-edges.sqllogic

@@ -0,0 +1,157 @@
+-- between-edges.sqllogic - BETWEEN edge cases beyond the basic operator
+-- Distilled from SQLite test/between.test
+
+create table bt (id integer primary key, val integer null, lo integer null, hi integer null);
+insert into bt values
+  (1, 5, 1, 10),
+  (2, 15, 5, 12),
+  (3, 8, null, 10),
+  (4, 8, 5, null),
+  (5, null, 1, 10),
+  (6, 25, 30, 20);
+
+-- =============================================================================
+-- Basic NULL propagation in BETWEEN operands (in WHERE: filters out)
+-- =============================================================================
+
+-- value is NULL -> unknown -> no row
+select id from bt where val between 1 and 100 order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":6}]
+
+-- lower bound is NULL: row 3 (val=8, lo=null, hi=10): 8 BETWEEN null AND 10 -> unknown
+-- row 2 (val=15, lo=5, hi=12): 15 between 5 and 12 -> false
+-- row 6 (val=25, lo=30, hi=20): reversed bounds -> false
+select id from bt where val between lo and hi order by id;
+→ [{"id":1}]
+
+-- upper bound is NULL alone, value satisfies low side:
+-- 8 BETWEEN 5 AND null -> unknown -> excluded
+select id from bt where id = 4 and val between lo and hi;
+→ []
+
+-- =============================================================================
+-- BETWEEN as a SELECT expression: NULL in any operand returns NULL
+-- =============================================================================
+
+select null between 1 and 10 as r;
+→ [{"r":null}]
+
+select 5 between null and 10 as r;
+→ [{"r":null}]
+
+select 5 between 1 and null as r;
+→ [{"r":null}]
+
+select 50 between 1 and null as r;
+→ [{"r":null}]
+
+select null between null and null as r;
+→ [{"r":null}]
+
+-- =============================================================================
+-- Reversed bounds (lower > upper): always false, never matches
+-- =============================================================================
+
+select id from bt where val between 10 and 5;
+→ []
+
+select 5 between 10 and 1 as r;
+→ [{"r":false}]
+
+-- NOT BETWEEN with reversed bounds: rows with non-null val all qualify (NOT false = true);
+-- rows with null val stay unknown
+select id from bt where val not between 10 and 5 order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":6}]
+
+-- BETWEEN against column-stored reversed bounds (id=6 has lo=30, hi=20)
+select id from bt where id = 6 and val between lo and hi;
+→ []
+
+-- =============================================================================
+-- NOT BETWEEN preserves unknown for NULL operands
+-- =============================================================================
+
+-- Row 5 has val=null: NOT (null between 1 and 10) -> NOT unknown -> unknown -> excluded
+select id from bt where val not between 1 and 10 order by id;
+→ [{"id":2},{"id":6}]
+
+select null not between 1 and 10 as r;
+→ [{"r":null}]
+
+-- =============================================================================
+-- Expression bounds (arithmetic in lower / upper / both)
+-- =============================================================================
+
+create table bx (id integer primary key, x integer, a integer, b integer);
+insert into bx values (1, 5, 2, 10), (2, 15, 8, 12), (3, 22, 3, 30);
+
+select id from bx where x between a + 1 and 100 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+select id from bx where x between 0 and b * 2 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+select id from bx where x between a + 3 and b * 2 order by id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- LHS is also an expression
+select id from bx where (x - 5) between a and b order by id;
+→ [{"id":2},{"id":3}]
+
+drop table bx;
+
+-- =============================================================================
+-- BETWEEN with TEXT operands and lexicographic ordering
+-- =============================================================================
+
+create table bs (id integer primary key, s text null);
+insert into bs values (1, 'apple'), (2, 'mango'), (3, 'zebra'), (4, null);
+
+select id from bs where s between 'banana' and 'orange' order by id;
+→ [{"id":2}]
+
+select id from bs where s not between 'banana' and 'orange' order by id;
+→ [{"id":1},{"id":3}]
+
+-- Reversed lexicographic bounds: empty
+select id from bs where s between 'z' and 'a' order by id;
+→ []
+
+drop table bs;
+
+-- =============================================================================
+-- BETWEEN inside HAVING and CASE
+-- =============================================================================
+
+create table bg (id integer primary key, grp text, n integer);
+insert into bg values (1, 'a', 2), (2, 'a', 4), (3, 'b', 7), (4, 'b', 9), (5, 'c', 1);
+
+select grp, sum(n) as s from bg group by grp having sum(n) between 5 and 10 order by grp;
+→ [{"grp":"a","s":6}]
+
+select id, case when n between 3 and 8 then 'mid' else 'edge' end as bucket from bg order by id;
+→ [{"id":1,"bucket":"edge"},{"id":2,"bucket":"mid"},{"id":3,"bucket":"mid"},{"id":4,"bucket":"edge"},{"id":5,"bucket":"edge"}]
+
+drop table bg;
+
+-- =============================================================================
+-- BETWEEN in JOIN ON clause (range join)
+-- =============================================================================
+
+create table bj_l (id integer primary key, x integer);
+create table bj_r (id integer primary key, lo integer, hi integer, tag text);
+insert into bj_l values (1, 5), (2, 15), (3, 25);
+insert into bj_r values (10, 1, 10, 'low'), (20, 11, 20, 'mid'), (30, 21, 30, 'high');
+
+select bj_l.id as lid, bj_r.tag from bj_l join bj_r on bj_l.x between bj_r.lo and bj_r.hi order by lid;
+→ [{"lid":1,"tag":"low"},{"lid":2,"tag":"mid"},{"lid":3,"tag":"high"}]
+
+-- LEFT JOIN with BETWEEN ON clause: unmatched left rows preserved
+insert into bj_l values (4, 100);
+select bj_l.id as lid, bj_r.tag from bj_l left join bj_r on bj_l.x between bj_r.lo and bj_r.hi order by lid;
+→ [{"lid":1,"tag":"low"},{"lid":2,"tag":"mid"},{"lid":3,"tag":"high"},{"lid":4,"tag":null}]
+
+drop table bj_l;
+drop table bj_r;
+
+drop table bt;