@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/13.2-cte-bind-params.sqllogic

@@ -0,0 +1,98 @@
+-- Testing recursive CTEs with bind parameters in termination conditions
+-- Uses -- params: directive to supply bind parameter values
+
+-- Setup: hierarchy table for tree-walking tests
+CREATE TABLE Node (id INTEGER PRIMARY KEY, parent_id INTEGER NULL, name TEXT);
+INSERT INTO Node VALUES
+  (1, null, 'Root'),
+  (2, 1, 'A'),
+  (3, 1, 'B'),
+  (4, 2, 'A1'),
+  (5, 2, 'A2'),
+  (6, 3, 'B1');
+
+-- Test 1: Bind parameter in base case seed (WHERE id = ?)
+-- params: [1]
+WITH RECURSIVE tree(id) AS (
+  SELECT id FROM Node WHERE id = ?
+  UNION ALL
+  SELECT N.id FROM Node N JOIN tree T ON N.parent_id = T.id
+)
+SELECT id FROM tree ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6}]
+
+-- Test 2: Different seed value via bind parameter
+-- params: [2]
+WITH RECURSIVE tree(id) AS (
+  SELECT id FROM Node WHERE id = ?
+  UNION ALL
+  SELECT N.id FROM Node N JOIN tree T ON N.parent_id = T.id
+)
+SELECT id FROM tree ORDER BY id;
+→ [{"id":2},{"id":4},{"id":5}]
+
+-- Test 3: Bind parameter in recursive termination (depth < ?)
+-- params: [2]
+WITH RECURSIVE tree(id, depth) AS (
+  SELECT id, 0 FROM Node WHERE parent_id IS NULL
+  UNION ALL
+  SELECT N.id, T.depth + 1 FROM Node N JOIN tree T ON N.parent_id = T.id
+  WHERE T.depth + 1 < ?
+)
+SELECT id, depth FROM tree ORDER BY depth, id;
+→ [{"id":1,"depth":0},{"id":2,"depth":1},{"id":3,"depth":1}]
+
+-- Test 4: Bind parameter as exclusion (id != ?)
+-- params: [4]
+WITH RECURSIVE tree(id) AS (
+  SELECT id FROM Node WHERE parent_id IS NULL
+  UNION ALL
+  SELECT N.id FROM Node N JOIN tree T ON N.parent_id = T.id
+  WHERE N.id != ?
+)
+SELECT id FROM tree ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":5},{"id":6}]
+
+-- Test 5: Multiple bind parameters — seed + termination
+-- params: [2, 1]
+WITH RECURSIVE tree(id, depth) AS (
+  SELECT id, 0 FROM Node WHERE id = ?
+  UNION ALL
+  SELECT N.id, T.depth + 1 FROM Node N JOIN tree T ON N.parent_id = T.id
+  WHERE T.depth < ?
+)
+SELECT id, depth FROM tree ORDER BY depth, id;
+→ [{"id":2,"depth":0},{"id":4,"depth":1},{"id":5,"depth":1}]
+
+-- Test 6: Bind parameter in both seed and exclusion
+-- params: [1, 3]
+WITH RECURSIVE tree(id) AS (
+  SELECT id FROM Node WHERE id = ?
+  UNION ALL
+  SELECT N.id FROM Node N JOIN tree T ON N.parent_id = T.id
+  WHERE N.id != ?
+)
+SELECT id FROM tree ORDER BY id;
+→ [{"id":1},{"id":2},{"id":4},{"id":5}]
+
+-- Test 7: Simple counting CTE with parameterized limit
+-- params: [4]
+WITH RECURSIVE counter(n) AS (
+  SELECT 1
+  UNION ALL
+  SELECT n + 1 FROM counter WHERE n < ?
+)
+SELECT n FROM counter ORDER BY n;
+→ [{"n":1},{"n":2},{"n":3},{"n":4}]
+
+-- Test 8: Parameterized start and limit in counting CTE
+-- params: [10, 13]
+WITH RECURSIVE counter(n) AS (
+  SELECT ?
+  UNION ALL
+  SELECT n + 1 FROM counter WHERE n < ?
+)
+SELECT n FROM counter ORDER BY n;
+→ [{"n":10},{"n":11},{"n":12},{"n":13}]
+
+DROP TABLE Node;

package/test/logic/13.3-cte-edge-cases.sqllogic

@@ -0,0 +1,120 @@
+-- cte-edge-cases.sqllogic - CTE edge cases
+
+-- Setup
+create table ct (id integer primary key, val text, parent_id integer null);
+insert into ct values (1, 'root', null), (2, 'child1', 1), (3, 'child2', 1), (4, 'leaf', 2);
+
+-- ===== CTE referenced multiple times in same query =====
+
+with shared as (select id, val from ct where parent_id is not null)
+select a.id, b.id as b_id
+from shared a cross join shared b
+where a.id < b.id
+order by a.id, b.id;
+→ [{"id":2,"b_id":3},{"id":2,"b_id":4},{"id":3,"b_id":4}]
+
+-- ===== CTE referencing another CTE =====
+
+with
+  cte1 as (select id, val from ct where id <= 2),
+  cte2 as (select id, val from cte1 where id = 1)
+select * from cte2;
+→ [{"id":1,"val":"root"}]
+
+-- ===== CTE chain of 3 =====
+
+with
+  a as (select id from ct),
+  b as (select id from a where id > 1),
+  c as (select id from b where id > 2)
+select * from c order by id;
+→ [{"id":3},{"id":4}]
+
+-- ===== Recursive CTE: 0 iterations =====
+
+-- Base case produces 0 rows, recursion never starts
+with recursive r(n) as (
+  select 1 where false
+  union all
+  select n + 1 from r where n < 5
+)
+select * from r;
+→ []
+
+-- ===== Recursive CTE: 1 iteration =====
+
+-- Base case produces 1 row, recursive step produces 0
+with recursive r(n) as (
+  select 1
+  union all
+  select n + 1 from r where n < 1
+)
+select * from r;
+→ [{"n":1}]
+
+-- ===== CTE with EXISTS check =====
+
+-- Existing value
+with data as (select id from ct where val = 'root')
+select exists (select 1 from data) as has_root;
+→ [{"has_root":true}]
+
+-- Non-existent value
+with data as (select id from ct where val = 'nonexistent')
+select exists (select 1 from data) as has_it;
+→ [{"has_it":false}]
+
+-- ===== CTE used in UPDATE — the leading WITH is now in scope for SET/WHERE =====
+-- UPDATE/DELETE previously ignored the statement's WITH clause, so a CTE read in a
+-- SET value / WHERE subquery failed to resolve ("not found"). The CTE-name DML write
+-- target work threads the statement's CTEs into scope, closing that read gap.
+
+create table ct_target (id integer primary key, val text);
+insert into ct_target values (1, 'old');
+-- run
+
+with src as (select val from ct where id = 1)
+update ct_target set val = (select val from src) where id = 1;
+-- run
+
+-- The CTE read resolved: ct.val where id=1 is 'root'.
+select * from ct_target;
+→ [{"id":1,"val":"root"}]
+
+-- ===== CTE used in DELETE — the leading WITH is likewise in scope for the WHERE =====
+
+with to_del as (select id from ct_target)
+delete from ct_target where id in (select id from to_del);
+-- run
+
+-- The CTE read resolved: every ct_target row whose id is in to_del was deleted.
+select count(*) as cnt from ct_target;
+→ [{"cnt":0}]
+
+drop table ct_target;
+-- run
+
+-- ===== CTE with set operations =====
+
+-- UNION
+with
+  a as (select id from ct where id <= 2),
+  b as (select id from ct where id >= 2)
+select id from a
+union
+select id from b
+order by id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- INTERSECT
+with
+  a as (select id from ct where id <= 2),
+  b as (select id from ct where id >= 2)
+select id from a
+intersect
+select id from b
+order by id;
+→ [{"id":2}]
+
+-- Cleanup
+drop table ct;

package/test/logic/13.4-cte-extras.sqllogic

@@ -0,0 +1,98 @@
+-- adapted from SQLite test/with1.test, test/with2.test, test/with3.test, test/with4.test
+-- CTE surface gaps: CTE name shadowing a base table, VALUES as CTE source,
+-- LIMIT applied inside a recursive CTE definition, nested WITH inside a recursive
+-- CTE base case, and CTE used inside a VIEW definition.
+
+-- =============================================================================
+-- CTE shadowing a base table of the same name
+-- =============================================================================
+
+create table cte_t (id integer primary key, val text);
+insert into cte_t values (1, 'base'), (2, 'base2');
+
+-- Inside the WITH scope, the CTE name takes precedence over the base table
+with cte_t as (select 99 as id, 'cte' as val)
+select id, val from cte_t;
+→ [{"id":99,"val":"cte"}]
+
+-- Outside the WITH scope, the base table is back
+select id, val from cte_t order by id;
+→ [{"id":1,"val":"base"},{"id":2,"val":"base2"}]
+
+drop table cte_t;
+
+-- =============================================================================
+-- VALUES clause as direct CTE source — now supported via the orthogonal
+-- QueryExpr surface (ticket: query-expr-ast-parser-unification). Pin the
+-- positive behaviour so a future regression here would surface here, not
+-- only in the new 01.9-query-expr-values suite.
+-- =============================================================================
+
+with v(a, b) as (
+  values (1, 'x'), (2, 'y'), (3, 'z')
+)
+select a, b from v order by a;
+→ [{"a":1,"b":"x"},{"a":2,"b":"y"},{"a":3,"b":"z"}]
+
+-- =============================================================================
+-- LIMIT applied inside a recursive CTE definition
+-- =============================================================================
+
+with recursive lim_cnt(n) as (
+  select 1
+  union all
+  select n + 1 from lim_cnt where n < 1000
+  limit 5
+)
+select n from lim_cnt order by n;
+→ [{"n":1},{"n":2},{"n":3},{"n":4},{"n":5}]
+
+-- LIMIT 0 yields zero rows (no early base-case row leakage)
+with recursive lim_zero(n) as (
+  select 1
+  union all
+  select n + 1 from lim_zero where n < 1000
+  limit 0
+)
+select n from lim_zero;
+→ []
+
+-- =============================================================================
+-- Nested WITH inside the base case of a recursive CTE — accepted by
+-- parseQueryExpr (the inner WITH attaches to the inner SELECT, then the
+-- recursive UNION ALL leg references the outer CTE name).
+-- =============================================================================
+
+with recursive r(n) as (
+  with base as (select 1 as start)
+  select start from base
+  union all
+  select n + 1 from r where n < 3
+)
+select n from r order by n;
+→ [{"n":1},{"n":2},{"n":3}]
+
+-- =============================================================================
+-- CTE inside a VIEW definition — CREATE VIEW body may begin with a WITH clause.
+-- =============================================================================
+
+create table cte_src (id integer primary key, val integer);
+insert into cte_src values (1, 10), (2, 20), (3, 30);
+
+create view cte_view as
+  with positives as (select id, val from cte_src where val > 15)
+  select id, val from positives;
+
+select id, val from cte_view order by id;
+→ [{"id":2,"val":20},{"id":3,"val":30}]
+
+drop view cte_view;
+drop table cte_src;
+
+-- =============================================================================
+-- CTE column count mismatch (declared columns vs SELECT columns)
+-- =============================================================================
+
+with bad(a, b) as (select 1)
+select * from bad;
+-- error: declared columns

package/test/logic/13.5-cte-join-order.sqllogic

@@ -0,0 +1,166 @@
+-- 13.5-cte-join-order.sqllogic - a WITH-clause reference must resolve the same
+-- whichever side of a join it appears on
+--
+-- Regression guard for `bug-cte-reference-as-second-join-source-fails-at-runtime`.
+--
+-- Every FROM source gets a scope mapping its column names to plan attribute ids, and
+-- a join combines the two peer scopes with MultiScope (first match wins). Each source
+-- scope used to be built with the *enclosing* query's scope as its fallback parent, so
+-- when MultiScope asked the LEFT peer about a name it did not own, the left peer did
+-- not answer "no" — it forwarded the question to the enclosing scope and answered from
+-- there. The right peer was never consulted.
+--
+-- `createCTEScope` registers a qualified `c.col` symbol for every WITH-clause column in
+-- the enclosing scope, bound to the CTE *body's* attribute ids (not the ids a
+-- CTEReferenceNode republishes). So `… from r join c on c.rid = r.id` resolved `c.rid`
+-- through `r`'s scope → miss → enclosing scope → the body's attribute id, which nothing
+-- below that point publishes, and the query died at runtime with
+-- "No row context found for column rid". The mirrored `from c join r on …` worked only
+-- because there the CTE reference is the left peer and answers first.
+--
+-- Fix: a FROM source's scope holds only its own columns (parented on EmptyScope); the
+-- enclosing-query fallback is composed once by the consumer (ShadowScope).
+--
+-- Invariant pinned here: for each shape, both join orders return the same rows, and the
+-- rows are the correct ones (row data, not just "did not crash").
+
+create table r (id integer primary key, qty integer, label text);
+insert into r values (1, 10, 'a'), (2, 20, 'b'), (3, 30, 'c');
+
+create table o (oid integer primary key, rid integer, cat text, qty integer);
+insert into o values (100, 1, 'x', 10), (101, 2, 'y', 20), (102, 2, 'z', 99), (103, 9, 'w', 5);
+
+create table s (k text primary key, note text);
+insert into s values ('x', 'X'), ('y', 'Y');
+
+-- =============================================================================
+-- The reported shape: WITH clause as the SECOND (right) join source. Before the
+-- fix this threw "No row context found for column rid"; the mirrored order below
+-- always worked, so the two must agree.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select count(*) as n from r join c on c.rid = r.id;
+→ [{"n":3}]
+
+with c as (select cat, qty, rid from o)
+select count(*) as n from c join r on c.rid = r.id;
+→ [{"n":3}]
+
+-- Same shapes projecting real columns, so a wrong-rows regression is caught too.
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from r join c on c.rid = r.id order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"},{"id":2,"cat":"z"}]
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from c join r on c.rid = r.id order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"},{"id":2,"cat":"z"}]
+
+-- =============================================================================
+-- Operand-swapped ON condition — `c.rid` is looked up second rather than first.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from r join c on r.id = c.rid order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"},{"id":2,"cat":"z"}]
+
+-- =============================================================================
+-- Non-key join column: the join cannot be answered by a primary-key seek, so a
+-- different access path carries the same column reference.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from r join c on c.qty = r.qty order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"}]
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from c join r on c.qty = r.qty order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"}]
+
+-- =============================================================================
+-- LEFT JOIN with the WITH clause second — the null-extended side is the CTE.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat from r left join c on c.rid = r.id order by r.id, c.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"},{"id":2,"cat":"z"},{"id":3,"cat":null}]
+
+-- =============================================================================
+-- Three-way join with the WITH clause in the MIDDLE: `(r join c) join s`. The
+-- left peer of the outer join is itself a join, so its scope is a nested
+-- MultiScope — the fall-through has to work through two levels.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select count(*) as n from r join c on c.rid = r.id join s on s.k = c.cat;
+→ [{"n":2}]
+
+with c as (select cat, qty, rid from o)
+select r.id, c.cat, s.note from r join c on c.rid = r.id join s on s.k = c.cat
+order by r.id, c.cat;
+→ [{"id":1,"cat":"x","note":"X"},{"id":2,"cat":"y","note":"Y"}]
+
+-- =============================================================================
+-- The aliased spelling passed before the fix (the enclosing scope registers
+-- `c.rid`, not `x.rid`, so the leak had nothing to hand back). Pinned so the fix
+-- does not regress the shape that already worked.
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select r.id, x.cat from r join c as x on x.rid = r.id order by r.id, x.cat;
+→ [{"id":1,"cat":"x"},{"id":2,"cat":"y"},{"id":2,"cat":"z"}]
+
+-- =============================================================================
+-- Naming a WITH-clause column without the CTE in FROM is a plain unresolved-column
+-- error, not a confusing runtime row-context failure. (Before the fix, the stale
+-- `c.cat → CTE body attribute id` registration in the enclosing scope made this
+-- resolve to an id nothing publishes.)
+-- =============================================================================
+
+with c as (select cat, qty, rid from o)
+select c.cat from r;
+-- error: c.cat
+
+-- =============================================================================
+-- The shapes that ONLY the deleted registration could plausibly have served: a
+-- `cteName.column` reference from somewhere other than the CTE's own SELECT list.
+-- Each one names the CTE in a FROM, so it resolves through the reference's own
+-- republished attribute ids — the ids that actually reach the runtime.
+-- =============================================================================
+
+-- CTE column read from a nested subquery, with the CTE in the OUTER from.
+
+with c as (select rid, cat from o)
+select c.rid, (select count(*) from r where r.id = c.rid) as n from c order by c.rid, c.cat;
+→ [{"rid":1,"n":1},{"rid":2,"n":1},{"rid":2,"n":1},{"rid":9,"n":0}]
+
+-- CTE in an UPDATE's WHERE subquery.
+
+with c as (select rid from o where cat = 'x')
+update r set label = 'hit' where id in (select c.rid from c);
+select id, label from r order by id;
+→ [{"id":1,"label":"hit"},{"id":2,"label":"b"},{"id":3,"label":"c"}]
+
+-- CTE in an UPDATE's SET subquery, correlated to the update target.
+
+with c as (select rid, cat from o where cat <> 'z')
+update r set label = coalesce((select c.cat from c where c.rid = r.id), label);
+select id, label from r order by id;
+→ [{"id":1,"label":"x"},{"id":2,"label":"y"},{"id":3,"label":"c"}]
+
+-- CTE in a DELETE's WHERE subquery, with RETURNING.
+
+with c as (select rid from o where cat = 'y')
+delete from r where id in (select c.rid from c) returning id, label;
+→ [{"id":2,"label":"y"}]
+
+-- CTE read from an UPDATE's RETURNING clause.
+
+with c as (select rid from o)
+update r set qty = qty + 1 returning id, (select count(*) from c) as total;
+→ [{"id":1,"total":4},{"id":3,"total":4}]
+
+drop table s;
+drop table o;
+drop table r;