@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/90.3-expression-errors.sqllogic

@@ -0,0 +1,43 @@
+-- 90.3-expression-errors.sqllogic - Expression, subquery, and aggregate error paths
+
+-- Scalar subquery with multiple columns
+SELECT (SELECT 1, 2);
+-- error: Scalar subquery must return exactly one column
+
+-- IN subquery with multiple columns
+SELECT 1 WHERE 1 IN (SELECT 1, 2);
+-- error: IN subquery must return exactly one column
+
+-- Duplicate CTE name
+WITH c AS (SELECT 1 AS x), c AS (SELECT 2 AS x) SELECT * FROM c;
+-- error: Duplicate CTE name 'c' in WITH clause
+
+-- Aggregate function in WHERE clause
+CREATE TABLE t_agg_ctx (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO t_agg_ctx VALUES (1, 10), (2, 20);
+-- run
+
+SELECT * FROM t_agg_ctx WHERE count(*) > 1;
+-- error: not allowed in this context
+
+-- Window function requiring ORDER BY
+SELECT rank() OVER () FROM t_agg_ctx;
+-- error: requires ORDER BY clause
+
+-- OLD qualifier in INSERT RETURNING
+INSERT INTO t_agg_ctx VALUES (3, 30) RETURNING OLD.id;
+-- error: OLD qualifier cannot be used in INSERT RETURNING clause
+
+-- Cleanup
+DROP TABLE t_agg_ctx;
+-- run
+
+-- NEW qualifier in DELETE RETURNING
+CREATE TABLE t_del_ret (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO t_del_ret VALUES (1, 10);
+-- run
+
+DELETE FROM t_del_ret WHERE id = 1 RETURNING NEW.id;
+-- error: NEW qualifier cannot be used in DELETE RETURNING clause
+
+DROP TABLE t_del_ret;

package/test/logic/90.4-dml-errors.sqllogic

@@ -0,0 +1,47 @@
+-- 90.4-dml-errors.sqllogic - DML error paths (INSERT, UPDATE, DELETE edge cases)
+
+-- VALUES clause column count mismatch (fewer values than columns)
+CREATE TABLE t_vals (a INTEGER, b INTEGER, c INTEGER);
+-- run
+
+INSERT INTO t_vals VALUES (1, 2);
+-- error: Column count mismatch
+
+-- VALUES clause column count mismatch (more values than columns)
+INSERT INTO t_vals VALUES (1, 2, 3, 4);
+-- error: Column count mismatch
+
+DROP TABLE t_vals;
+-- run
+
+-- INSERT with explicit column referencing non-existent column
+CREATE TABLE t_insert_col (id INTEGER PRIMARY KEY, name TEXT);
+-- run
+
+INSERT INTO t_insert_col (id, missing_col) VALUES (1, 'x');
+-- error: not found
+
+DROP TABLE t_insert_col;
+-- run
+
+-- ON CONFLICT target with non-existent column
+CREATE TABLE t_upsert_bad (id INTEGER PRIMARY KEY, val INTEGER);
+-- run
+
+INSERT INTO t_upsert_bad (id, val) VALUES (1, 10) ON CONFLICT (missing_col) DO NOTHING;
+-- error: not found
+
+DROP TABLE t_upsert_bad;
+-- run
+
+-- Mutating subquery without RETURNING clause
+CREATE TABLE t_mut_src (id INTEGER PRIMARY KEY, val INTEGER);
+CREATE TABLE t_mut_dst (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO t_mut_src VALUES (1, 10);
+-- run
+
+INSERT INTO t_mut_dst SELECT * FROM (DELETE FROM t_mut_src WHERE id = 1);
+-- error: must have a RETURNING clause
+
+DROP TABLE t_mut_src;
+DROP TABLE t_mut_dst;

package/test/logic/90.5-unsupported-join-types.sqllogic

@@ -0,0 +1,37 @@
+-- adapted from SQLite test/join.test, join7.test, joinB.test, joinH.test
+-- RIGHT [OUTER] JOIN and FULL [OUTER] JOIN now execute in the nested-loop join
+-- emitter (read path). NATURAL JOIN remains unparsed and is pinned as an error.
+
+create table uj_l (id integer primary key, val text);
+create table uj_r (id integer primary key, val text);
+
+insert into uj_l values (1, 'L1'), (2, 'L2');
+insert into uj_r values (1, 'R1'), (3, 'R3');
+-- run
+
+-- RIGHT JOIN: every right row appears; right id=3 has no left match → null-left.
+select uj_l.id as l, uj_r.id as r from uj_l right join uj_r on uj_l.id = uj_r.id order by uj_r.id;
+→ [{"l":1,"r":1},{"l":null,"r":3}]
+
+-- RIGHT OUTER JOIN: same path, same rows.
+select uj_l.id as l, uj_r.id as r from uj_l right outer join uj_r on uj_l.id = uj_r.id order by uj_r.id;
+→ [{"l":1,"r":1},{"l":null,"r":3}]
+
+-- FULL OUTER JOIN: matched (1,1), left id=2 unmatched (2,NULL), right id=3 unmatched (NULL,3).
+select uj_l.id as l, uj_r.id as r from uj_l full outer join uj_r on uj_l.id = uj_r.id order by coalesce(uj_l.id, uj_r.id);
+→ [{"l":1,"r":1},{"l":2,"r":null},{"l":null,"r":3}]
+
+-- FULL JOIN (no OUTER keyword): same path, same rows.
+select uj_l.id as l, uj_r.id as r from uj_l full join uj_r on uj_l.id = uj_r.id order by coalesce(uj_l.id, uj_r.id);
+→ [{"l":1,"r":1},{"l":2,"r":null},{"l":null,"r":3}]
+
+-- NATURAL JOIN: still not parsed (out of scope for this ticket).
+select * from uj_l natural join uj_r;
+-- error: NATURAL
+
+-- NATURAL LEFT JOIN: still not parsed.
+select * from uj_l natural left join uj_r;
+-- error: NATURAL
+
+drop table uj_l;
+drop table uj_r;

package/test/logic/90.5.1-right-full-join-read.sqllogic

@@ -0,0 +1,157 @@
+-- Read-path coverage for RIGHT / FULL outer joins in the nested-loop emitter
+-- (runtime/emit/join.ts). Companion to 90.5, which flips the basic RIGHT/FULL
+-- cases; this file pins column order, the empty-side matrix, no-match, many-to-many
+-- (fan-out), USING, and existence (`exists … as`) flag semantics.
+
+-- ===== select * column order: left columns first, then right columns =====
+-- `a right/full join b` returns `a.*` then `b.*` (the JoinNode attribute order),
+-- not the scan/drive order. Distinct column names avoid `:N` disambiguation so the
+-- per-name values directly confirm left attrs occupy the left positions.
+
+create table so_l (lid integer primary key, lval text);
+create table so_r (rid integer primary key, rval text);
+insert into so_l values (1, 'L1'), (2, 'L2');
+insert into so_r values (1, 'R1'), (3, 'R3');
+-- run
+
+-- RIGHT: matched (1) plus right id=3 null-extended on the left.
+select * from so_l right join so_r on so_l.lid = so_r.rid order by so_r.rid;
+→ [{"lid":1,"lval":"L1","rid":1,"rval":"R1"},{"lid":null,"lval":null,"rid":3,"rval":"R3"}]
+
+-- FULL: matched (1), left id=2 null-right, right id=3 null-left.
+select * from so_l full join so_r on so_l.lid = so_r.rid order by coalesce(so_l.lid, so_r.rid);
+→ [{"lid":1,"lval":"L1","rid":1,"rval":"R1"},{"lid":2,"lval":"L2","rid":null,"rval":null},{"lid":null,"lval":null,"rid":3,"rval":"R3"}]
+
+drop table so_l;
+drop table so_r;
+-- run
+
+-- ===== Empty-side matrix =====
+
+create table es_full (k integer primary key, v text);
+create table es_empty (k integer primary key, v text);
+create table es_empty2 (k integer primary key, v text);
+insert into es_full values (1, 'a'), (2, 'b');
+-- run
+
+-- left empty + RIGHT: every right row appears, null-extended on the left.
+select es_empty.k as lk, es_full.k as rk from es_empty right join es_full on es_empty.k = es_full.k order by es_full.k;
+→ [{"lk":null,"rk":1},{"lk":null,"rk":2}]
+
+-- right empty + RIGHT: no rows at all.
+select es_full.k as lk, es_empty.k as rk from es_full right join es_empty on es_full.k = es_empty.k order by es_empty.k;
+→ []
+
+-- both empty + FULL: no rows.
+select a.k as lk, b.k as rk from es_empty a full join es_empty2 b on a.k = b.k;
+→ []
+
+-- left non-empty + right empty + FULL: every left row null-extended on the right (trailing pass only).
+select es_full.k as lk, es_empty.k as rk from es_full full join es_empty on es_full.k = es_empty.k order by es_full.k;
+→ [{"lk":1,"rk":null},{"lk":2,"rk":null}]
+
+-- left empty + FULL: every right row null-extended on the left (no trailing rows).
+select es_empty.k as lk, es_full.k as rk from es_empty full join es_full on es_empty.k = es_full.k order by es_full.k;
+→ [{"lk":null,"rk":1},{"lk":null,"rk":2}]
+
+drop table es_full;
+drop table es_empty;
+drop table es_empty2;
+-- run
+
+-- ===== No match at all =====
+
+create table nm_l (id integer primary key);
+create table nm_r (id integer primary key);
+insert into nm_l values (1), (2);
+insert into nm_r values (3), (4);
+-- run
+
+-- RIGHT, predicate matches nothing: all right rows null-left.
+select nm_l.id as l, nm_r.id as r from nm_l right join nm_r on nm_l.id = nm_r.id order by nm_r.id;
+→ [{"l":null,"r":3},{"l":null,"r":4}]
+
+-- FULL, predicate matches nothing: all right null-left AND all left null-right.
+select nm_l.id as l, nm_r.id as r from nm_l full join nm_r on nm_l.id = nm_r.id order by coalesce(nm_l.id, nm_r.id);
+→ [{"l":1,"r":null},{"l":2,"r":null},{"l":null,"r":3},{"l":null,"r":4}]
+
+drop table nm_l;
+drop table nm_r;
+-- run
+
+-- ===== Many-to-many (duplicate join keys): one row per match, no spurious null-extension =====
+
+create table mm_l (id integer primary key, k integer);
+create table mm_r (id integer primary key, k integer);
+-- k=1 twice on each side; k=2 only on right; k=3 only on left.
+insert into mm_l values (1, 1), (2, 1), (3, 3);
+insert into mm_r values (10, 1), (11, 1), (12, 2);
+-- run
+
+-- RIGHT: right rows 10 & 11 (k=1) each match BOTH left k=1 rows (2 each); right row
+-- 12 (k=2) has no match → one null-left row. No matched right row is null-extended.
+select mm_l.id as lid, mm_r.id as rid from mm_l right join mm_r on mm_l.k = mm_r.k order by mm_r.id, mm_l.id;
+→ [{"lid":1,"rid":10},{"lid":2,"rid":10},{"lid":1,"rid":11},{"lid":2,"rid":11},{"lid":null,"rid":12}]
+
+-- FULL: the same matched/null-left rows, plus left row 3 (k=3) null-right exactly once.
+select mm_l.id as lid, mm_r.id as rid from mm_l full join mm_r on mm_l.k = mm_r.k order by coalesce(mm_r.id, 999), coalesce(mm_l.id, 999);
+→ [{"lid":1,"rid":10},{"lid":2,"rid":10},{"lid":1,"rid":11},{"lid":2,"rid":11},{"lid":null,"rid":12},{"lid":3,"rid":null}]
+
+drop table mm_l;
+drop table mm_r;
+-- run
+
+-- ===== USING join (order-agnostic equality in the right-driven loop) =====
+
+create table us_l (id integer primary key, val text);
+create table us_r (id integer primary key, val text);
+insert into us_l values (1, 'L1'), (2, 'L2');
+insert into us_r values (1, 'R1'), (3, 'R3');
+-- run
+
+-- right join … using (id): same shape as the ON form; right id=3 null-left.
+select us_l.id as l, us_r.id as r from us_l right join us_r using (id) order by us_r.id;
+→ [{"l":1,"r":1},{"l":null,"r":3}]
+
+-- full join … using (id): both unmatched sides surface.
+select us_l.id as l, us_r.id as r from us_l full join us_r using (id) order by coalesce(us_l.id, us_r.id);
+→ [{"l":1,"r":1},{"l":2,"r":null},{"l":null,"r":3}]
+
+drop table us_l;
+drop table us_r;
+-- run
+
+-- ===== Existence flags on RIGHT (non-preserved side = left) =====
+-- `exists as h` resolves to the only null-extendable side (left) of a RIGHT join.
+-- A matched row sets h=true; a left-null-extended row sets h=false.
+
+create table ex_l (id integer primary key, val text);
+create table ex_r (id integer primary key, val text);
+insert into ex_l values (1, 'L1');
+insert into ex_r values (1, 'R1'), (2, 'R2');
+-- run
+
+select ex_r.id as r, h from ex_l right join ex_r on ex_l.id = ex_r.id exists as h order by ex_r.id;
+→ [{"r":1,"h":true},{"r":2,"h":false}]
+
+drop table ex_l;
+drop table ex_r;
+-- run
+
+-- ===== Existence flags on FULL (both sides null-extendable) =====
+-- fl = "left present", fr = "right present". Matched → both true; right-only row →
+-- fl false, fr true; left-only row → fl true, fr false.
+
+create table fe_l (id integer primary key);
+create table fe_r (id integer primary key);
+insert into fe_l values (1), (2);
+insert into fe_r values (1), (3);
+-- run
+
+select fe_l.id as l, fe_r.id as r, fl, fr
+from fe_l full join fe_r on fe_l.id = fe_r.id exists left as fl, exists right as fr
+order by coalesce(fe_l.id, fe_r.id);
+→ [{"l":1,"r":1,"fl":true,"fr":true},{"l":2,"r":null,"fl":true,"fr":false},{"l":null,"r":3,"fl":false,"fr":true}]
+
+drop table fe_l;
+drop table fe_r;

package/test/logic/90.6-select-error-paths.sqllogic

@@ -0,0 +1,57 @@
+-- adapted from SQLite test/select1.test, test/select5.test, test/e_select.test
+-- SELECT-side error paths: wrong-arity aggregate calls, ORDER BY positional
+-- references that are out of range, and aggregate references in disallowed
+-- contexts.
+
+create table eptab (id integer primary key, a integer, b integer);
+insert into eptab values (1, 11, 22), (2, 33, 44);
+
+-- count() with two arguments is rejected
+select count(a, b) from eptab;
+-- error: count
+
+-- sum() with two arguments is rejected
+select sum(a, b) from eptab;
+-- error: sum
+
+-- min(*) and max(*) — the star form is reserved for count() only
+select min(*) from eptab;
+-- error: min
+
+select max(*) from eptab;
+-- error: max
+
+-- Out-of-range / zero / negative ordinal references in GROUP BY and ORDER BY
+-- raise an error at planning time.
+select a from eptab group by 0;
+-- error: GROUP BY position 0
+
+select a from eptab group by 2;
+-- error: GROUP BY position 2
+
+select a from eptab order by -1;
+-- error: ORDER BY position -1
+
+select a from eptab order by 99;
+-- error: ORDER BY position 99
+
+drop table eptab;
+
+-- =============================================================================
+-- Compound SELECT column-count mismatch — branches must agree
+-- =============================================================================
+
+select 1
+union
+select 1, 2;
+-- error: column
+
+select 1, 2
+intersect
+select 1;
+-- error: column
+
+select 1, 2
+except
+select 1;
+-- error: column

package/test/logic/91-merge-join-edge-cases.sqllogic

@@ -0,0 +1,159 @@
+-- merge-join-edge-cases.sqllogic - Edge cases for join emitters (merge/hash)
+-- Targets: merge-join.ts branches — self-joins, residual conditions, NULL keys, many-to-many
+
+-- Self-join: cross-product within each group
+CREATE TABLE mj_self (id INTEGER PRIMARY KEY, grp INTEGER, label TEXT);
+INSERT INTO mj_self VALUES (1, 1, 'a'), (2, 1, 'b'), (3, 2, 'c'), (4, 2, 'd'), (5, 3, 'e');
+
+SELECT a.id AS aid, b.id AS bid
+FROM mj_self a JOIN mj_self b ON a.grp = b.grp
+ORDER BY aid, bid;
+→ [{"aid":1,"bid":1},{"aid":1,"bid":2},{"aid":2,"bid":1},{"aid":2,"bid":2},{"aid":3,"bid":3},{"aid":3,"bid":4},{"aid":4,"bid":3},{"aid":4,"bid":4},{"aid":5,"bid":5}]
+
+-- Self LEFT JOIN with residual condition: equi on grp, residual a.id != b.id
+-- id=5 (grp=3) is the only row in its group, so residual filters out the self-match → NULL padded
+SELECT a.id AS aid, b.id AS bid
+FROM mj_self a LEFT JOIN mj_self b ON a.grp = b.grp AND a.id != b.id
+ORDER BY aid, bid;
+→ [{"aid":1,"bid":2},{"aid":2,"bid":1},{"aid":3,"bid":4},{"aid":4,"bid":3},{"aid":5,"bid":null}]
+
+-- JOIN with residual inequality: only pairs where left label < right label
+SELECT a.id AS aid, b.id AS bid
+FROM mj_self a JOIN mj_self b ON a.grp = b.grp AND a.label < b.label
+ORDER BY aid, bid;
+→ [{"aid":1,"bid":2},{"aid":3,"bid":4}]
+
+-- All-NULL join keys: NULLs never match per SQL standard
+CREATE TABLE mj_allnull (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO mj_allnull VALUES (1, null), (2, null), (3, null);
+
+SELECT a.id, b.id FROM mj_allnull a JOIN mj_allnull b ON a.val = b.val;
+→ []
+
+-- LEFT JOIN with all-NULL keys: every left row is unmatched
+SELECT a.id, b.id FROM mj_allnull a LEFT JOIN mj_allnull b ON a.val = b.val ORDER BY a.id;
+→ [{"id":1,"id:1":null},{"id":2,"id:1":null},{"id":3,"id:1":null}]
+
+-- Mixed NULL and non-NULL join keys
+CREATE TABLE mj_mixed (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO mj_mixed VALUES (1, 10), (2, null), (3, 20), (4, null), (5, 10);
+
+-- INNER JOIN: NULLs excluded, matching non-NULLs produce cross-product
+SELECT a.id AS aid, b.id AS bid
+FROM mj_mixed a JOIN mj_mixed b ON a.val = b.val
+ORDER BY aid, bid;
+→ [{"aid":1,"bid":1},{"aid":1,"bid":5},{"aid":3,"bid":3},{"aid":5,"bid":1},{"aid":5,"bid":5}]
+
+-- LEFT JOIN: NULL-keyed rows get NULL padding, matched rows get cross-product
+SELECT a.id AS aid, b.id AS bid
+FROM mj_mixed a LEFT JOIN mj_mixed b ON a.val = b.val
+ORDER BY aid, bid;
+→ [{"aid":1,"bid":1},{"aid":1,"bid":5},{"aid":2,"bid":null},{"aid":3,"bid":3},{"aid":4,"bid":null},{"aid":5,"bid":1},{"aid":5,"bid":5}]
+
+-- Many-to-many with asymmetric cardinality
+CREATE TABLE mj_m2m_l (id INTEGER PRIMARY KEY, key INTEGER);
+CREATE TABLE mj_m2m_r (id INTEGER PRIMARY KEY, key INTEGER);
+INSERT INTO mj_m2m_l VALUES (1, 10), (2, 10), (3, 10), (4, 20);
+INSERT INTO mj_m2m_r VALUES (10, 10), (20, 10), (30, 20), (40, 20), (50, 20);
+
+-- 3×2=6 for key=10, 1×3=3 for key=20 → total 9
+SELECT count(*) AS cnt FROM mj_m2m_l l JOIN mj_m2m_r r ON l.key = r.key;
+→ [{"cnt":9}]
+
+-- LEFT JOIN preserves all left rows with correct match counts
+SELECT l.id, count(r.id) AS matches
+FROM mj_m2m_l l LEFT JOIN mj_m2m_r r ON l.key = r.key
+GROUP BY l.id ORDER BY l.id;
+→ [{"id":1,"matches":2},{"id":2,"matches":2},{"id":3,"matches":2},{"id":4,"matches":3}]
+
+-- Join where one side is empty (inner and left)
+CREATE TABLE mj_populated (id INTEGER PRIMARY KEY, val INTEGER);
+CREATE TABLE mj_empty (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO mj_populated VALUES (1, 10), (2, 20);
+
+SELECT p.id FROM mj_populated p JOIN mj_empty e ON p.val = e.val;
+→ []
+
+SELECT p.id, e.id AS eid FROM mj_populated p LEFT JOIN mj_empty e ON p.val = e.val ORDER BY p.id;
+→ [{"id":1,"eid":null},{"id":2,"eid":null}]
+
+-- Both sides empty
+SELECT a.id FROM mj_empty a JOIN mj_empty b ON a.val = b.val;
+→ []
+
+-- Multi-column join with partial key matches
+CREATE TABLE mj_mc_l (a INTEGER, b INTEGER, v TEXT, PRIMARY KEY (a, b));
+CREATE TABLE mj_mc_r (x INTEGER, y INTEGER, w TEXT, PRIMARY KEY (x, y));
+
+INSERT INTO mj_mc_l VALUES (1, 10, 'p'), (1, 20, 'q'), (2, 10, 'r');
+INSERT INTO mj_mc_r VALUES (1, 10, 's'), (1, 30, 't'), (2, 10, 'u');
+
+-- Only (1,10) and (2,10) match on both columns
+SELECT l.v, r.w FROM mj_mc_l l JOIN mj_mc_r r ON l.a = r.x AND l.b = r.y ORDER BY l.a, l.b;
+→ [{"v":"p","w":"s"},{"v":"r","w":"u"}]
+
+-- LEFT JOIN: (1,20) has no match on both columns → NULL padded
+SELECT l.a, l.b, r.w FROM mj_mc_l l LEFT JOIN mj_mc_r r ON l.a = r.x AND l.b = r.y ORDER BY l.a, l.b;
+→ [{"a":1,"b":10,"w":"s"},{"a":1,"b":20,"w":null},{"a":2,"b":10,"w":"u"}]
+
+-- DESC primary key: the scan's advertised ordering must carry the declared
+-- direction, or a merge join built on it drops all but one matching row.
+-- (bug-desc-pk-scan-advertises-ascending-order)
+CREATE TABLE mj_dpk (id INTEGER, v TEXT, PRIMARY KEY (id DESC));
+CREATE TABLE mj_small (id INTEGER PRIMARY KEY);
+INSERT INTO mj_dpk VALUES (1, 'a'), (2, 'b'), (3, 'c');
+INSERT INTO mj_small VALUES (1), (2), (3);
+
+SELECT id FROM mj_dpk WHERE id IN (SELECT id FROM mj_small) ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+SELECT id FROM mj_dpk d WHERE EXISTS (SELECT 1 FROM mj_small s WHERE s.id = d.id) ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+SELECT d.id FROM mj_dpk d JOIN mj_small s ON s.id = d.id ORDER BY d.id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+SELECT d.id AS did, s.id AS sid FROM mj_dpk d LEFT JOIN mj_small s ON s.id = d.id ORDER BY d.id;
+→ [{"did":1,"sid":1},{"did":2,"sid":2},{"did":3,"sid":3}]
+
+-- Sort absorption over the same advertisement: an ORDER BY must not be elided
+-- against a stream that runs the other way.
+SELECT id FROM mj_dpk ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+SELECT id FROM mj_dpk ORDER BY id DESC;
+→ [{"id":3},{"id":2},{"id":1}]
+
+-- Composite PK with mixed directions: the advertisement is per-column, so the
+-- ASC member and the DESC member must each carry their own direction.
+CREATE TABLE mj_mixdir (a INTEGER, b INTEGER, v TEXT, PRIMARY KEY (a ASC, b DESC));
+CREATE TABLE mj_mixdir_r (a INTEGER, b INTEGER, w TEXT, PRIMARY KEY (a ASC, b DESC));
+INSERT INTO mj_mixdir VALUES (1, 10, 'p'), (1, 20, 'q'), (2, 10, 'r');
+INSERT INTO mj_mixdir_r VALUES (1, 10, 's'), (1, 20, 't'), (2, 10, 'u');
+
+SELECT l.v, r.w FROM mj_mixdir l JOIN mj_mixdir_r r ON l.a = r.a AND l.b = r.b ORDER BY l.a, l.b;
+→ [{"v":"p","w":"s"},{"v":"q","w":"t"},{"v":"r","w":"u"}]
+
+SELECT l.a, l.b, r.w FROM mj_mixdir l LEFT JOIN mj_mixdir_r r ON l.a = r.a AND l.b = r.b ORDER BY l.a, l.b;
+→ [{"a":1,"b":10,"w":"s"},{"a":1,"b":20,"w":"t"},{"a":2,"b":10,"w":"u"}]
+
+SELECT a, b FROM mj_mixdir ORDER BY a, b;
+→ [{"a":1,"b":10},{"a":1,"b":20},{"a":2,"b":10}]
+
+SELECT a, b FROM mj_mixdir ORDER BY a, b DESC;
+→ [{"a":1,"b":20},{"a":1,"b":10},{"a":2,"b":10}]
+
+-- Cleanup
+DROP TABLE mj_self;
+DROP TABLE mj_allnull;
+DROP TABLE mj_mixed;
+DROP TABLE mj_m2m_l;
+DROP TABLE mj_m2m_r;
+DROP TABLE mj_populated;
+DROP TABLE mj_empty;
+DROP TABLE mj_mc_l;
+DROP TABLE mj_mc_r;
+DROP TABLE mj_dpk;
+DROP TABLE mj_small;
+DROP TABLE mj_mixdir;
+DROP TABLE mj_mixdir_r;

package/test/logic/92-hash-aggregate-edge-cases.sqllogic

@@ -0,0 +1,139 @@
+-- hash-aggregate-edge-cases.sqllogic - Edge cases for hash aggregate emitter
+-- Targets: hash-aggregate.ts — empty input, NULL groups, DISTINCT aggregates, expression keys
+
+-- Empty table with GROUP BY → no rows (not a single NULL row)
+CREATE TABLE ha_empty (id INTEGER PRIMARY KEY, grp TEXT, val INTEGER NULL);
+
+SELECT grp, count(*) AS cnt FROM ha_empty GROUP BY grp;
+→ []
+
+SELECT grp, sum(val) AS total FROM ha_empty GROUP BY grp;
+→ []
+
+DROP TABLE ha_empty;
+
+-- All-NULL group key → single NULL group
+CREATE TABLE ha_null_grp (id INTEGER PRIMARY KEY, grp TEXT NULL, val INTEGER);
+INSERT INTO ha_null_grp VALUES (1, null, 10), (2, null, 20), (3, null, 30);
+
+SELECT grp, count(*) AS cnt, sum(val) AS total FROM ha_null_grp GROUP BY grp;
+→ [{"grp":null,"cnt":3,"total":60}]
+
+-- Multiple NULL groups and non-NULL groups coexist
+INSERT INTO ha_null_grp VALUES (4, 'x', 40), (5, 'x', 50);
+
+SELECT grp, count(*) AS cnt FROM ha_null_grp GROUP BY grp ORDER BY grp NULLS FIRST;
+→ [{"grp":null,"cnt":3},{"grp":"x","cnt":2}]
+
+DROP TABLE ha_null_grp;
+
+-- SUM(DISTINCT col) with NULLs: NULLs excluded from distinct tracking
+CREATE TABLE ha_dist (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO ha_dist VALUES (1, 10), (2, 20), (3, 10), (4, null), (5, 20), (6, null);
+
+SELECT sum(distinct val) AS sd FROM ha_dist;
+→ [{"sd":30}]
+
+-- count(*) vs count(col) vs count(distinct col) with NULLs
+SELECT count(*) AS c_star, count(val) AS c_val, count(distinct val) AS c_dval FROM ha_dist;
+→ [{"c_star":6,"c_val":4,"c_dval":2}]
+
+-- AVG(DISTINCT col)
+SELECT avg(distinct val) AS ad FROM ha_dist;
+→ [{"ad":15}]
+
+-- Multiple DISTINCT aggregates in same query
+SELECT count(distinct val) AS cd, sum(distinct val) AS sd, avg(distinct val) AS ad FROM ha_dist;
+→ [{"cd":2,"sd":30,"ad":15}]
+
+DROP TABLE ha_dist;
+
+-- SUM(DISTINCT) with GROUP BY
+CREATE TABLE ha_dist_grp (id INTEGER PRIMARY KEY, grp TEXT, val INTEGER NULL);
+INSERT INTO ha_dist_grp VALUES (1, 'a', 10), (2, 'a', 10), (3, 'a', 20), (4, 'b', 30), (5, 'b', null);
+
+SELECT grp, sum(distinct val) AS sd, count(distinct val) AS cd FROM ha_dist_grp GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","sd":30,"cd":2},{"grp":"b","sd":30,"cd":1}]
+
+DROP TABLE ha_dist_grp;
+
+-- All-NULL value column: aggregates return null (except count(*) and count)
+CREATE TABLE ha_allnull (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO ha_allnull VALUES (1, null), (2, null), (3, null);
+
+SELECT count(*) AS c_star, count(val) AS c_val, sum(val) AS s, avg(val) AS a, min(val) AS mn, max(val) AS mx FROM ha_allnull;
+→ [{"c_star":3,"c_val":0,"s":null,"a":null,"mn":null,"mx":null}]
+
+DROP TABLE ha_allnull;
+
+-- GROUP BY on expression
+CREATE TABLE ha_expr (id INTEGER PRIMARY KEY, name TEXT, val INTEGER);
+INSERT INTO ha_expr VALUES (1, 'a', 10), (2, 'bb', 20), (3, 'ccc', 30), (4, 'dd', 40);
+
+SELECT length(name) AS name_len, sum(val) AS total FROM ha_expr GROUP BY length(name) ORDER BY length(name);
+→ [{"name_len":1,"total":10},{"name_len":2,"total":60},{"name_len":3,"total":30}]
+
+DROP TABLE ha_expr;
+
+-- Single-row groups (each row is its own group)
+CREATE TABLE ha_single (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO ha_single VALUES (1, 100), (2, 200), (3, 300);
+
+SELECT id, count(*) AS cnt, sum(val) AS total FROM ha_single GROUP BY id ORDER BY id;
+→ [{"id":1,"cnt":1,"total":100},{"id":2,"cnt":1,"total":200},{"id":3,"cnt":1,"total":300}]
+
+DROP TABLE ha_single;
+
+-- HAVING that filters all groups → empty result
+CREATE TABLE ha_having (id INTEGER PRIMARY KEY, grp TEXT, val INTEGER);
+INSERT INTO ha_having VALUES (1, 'a', 10), (2, 'b', 20);
+
+SELECT grp, sum(val) AS total FROM ha_having GROUP BY grp HAVING sum(val) > 1000;
+→ []
+
+-- HAVING with DISTINCT aggregate
+SELECT grp, count(distinct val) AS cd FROM ha_having GROUP BY grp HAVING count(distinct val) > 5;
+→ []
+
+DROP TABLE ha_having;
+
+-- Aggregate without GROUP BY on empty table: returns single row with initial values
+CREATE TABLE ha_empty_agg (id INTEGER PRIMARY KEY, val INTEGER NULL);
+
+SELECT count(*) AS cnt, sum(val) AS s, min(val) AS mn, max(val) AS mx FROM ha_empty_agg;
+→ [{"cnt":0,"s":null,"mn":null,"mx":null}]
+
+DROP TABLE ha_empty_agg;
+
+-- GROUP BY with multiple columns including NULL
+CREATE TABLE ha_multi_grp (id INTEGER PRIMARY KEY, a TEXT NULL, b INTEGER NULL, val INTEGER);
+INSERT INTO ha_multi_grp VALUES (1, 'x', 1, 10), (2, 'x', 1, 20), (3, 'x', null, 30), (4, null, 1, 40), (5, null, null, 50);
+
+SELECT a, b, count(*) AS cnt, sum(val) AS total
+FROM ha_multi_grp GROUP BY a, b ORDER BY a NULLS FIRST, b NULLS FIRST;
+→ [{"a":null,"b":null,"cnt":1,"total":50},{"a":null,"b":1,"cnt":1,"total":40},{"a":"x","b":null,"cnt":1,"total":30},{"a":"x","b":1,"cnt":2,"total":30}]
+
+DROP TABLE ha_multi_grp;
+
+-- group_concat(DISTINCT) — distinct string aggregation
+CREATE TABLE ha_gc (id INTEGER PRIMARY KEY, grp TEXT, tag TEXT NULL);
+INSERT INTO ha_gc VALUES (1, 'a', 'x'), (2, 'a', 'y'), (3, 'a', 'x'), (4, 'b', null), (5, 'b', 'z');
+
+SELECT grp, group_concat(distinct tag) AS tags FROM ha_gc GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","tags":"x,y"},{"grp":"b","tags":"z"}]
+
+DROP TABLE ha_gc;
+
+-- count(distinct blob_col) with GROUP BY — the DISTINCT tree's entry is the
+-- bare BLOB scalar (a Uint8Array), which inheritree's default freeze-on-insert
+-- could not store (bug-in-subquery-blob-values-crash). Exercises the shared
+-- distinct-tree factory used by hash-aggregate's grouped path.
+CREATE TABLE ha_blob_grp (id INTEGER PRIMARY KEY, grp TEXT, b BLOB NULL);
+INSERT INTO ha_blob_grp VALUES
+	(1, 'a', x'6162'), (2, 'a', x'6162'), (3, 'a', x'6164'),
+	(4, 'b', x'6162'), (5, 'b', null);
+
+SELECT grp, count(distinct b) AS cd FROM ha_blob_grp GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","cd":2},{"grp":"b","cd":1}]
+
+DROP TABLE ha_blob_grp;