@quereus/quereus 4.20.1 → 4.20.3

package/test/logic/07.5.1-window-named.sqllogic

@@ -0,0 +1,13 @@
+-- adapted from SQLite test/window1.test, test/window4.test, test/window9.test
+-- Named window definitions via the WINDOW clause; Quereus does not yet
+-- support window-name references. Document the rejection.
+
+create table nw (id integer primary key, val integer, grp text);
+insert into nw values (1, 10, 'A'), (2, 20, 'A');
+
+select id, val, grp,
+       row_number() over w as rn
+from nw window w as (partition by grp order by id) order by id;
+-- error: Window name references are not yet supported
+
+drop table nw;

package/test/logic/07.5.2-window-nth-value.sqllogic

@@ -0,0 +1,13 @@
+-- adapted from SQLite test/window1.test, test/window3.test, test/window6.test
+-- nth_value(expr, n) is not currently implemented as a window function in
+-- Quereus. Document the rejection.
+
+create table nv (id integer primary key, val integer, grp text);
+insert into nv values (1, 10, 'A'), (2, 20, 'A');
+
+select id, val, grp,
+       nth_value(val, 1) over (partition by grp order by id) as nth1
+from nv order by id;
+-- error: Unknown window function: nth_value
+
+drop table nv;

package/test/logic/07.6-subqueries.sqllogic

@@ -0,0 +1,78 @@
+-- subqueries.sqllogic - Testing various subquery forms
+
+-- Setup tables
+CREATE TABLE outer_t (id INTEGER PRIMARY KEY, grp TEXT);
+CREATE TABLE inner_t (id INTEGER PRIMARY KEY, val INTEGER, outer_id INTEGER NULL);
+
+INSERT INTO outer_t VALUES (1, 'A'), (2, 'B'), (3, 'A');
+INSERT INTO inner_t VALUES (10, 100, 1), (20, 200, 2), (30, 300, 1), (40, 400, 3), (50, 500, null);
+
+-- Scalar Subquery (Uncorrelated)
+SELECT (SELECT max(val) FROM inner_t);
+→ [{"(select max(val) from inner_t)":500}]
+SELECT id, (SELECT count(*) FROM inner_t) as inner_count FROM outer_t ORDER BY id;
+→ [{"id":1,"inner_count":5},{"id":2,"inner_count":5},{"id":3,"inner_count":5}]
+
+-- Scalar Subquery (Correlated)
+SELECT id, (SELECT sum(val) FROM inner_t WHERE inner_t.outer_id = outer_t.id) as grp_sum FROM outer_t ORDER BY id;
+→ [{"id":1,"grp_sum":400},{"id":2,"grp_sum":200},{"id":3,"grp_sum":400}]
+
+-- EXISTS Subquery (Uncorrelated)
+SELECT id FROM outer_t WHERE EXISTS (SELECT 1 FROM inner_t WHERE val > 1000);
+→ []
+SELECT id FROM outer_t WHERE EXISTS (SELECT 1 FROM inner_t WHERE val < 200);
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- EXISTS Subquery (Correlated)
+SELECT id FROM outer_t WHERE EXISTS (SELECT 1 FROM inner_t WHERE inner_t.outer_id = outer_t.id AND val > 250) ORDER BY id;
+→ [{"id":1},{"id":3}]
+SELECT id FROM outer_t WHERE NOT EXISTS (SELECT 1 FROM inner_t WHERE inner_t.outer_id = outer_t.id);
+→ []
+
+-- IN Subquery (Uncorrelated)
+SELECT id FROM outer_t WHERE id IN (SELECT outer_id FROM inner_t WHERE val > 300) ORDER BY id;
+→ [{"id":3}]
+SELECT id FROM outer_t WHERE id NOT IN (SELECT outer_id FROM inner_t WHERE val < 300) ORDER BY id;
+→ [{"id":3}]
+
+-- IN Subquery (Correlated - less common, but syntactically valid)
+SELECT id FROM outer_t WHERE outer_t.grp IN (SELECT o2.grp FROM outer_t o2 WHERE o2.id = outer_t.id) ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- Comparison Subquery (Uncorrelated)
+SELECT id FROM outer_t WHERE id = (SELECT min(outer_id) FROM inner_t);
+→ [{"id":1}]
+SELECT id FROM outer_t WHERE id > (SELECT avg(outer_id) FROM inner_t WHERE outer_id IS NOT NULL) ORDER BY id;
+→ [{"id":2},{"id":3}]
+
+-- Comparison Subquery (Correlated)
+SELECT id FROM outer_t WHERE outer_t.id = (SELECT i.outer_id FROM inner_t i WHERE i.val = 400 AND i.outer_id = outer_t.id);
+→ [{"id":3}]
+
+-- Subquery in SELECT list returning multiple rows (Error expected)
+SELECT id, (SELECT val FROM inner_t WHERE inner_t.outer_id = outer_t.id) FROM outer_t;
+-- error: Scalar subquery returned more than one row
+
+-- Subqueries in ORDER BY (testing async expression handling)
+-- Uncorrelated scalar subquery in ORDER BY
+SELECT id, grp FROM outer_t ORDER BY (SELECT max(val) FROM inner_t), id;
+→ [{"id":1,"grp":"A"},{"id":2,"grp":"B"},{"id":3,"grp":"A"}]
+
+-- Correlated scalar subquery in ORDER BY
+SELECT id, grp FROM outer_t ORDER BY (SELECT sum(val) FROM inner_t WHERE inner_t.outer_id = outer_t.id) DESC, id;
+→ [{"id":1,"grp":"A"},{"id":3,"grp":"A"},{"id":2,"grp":"B"}]
+
+-- Complex ORDER BY with both regular columns and subqueries
+SELECT id, grp FROM outer_t ORDER BY grp, (SELECT count(*) FROM inner_t WHERE inner_t.outer_id = outer_t.id) DESC;
+→ [{"id":1,"grp":"A"},{"id":3,"grp":"A"},{"id":2,"grp":"B"}]
+
+-- ORDER BY with subquery that may return NULL
+SELECT id, grp FROM outer_t ORDER BY (SELECT min(val) FROM inner_t WHERE inner_t.outer_id = outer_t.id + 100) NULLS LAST, id;
+→ [{"id":1,"grp":"A"},{"id":2,"grp":"B"},{"id":3,"grp":"A"}]
+
+-- Subquery source (derived table) with alias and qualified SELECT *
+SELECT s.* FROM (SELECT id, grp FROM outer_t WHERE id > 1) s ORDER BY id;
+→ [{"id":2,"grp":"B"},{"id":3,"grp":"A"}]
+
+DROP TABLE outer_t;
+DROP TABLE inner_t;

package/test/logic/07.6.1-subquery-extras.sqllogic

@@ -0,0 +1,93 @@
+-- adapted from SQLite test/subquery.test, test/subquery2.test, test/exists.test
+-- Subquery surface gaps: scalar in UPDATE SET, dynamic LIMIT/OFFSET via scalar
+-- subquery, scalar subquery with DISTINCT/LIMIT in projection, EXISTS in SELECT
+-- list (not just WHERE), and EXISTS with arithmetic correlation predicates.
+
+create table sqx_outer (id integer primary key, val integer);
+create table sqx_inner (id integer primary key, ref_id integer, amount integer);
+insert into sqx_outer values (1, 0), (2, 0), (3, 0);
+insert into sqx_inner values (10, 1, 50), (20, 1, 30), (30, 2, 40);
+
+-- =============================================================================
+-- Correlated scalar subquery in UPDATE SET clause
+-- =============================================================================
+
+update sqx_outer set val = (select coalesce(sum(amount), 0) from sqx_inner where sqx_inner.ref_id = sqx_outer.id);
+select id, val from sqx_outer order by id;
+→ [{"id":1,"val":80},{"id":2,"val":40},{"id":3,"val":0}]
+
+-- =============================================================================
+-- Dynamic LIMIT / OFFSET via scalar subquery
+-- =============================================================================
+
+create table sqx_limits (lim integer primary key, off integer);
+insert into sqx_limits values (2, 0), (3, 1);
+
+-- LIMIT from scalar subquery
+select id from sqx_outer order by id limit (select lim from sqx_limits where lim = 2);
+→ [{"id":1},{"id":2}]
+
+-- LIMIT and OFFSET both from scalar subqueries
+select id from sqx_outer order by id limit (select lim from sqx_limits where lim = 3) offset (select off from sqx_limits where lim = 3);
+→ [{"id":2},{"id":3}]
+
+drop table sqx_limits;
+
+-- =============================================================================
+-- Scalar subquery in projection with DISTINCT + ORDER BY + LIMIT
+-- =============================================================================
+
+create table sqx_dups (id integer primary key, v integer);
+insert into sqx_dups values (1, 100), (2, 100), (3, 200), (4, 200), (5, 300);
+
+-- DISTINCT inside scalar subquery: pick the second-smallest distinct value
+select (select distinct v from sqx_dups order by v limit 1 offset 1) as second_distinct;
+→ [{"second_distinct":200}]
+
+-- Scalar subquery with constant projection + ORDER BY + LIMIT
+select (select 'k' from sqx_dups order by v limit 1) as constant_proj;
+→ [{"constant_proj":"k"}]
+
+-- Scalar subquery with ORDER BY + LIMIT past end yields null
+select (select v from sqx_dups order by v limit 1 offset 100) as past_end;
+→ [{"past_end":null}]
+
+drop table sqx_dups;
+
+-- =============================================================================
+-- EXISTS in SELECT projection (not just WHERE)
+-- =============================================================================
+
+select id, exists (select 1 from sqx_inner where sqx_inner.ref_id = sqx_outer.id) as has_child from sqx_outer order by id;
+→ [{"id":1,"has_child":true},{"id":2,"has_child":true},{"id":3,"has_child":false}]
+
+-- NOT EXISTS in SELECT projection
+select id, not exists (select 1 from sqx_inner where sqx_inner.ref_id = sqx_outer.id) as is_leaf from sqx_outer order by id;
+→ [{"id":1,"is_leaf":false},{"id":2,"is_leaf":false},{"id":3,"is_leaf":true}]
+
+-- EXISTS inside CASE expression in projection
+select id, case when exists (select 1 from sqx_inner where sqx_inner.ref_id = sqx_outer.id and amount > 45) then 'large' else 'small' end as bucket from sqx_outer order by id;
+→ [{"id":1,"bucket":"large"},{"id":2,"bucket":"small"},{"id":3,"bucket":"small"}]
+
+-- =============================================================================
+-- EXISTS with arithmetic correlation predicate (not just plain equality)
+-- =============================================================================
+
+create table sqx_a (id integer primary key, x integer);
+create table sqx_b (id integer primary key, y integer);
+insert into sqx_a values (1, 10), (2, 20), (3, 30);
+insert into sqx_b values (10, 0), (20, 10), (30, 20);
+
+-- EXISTS where correlation is `b.y = a.x - 10`
+select sqx_a.id from sqx_a where exists (select 1 from sqx_b where sqx_b.y = sqx_a.x - 10) order by sqx_a.id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+-- EXISTS where correlation includes a function call
+select sqx_a.id from sqx_a where exists (select 1 from sqx_b where sqx_b.y = abs(sqx_a.x - 30)) order by sqx_a.id;
+→ [{"id":1},{"id":2},{"id":3}]
+
+drop table sqx_a;
+drop table sqx_b;
+
+drop table sqx_inner;
+drop table sqx_outer;

package/test/logic/07.7-and-or-short-circuit.sqllogic

@@ -0,0 +1,58 @@
+-- and-or-short-circuit.sqllogic - AND/OR short-circuit deferral end-to-end
+-- Complements test/and-or-short-circuit.spec.ts (which owns the side-effect /
+-- non-evaluation and emit-note assertions via a counting UDF). This file pins
+-- three-valued-logic parity between the eager two-param path (pure-scalar RHS)
+-- and the deferred short-circuit path (subquery-wrapped RHS) end-to-end through
+-- the SQL runner, for every {true,false,null}² operand pair.
+
+-- true=1, false=0, null=null (isTruthy maps 1->true, 0->false). Row id = combo.
+create table tv (id integer primary key, a integer null, b integer null);
+insert into tv values
+  (1, 1, 1), (2, 1, 0), (3, 1, null),
+  (4, 0, 1), (5, 0, 0), (6, 0, null),
+  (7, null, 1), (8, null, 0), (9, null, null);
+
+-- =============================================================================
+-- AND: eager (column RHS) vs deferred (correlated subquery RHS) must match
+-- =============================================================================
+
+select id, (a and b) as r from tv order by id;
+→ [{"id":1,"r":true},{"id":2,"r":false},{"id":3,"r":null},{"id":4,"r":false},{"id":5,"r":false},{"id":6,"r":false},{"id":7,"r":null},{"id":8,"r":false},{"id":9,"r":null}]
+
+select id, (a and (select b from tv t2 where t2.id = tv.id)) as r from tv order by id;
+→ [{"id":1,"r":true},{"id":2,"r":false},{"id":3,"r":null},{"id":4,"r":false},{"id":5,"r":false},{"id":6,"r":false},{"id":7,"r":null},{"id":8,"r":false},{"id":9,"r":null}]
+
+-- =============================================================================
+-- OR: eager vs deferred must match
+-- =============================================================================
+
+select id, (a or b) as r from tv order by id;
+→ [{"id":1,"r":true},{"id":2,"r":true},{"id":3,"r":true},{"id":4,"r":true},{"id":5,"r":false},{"id":6,"r":null},{"id":7,"r":true},{"id":8,"r":null},{"id":9,"r":null}]
+
+select id, (a or (select b from tv t2 where t2.id = tv.id)) as r from tv order by id;
+→ [{"id":1,"r":true},{"id":2,"r":true},{"id":3,"r":true},{"id":4,"r":true},{"id":5,"r":false},{"id":6,"r":null},{"id":7,"r":true},{"id":8,"r":null},{"id":9,"r":null}]
+
+-- =============================================================================
+-- XOR is untouched (both operands always required); subquery RHS still correct
+-- =============================================================================
+
+select id, (a xor b) as r from tv order by id;
+→ [{"id":1,"r":false},{"id":2,"r":true},{"id":3,"r":null},{"id":4,"r":true},{"id":5,"r":false},{"id":6,"r":null},{"id":7,"r":null},{"id":8,"r":null},{"id":9,"r":null}]
+
+select id, (a xor (select b from tv t2 where t2.id = tv.id)) as r from tv order by id;
+→ [{"id":1,"r":false},{"id":2,"r":true},{"id":3,"r":null},{"id":4,"r":true},{"id":5,"r":false},{"id":6,"r":null},{"id":7,"r":null},{"id":8,"r":null},{"id":9,"r":null}]
+
+-- =============================================================================
+-- Deferred RHS in a WHERE-clause OR (the headline use case), plus a nested
+-- short-circuit where the inner OR is itself the deferred right operand.
+-- =============================================================================
+
+-- true OR (subquery) short-circuits to true; false/null OR (subquery=b) resolves b.
+select id from tv where a = 1 or (select b from tv t2 where t2.id = tv.id) = 1 order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":7}]
+
+-- a and (b or (subquery)): outer AND defers the (b or subquery) group.
+select id, (a = 1 and (b = 1 or (select count(*) from tv t2 where t2.id = tv.id) > 5)) as r from tv order by id;
+→ [{"id":1,"r":true},{"id":2,"r":false},{"id":3,"r":null},{"id":4,"r":false},{"id":5,"r":false},{"id":6,"r":false},{"id":7,"r":null},{"id":8,"r":false},{"id":9,"r":null}]
+
+drop table tv;

package/test/logic/07.7-in-subquery-caching.sqllogic

@@ -0,0 +1,174 @@
+-- in-subquery-caching.sqllogic - Testing uncorrelated IN subquery materialization
+-- via the emitIn set probe (once-per-execution lookup set; see
+-- quereus-in-subquery-set-probe). Correlated / non-deterministic sources keep the
+-- per-outer-row streaming path.
+
+-- Setup tables
+CREATE TABLE items (id INTEGER PRIMARY KEY, category TEXT, val INTEGER);
+CREATE TABLE categories (name TEXT PRIMARY KEY);
+
+INSERT INTO categories VALUES ('A'), ('B'), ('C');
+INSERT INTO items VALUES (1, 'A', 10), (2, 'A', 20), (3, 'B', 30), (4, 'C', 40), (5, 'A', 50);
+
+-- Basic uncorrelated IN subquery (should be cached)
+SELECT id FROM items WHERE category IN (SELECT name FROM categories WHERE name <> 'C') ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":5}]
+
+-- IN subquery with NULLs in the subquery result set
+-- SQL three-valued logic: if value not found and NULLs present, result is NULL (not FALSE)
+CREATE TABLE nullable_ids (id INTEGER PRIMARY KEY, val INTEGER NULL);
+INSERT INTO nullable_ids VALUES (1, 1), (2, NULL), (3, 3);
+
+-- id=2 is not in {1, NULL, 3}, but NULL is present, so result is NULL (not TRUE) — excluded from WHERE
+SELECT id FROM items WHERE id IN (SELECT val FROM nullable_ids) ORDER BY id;
+→ [{"id":1},{"id":3}]
+
+-- NOT IN with NULLs — any NULL in subquery makes NOT IN return NULL for non-matching rows
+-- Only rows whose id IS in the set (after ignoring NULLs) would return FALSE for IN, i.e., TRUE for NOT IN
+-- But since NULL is present, non-matching rows get NULL (not FALSE) for IN, so NOT IN is NULL (not TRUE)
+SELECT id FROM items WHERE id NOT IN (SELECT val FROM nullable_ids) ORDER BY id;
+→ []
+
+-- IN subquery returning empty set (should return no rows)
+SELECT id FROM items WHERE id IN (SELECT val FROM nullable_ids WHERE val > 100) ORDER BY id;
+→ []
+
+-- Correlated IN subquery — must take the streaming (per-outer-row) path, not the
+-- set probe (should still work correctly)
+SELECT c.name FROM categories c WHERE c.name IN (SELECT i.category FROM items i WHERE i.val > 20 AND i.category = c.name) ORDER BY c.name;
+→ [{"name":"A"},{"name":"B"},{"name":"C"}]
+
+-- Uncorrelated IN subquery inside a CTE-based query (the motivating pattern)
+WITH RECURSIVE
+  nums(n) AS (
+    SELECT 1
+    UNION ALL
+    SELECT n + 1 FROM nums WHERE n < 5
+  )
+SELECT id FROM items WHERE id IN (SELECT n FROM nums) ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5}]
+
+-- Nested: uncorrelated IN subquery referencing a CTE that itself is recursive
+WITH RECURSIVE
+  tree(id) AS (
+    SELECT id FROM items WHERE id = 1
+    UNION ALL
+    SELECT i.id FROM items i JOIN tree t ON i.id = t.id + 1 WHERE i.id <= 3
+  )
+SELECT val FROM items WHERE id IN (SELECT id FROM tree) ORDER BY val;
+→ [{"val":10},{"val":20},{"val":30}]
+
+-- IN in projection position (not a WHERE filter): same emitter / set-probe path,
+-- must yield the three-valued boolean per row. id 4 (category 'C') is not in the
+-- filtered set {'A','B'}, and the subquery has no NULLs, so → false (0).
+SELECT id, category IN (SELECT name FROM categories WHERE name <> 'C') AS in_ab FROM items ORDER BY id;
+→ [{"id":1,"in_ab":true},{"id":2,"in_ab":true},{"id":3,"in_ab":true},{"id":4,"in_ab":false},{"id":5,"in_ab":true}]
+
+-- NOCASE collation: membership uses the condition column's collation. The set
+-- probe keys the lookup set under the same collation as the streaming path, so
+-- 'Apple' matches 'apple' and 'BANANA' matches 'banana'.
+CREATE TABLE nc (id INTEGER PRIMARY KEY, tag TEXT COLLATE NOCASE);
+INSERT INTO nc VALUES (1, 'Apple'), (2, 'BANANA'), (3, 'cherry');
+CREATE TABLE nc_want (w TEXT);
+INSERT INTO nc_want VALUES ('apple'), ('banana');
+
+SELECT id FROM nc WHERE tag IN (SELECT w FROM nc_want) ORDER BY id;
+→ [{"id":1},{"id":2}]
+
+DROP TABLE nc_want;
+DROP TABLE nc;
+
+-- Self-referencing DELETE: the subquery reads the same table being deleted from.
+-- Materialize-once makes this a deterministic pre-statement snapshot — the set of
+-- ids to delete is computed before any row is removed.
+CREATE TABLE sref (id INTEGER PRIMARY KEY, keep INTEGER);
+INSERT INTO sref VALUES (1, 1), (2, 0), (3, 1), (4, 0);
+
+DELETE FROM sref WHERE id IN (SELECT id FROM sref WHERE keep = 0);
+SELECT id FROM sref ORDER BY id;
+→ [{"id":1},{"id":3}]
+
+DROP TABLE sref;
+
+-- UPDATE / DELETE row counts filtered by an uncorrelated IN subquery over a
+-- larger set (exercises the set probe on many candidate rows).
+CREATE TABLE dml_outer (id INTEGER PRIMARY KEY, mark INTEGER);
+INSERT INTO dml_outer VALUES (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0);
+CREATE TABLE dml_keep (id INTEGER PRIMARY KEY);
+INSERT INTO dml_keep VALUES (2), (4), (6);
+
+UPDATE dml_outer SET mark = 1 WHERE id IN (SELECT id FROM dml_keep);
+SELECT id, mark FROM dml_outer ORDER BY id;
+→ [{"id":1,"mark":0},{"id":2,"mark":1},{"id":3,"mark":0},{"id":4,"mark":1},{"id":5,"mark":0},{"id":6,"mark":1}]
+
+DELETE FROM dml_outer WHERE id IN (SELECT id FROM dml_keep);
+SELECT id, mark FROM dml_outer ORDER BY id;
+→ [{"id":1,"mark":0},{"id":3,"mark":0},{"id":5,"mark":0}]
+
+DROP TABLE dml_keep;
+DROP TABLE dml_outer;
+
+-- BLOB values in an uncorrelated IN subquery: the set-probe path builds an
+-- in-memory BTree keyed on the raw scalar value, which used to crash on any
+-- non-empty BLOB (bug-in-subquery-blob-values-crash — inheritree freezes each
+-- stored entry by default, and Object.freeze throws on a non-empty
+-- Uint8Array, which is exactly what a BLOB scalar is).
+CREATE TABLE blob_items (id INTEGER PRIMARY KEY, b BLOB NULL);
+INSERT INTO blob_items VALUES (1, x'6162'), (2, x'6164'), (3, null);
+
+CREATE TABLE blob_set (v BLOB NULL);
+INSERT INTO blob_set VALUES (x'6162'), (x'6169');
+
+-- select-list position: byte-equality hit, non-match, condition-NULL → NULL
+SELECT id, b IN (SELECT v FROM blob_set) AS in_set FROM blob_items ORDER BY id;
+→ [{"id":1,"in_set":true},{"id":2,"in_set":false},{"id":3,"in_set":null}]
+
+-- NOT IN mirrors IN
+SELECT id, b NOT IN (SELECT v FROM blob_set) AS notin_set FROM blob_items ORDER BY id;
+→ [{"id":1,"notin_set":false},{"id":2,"notin_set":true},{"id":3,"notin_set":null}]
+
+-- WHERE position is rewritten to a semi join and never touches the set-probe
+-- tree — must agree with the select-list result above.
+SELECT id FROM blob_items WHERE b IN (SELECT v FROM blob_set) ORDER BY id;
+→ [{"id":1}]
+
+-- CASE WHEN wrapping the IN — exercises the set probe through a branch
+SELECT id, CASE WHEN b IN (SELECT v FROM blob_set) THEN 'y' ELSE 'n' END AS r FROM blob_items ORDER BY id;
+→ [{"id":1,"r":"y"},{"id":2,"r":"n"},{"id":3,"r":"n"}]
+
+-- Inner result set contains a NULL: a miss becomes NULL instead of false
+CREATE TABLE blob_set_n (v BLOB NULL);
+INSERT INTO blob_set_n VALUES (x'6162'), (null);
+
+SELECT id, b IN (SELECT v FROM blob_set_n) AS in_set FROM blob_items ORDER BY id;
+→ [{"id":1,"in_set":true},{"id":2,"in_set":null},{"id":3,"in_set":null}]
+
+SELECT id, b NOT IN (SELECT v FROM blob_set_n) AS notin_set FROM blob_items ORDER BY id;
+→ [{"id":1,"notin_set":false},{"id":2,"notin_set":null},{"id":3,"notin_set":null}]
+
+-- TEXT vs BLOB never match, even with byte-identical content — cross
+-- storage-class comparison (BLOB sorts above TEXT; see compareSqlValuesFast).
+SELECT ('ab' IN (SELECT v FROM blob_set)) AS text_in_blobs;
+→ [{"text_in_blobs":false}]
+
+-- Correlated inner takes the streaming path, not the set-probe tree — this
+-- shape never built a BTree even before the fix, kept here for parity.
+CREATE TABLE blob_outer (id INTEGER PRIMARY KEY, tag TEXT, b BLOB NULL);
+INSERT INTO blob_outer VALUES (1, 'x', x'6162'), (2, 'x', x'6164'), (3, 'y', x'6162');
+
+CREATE TABLE blob_inner (tag TEXT, v BLOB NULL);
+INSERT INTO blob_inner VALUES ('x', x'6162'), ('x', null), ('y', x'6169');
+
+SELECT id, b IN (SELECT v FROM blob_inner WHERE tag = blob_outer.tag) AS r FROM blob_outer ORDER BY id;
+→ [{"id":1,"r":true},{"id":2,"r":null},{"id":3,"r":false}]
+
+DROP TABLE blob_inner;
+DROP TABLE blob_outer;
+DROP TABLE blob_set_n;
+DROP TABLE blob_set;
+DROP TABLE blob_items;
+
+-- Cleanup
+DROP TABLE nullable_ids;
+DROP TABLE items;
+DROP TABLE categories;

package/test/logic/07.7-scalar-agg-decorrelation.sqllogic

@@ -0,0 +1,197 @@
+-- 07.7-scalar-agg-decorrelation.sqllogic
+-- Correlated scalar-aggregate subqueries in the SELECT list are decorrelated
+-- into grouped left joins (rule scalar-agg-decorrelation). These tests pin the
+-- observable semantics of both the decorrelated shapes and the shapes the rule
+-- must reject (which stay on the correlated per-row path).
+
+-- Setup
+CREATE TABLE p (id INTEGER PRIMARY KEY, k INTEGER NULL, grp TEXT);
+CREATE TABLE c (id INTEGER PRIMARY KEY, pid INTEGER NULL, v INTEGER NULL, tag TEXT);
+CREATE TABLE d (id INTEGER PRIMARY KEY, k INTEGER NULL);
+CREATE TABLE cc (id INTEGER PRIMARY KEY, pid INTEGER NULL, k INTEGER NULL, v INTEGER);
+
+INSERT INTO p VALUES (1, 10, 'a'), (2, 20, 'b'), (3, null, 'c'), (4, 10, 'd');
+INSERT INTO c VALUES (1, 1, 5, 'x'), (2, 1, 7, 'y'), (3, 2, null, 'z'), (4, null, 100, 'w');
+INSERT INTO d VALUES (1, 10), (2, 10), (3, 20), (4, null);
+INSERT INTO cc VALUES (1, 1, 10, 1), (2, 1, 99, 1), (3, 4, 10, 1);
+
+-- count(*): empty group must yield 0 (the "count bug"), not NULL
+SELECT p.id, (SELECT count(*) FROM c WHERE c.pid = p.id) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":2},{"id":2,"n":1},{"id":3,"n":0},{"id":4,"n":0}]
+
+-- count(v): group exists but all values NULL → 0 via the aggregate itself,
+-- NOT via the empty-group marker (distinguishes join-miss from all-NULL input)
+SELECT p.id, (SELECT count(c.v) FROM c WHERE c.pid = p.id) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":2},{"id":2,"n":0},{"id":3,"n":0},{"id":4,"n":0}]
+
+-- sum: NULL on empty group AND on all-NULL input (no marker needed)
+SELECT p.id, (SELECT sum(c.v) FROM c WHERE c.pid = p.id) AS s FROM p ORDER BY p.id;
+→ [{"id":1,"s":12},{"id":2,"s":null},{"id":3,"s":null},{"id":4,"s":null}]
+
+-- min / max: NULL on empty group
+SELECT p.id, (SELECT min(c.v) FROM c WHERE c.pid = p.id) AS mn, (SELECT max(c.v) FROM c WHERE c.pid = p.id) AS mx FROM p ORDER BY p.id;
+→ [{"id":1,"mn":5,"mx":7},{"id":2,"mn":null,"mx":null},{"id":3,"mn":null,"mx":null},{"id":4,"mn":null,"mx":null}]
+
+-- avg: NULL on empty group
+SELECT p.id, (SELECT avg(c.v) FROM c WHERE c.pid = p.id) AS a FROM p ORDER BY p.id;
+→ [{"id":1,"a":6},{"id":2,"a":null},{"id":3,"a":null},{"id":4,"a":null}]
+
+-- total: 0.0 on empty group (non-NULL empty value → marker CASE path, REAL)
+SELECT p.id, (SELECT total(c.v) FROM c WHERE c.pid = p.id) AS t FROM p ORDER BY p.id;
+→ [{"id":1,"t":12},{"id":2,"t":0},{"id":3,"t":0},{"id":4,"t":0}]
+
+-- Duplicate outer key values + NULL outer key: two outer rows share k=10 and
+-- each sees the same group; the NULL key never matches (empty value, not join junk)
+SELECT p.id, (SELECT count(*) FROM d WHERE d.k = p.k) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":2},{"id":2,"n":1},{"id":3,"n":0},{"id":4,"n":2}]
+
+-- NULL inner keys: the d.k IS NULL row groups but can never match any outer row
+SELECT p.id, (SELECT sum(d.id) FROM d WHERE d.k = p.k) AS s FROM p ORDER BY p.id;
+→ [{"id":1,"s":3},{"id":2,"s":3},{"id":3,"s":null},{"id":4,"s":3}]
+
+-- Composite (multi-conjunct) correlation
+SELECT p.id, (SELECT count(*) FROM cc WHERE cc.pid = p.id AND cc.k = p.k) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":1},{"id":2,"n":0},{"id":3,"n":0},{"id":4,"n":1}]
+
+-- Residual inner-only predicate alongside the correlation
+SELECT p.id, (SELECT count(*) FROM c WHERE c.pid = p.id AND c.v > 5) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":1},{"id":2,"n":0},{"id":3,"n":0},{"id":4,"n":0}]
+
+-- Wrapped subquery: only the inner node is substituted, wrapper preserved
+SELECT p.id, coalesce((SELECT sum(c.v) FROM c WHERE c.pid = p.id), -1) AS s FROM p ORDER BY p.id;
+→ [{"id":1,"s":12},{"id":2,"s":-1},{"id":3,"s":-1},{"id":4,"s":-1}]
+
+-- Subquery inside a scalar expression
+SELECT p.id, 1 + (SELECT count(*) FROM c WHERE c.pid = p.id) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":3},{"id":2,"n":2},{"id":3,"n":1},{"id":4,"n":1}]
+
+-- Multiple correlated subqueries in one SELECT list (independent joins)
+SELECT p.id, (SELECT count(*) FROM c WHERE c.pid = p.id) AS n, (SELECT count(*) FROM d WHERE d.k = p.k) AS m FROM p ORDER BY p.id;
+→ [{"id":1,"n":2,"m":2},{"id":2,"n":1,"m":1},{"id":3,"n":0,"m":0},{"id":4,"n":0,"m":2}]
+
+-- Outer reference in the aggregate argument (remapped to the equated inner column)
+SELECT p.id, (SELECT sum(c.v + p.id) FROM c WHERE c.pid = p.id) AS s FROM p ORDER BY p.id;
+→ [{"id":1,"s":14},{"id":2,"s":null},{"id":3,"s":null},{"id":4,"s":null}]
+
+-- group_concat: NULL on empty group (all values NULL also concatenates to NULL)
+SELECT p.id, (SELECT group_concat(c.tag) FROM c WHERE c.pid = p.id) AS g FROM p ORDER BY p.id;
+→ [{"id":1,"g":"x,y"},{"id":2,"g":"z"},{"id":3,"g":null},{"id":4,"g":null}]
+
+-- json_group_array: empty group matches the correlated/zero-row behavior
+SELECT p.id, (SELECT json_group_array(c.v) FROM c WHERE c.pid = p.id) AS j FROM p ORDER BY p.id;
+→ [{"id":1,"j":[5,7]},{"id":2,"j":[null]},{"id":3,"j":null},{"id":4,"j":null}]
+
+-- DISTINCT aggregate
+SELECT p.id, (SELECT count(DISTINCT d.k) FROM d WHERE d.k = p.k) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":1},{"id":2,"n":1},{"id":3,"n":0},{"id":4,"n":1}]
+
+-- Rejected shapes: these stay on the correlated per-row path and must keep
+-- today's semantics.
+
+-- Non-aggregate LIMIT 1 subquery (aggregate root required)
+SELECT p.id, (SELECT c.v FROM c WHERE c.pid = p.id ORDER BY c.v DESC LIMIT 1) AS v FROM p ORDER BY p.id;
+→ [{"id":1,"v":7},{"id":2,"v":null},{"id":3,"v":null},{"id":4,"v":null}]
+
+-- Non-aggregate multi-row subquery: the >1-row runtime error is preserved
+SELECT p.id, (SELECT c.v FROM c WHERE c.pid = p.id) AS v FROM p WHERE p.id = 1;
+-- error: Scalar subquery returned more than one row
+
+-- Non-equi correlation (rejected: stays correlated, still correct)
+SELECT p.id, (SELECT count(*) FROM c WHERE c.pid < p.id) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":0},{"id":2,"n":2},{"id":3,"n":3},{"id":4,"n":3}]
+
+-- Uncorrelated scalar subquery (untouched)
+SELECT p.id, (SELECT count(*) FROM c) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":4},{"id":2,"n":4},{"id":3,"n":4},{"id":4,"n":4}]
+
+-- GROUP BY inside a scalar subquery. This used to be rejected at build time as a
+-- two-column subquery, because a grouped select list of only aggregates leaked
+-- the grouping key into the output (bug-grouped-aggregate-only-select-returns-extra-column).
+-- It is a legal one-column subquery; the rule still rejects it (grouped body, not
+-- a bare scalar aggregate) so it stays on the correlated per-row path.
+SELECT p.id, (SELECT count(*) FROM cc WHERE cc.pid = p.id GROUP BY cc.pid) AS n FROM p WHERE p.id = 1;
+→ [{"id":1,"n":2}]
+
+-- An outer row matching no inner row produces *no group at all*, so the scalar
+-- subquery is NULL — not the 0 the ungrouped count(*) would give (ids 2 and 3).
+SELECT p.id, (SELECT count(*) FROM cc WHERE cc.pid = p.id GROUP BY cc.pid) AS n FROM p ORDER BY p.id;
+→ [{"id":1,"n":2},{"id":2,"n":null},{"id":3,"n":null},{"id":4,"n":1}]
+
+-- Grouping on a column the correlation does not pin can yield several groups,
+-- and the >1-row runtime error still applies.
+SELECT p.id, (SELECT count(*) FROM cc WHERE cc.pid = p.id GROUP BY cc.k) AS n FROM p WHERE p.id = 1;
+-- error: Scalar subquery returned more than one row
+
+-- Weak collation on the correlation + outer ref in the aggregate argument:
+-- the remap is not value-faithful, so the rule bails; results stay correct.
+CREATE TABLE nc (id INTEGER PRIMARY KEY, t TEXT COLLATE NOCASE);
+INSERT INTO nc VALUES (1, 'A'), (2, 'a'), (3, 'B');
+SELECT p.grp, (SELECT group_concat(p.grp) FROM nc WHERE nc.t = p.grp) AS g FROM p WHERE p.id = 1;
+→ [{"grp":"a","g":"a,a"}]
+
+-- ORDER BY anchor (rule scalar-agg-decorrelation-sort): a correlated
+-- scalar-aggregate subquery in a sort key is decorrelated into the same grouped
+-- LEFT join, capped by a pass-through Project so the Sort's output shape is
+-- unchanged. These pin the ordering semantics against the correlated baseline.
+
+-- Basic: order by the correlated count (asc), id tiebreak. Empty groups (id 3,4
+-- → 0) sort first.
+SELECT p.id FROM p ORDER BY (SELECT count(*) FROM c WHERE c.pid = p.id), p.id;
+→ [{"id":3},{"id":4},{"id":2},{"id":1}]
+
+-- DESC + LIMIT above the Sort: the pass-through Project sits between Sort and
+-- Limit, so Limit still caps the correct (unchanged) row set.
+SELECT p.id FROM p ORDER BY (SELECT count(*) FROM c WHERE c.pid = p.id) DESC, p.id LIMIT 2;
+→ [{"id":1},{"id":2}]
+
+-- Empty-group NULL ordering: sum is NULL on empty/all-NULL groups (id 2,3,4).
+-- NULLS FIRST puts them ahead of id 1 (sum 12).
+SELECT p.id FROM p ORDER BY (SELECT sum(c.v) FROM c WHERE c.pid = p.id) NULLS FIRST, p.id;
+→ [{"id":2},{"id":3},{"id":4},{"id":1}]
+
+-- Same key, NULLS LAST: the NULLs move to the end.
+SELECT p.id FROM p ORDER BY (SELECT sum(c.v) FROM c WHERE c.pid = p.id) NULLS LAST, p.id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Same subquery in the SELECT list AND the ORDER BY: two distinct anchors
+-- (Project + Sort) over the same subquery shape; the inner is scanned once and
+-- both resolve correctly (no double-decorrelation / conflict).
+SELECT p.id, (SELECT count(*) FROM c WHERE c.pid = p.id) AS n FROM p ORDER BY (SELECT count(*) FROM c WHERE c.pid = p.id), p.id;
+→ [{"id":3,"n":0},{"id":4,"n":0},{"id":2,"n":1},{"id":1,"n":2}]
+
+-- Multiple ORDER BY keys, only the second correlated: p.k (plain column) then
+-- the count breaks the k=10 tie (id 1 count 2 vs id 4 count 0).
+SELECT p.id FROM p WHERE p.k IS NOT NULL ORDER BY p.k, (SELECT count(*) FROM c WHERE c.pid = p.id), p.id;
+→ [{"id":4},{"id":1},{"id":2}]
+
+-- ORDER BY an aggregate scalar subquery over a GROUP BY query. The subquery's
+-- own count() must resolve as its OWN aggregate, not fingerprint-match the outer
+-- query's count() and bind to its output alias (the scope-leak fixed by
+-- fix/order-by-aggregate-subquery-scope-leak — a nested SELECT no longer inherits
+-- the enclosing query's aggregate context).
+-- Correlated form: order groups by children-per-key. d.k matches: k=10→2, k=20→1,
+-- k=null→0 (null = null is never true), so null sorts first, then 20, then 10.
+SELECT p.k, count(*) AS cnt FROM p GROUP BY p.k ORDER BY (SELECT count(*) FROM d WHERE d.k = p.k), p.k;
+→ [{"k":null,"cnt":1},{"k":20,"cnt":1},{"k":10,"cnt":2}]
+
+-- Uncorrelated form (also broke before the fix): the subquery is a constant 4 for
+-- every group, so the sort collapses to the p.k tiebreak (NULLs first on ASC).
+SELECT p.k, count(*) AS cnt FROM p GROUP BY p.k ORDER BY (SELECT count(*) FROM d), p.k;
+→ [{"k":null,"cnt":1},{"k":10,"cnt":2},{"k":20,"cnt":1}]
+
+-- Stripping projection: p.k is not selected, so the correlation column is absent
+-- from the Sort's source and the subquery stays correlated — still correct (the
+-- runtime reads p.k from the live base scan below the Project). count(d.k=p.k):
+-- p1/p4→2, p2→1, p3(null)→0. Ascending, id tiebreak.
+SELECT p.id FROM p ORDER BY (SELECT count(*) FROM d WHERE d.k = p.k), p.id;
+→ [{"id":3},{"id":2},{"id":1},{"id":4}]
+
+-- Bail-but-correct: a non-equi correlation (c.pid < p.id) stays on the
+-- correlated per-row path; the ordering is still correct.
+SELECT p.id FROM p ORDER BY (SELECT count(*) FROM c WHERE c.pid < p.id), p.id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Shape invariance: the decorrelated Sort feeds a derived table consumed by
+-- SELECT * — only the original columns (id, grp) appear, no leaked join columns.
+SELECT * FROM (SELECT p.id, p.grp FROM p ORDER BY (SELECT count(*) FROM c WHERE c.pid = p.id)) sub ORDER BY sub.id;
+→ [{"id":1,"grp":"a"},{"id":2,"grp":"b"},{"id":3,"grp":"c"},{"id":4,"grp":"d"}]