@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/13-cte.sqllogic

@@ -0,0 +1,137 @@
+-- cte.sqllogic - Testing Common Table Expressions (WITH clause)
+
+-- Simple non-recursive CTE
+CREATE TABLE base_t (id INTEGER PRIMARY KEY, name TEXT);
+INSERT INTO base_t VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Charlie');
+
+WITH name_cte AS (
+  SELECT name FROM base_t WHERE id > 1
+)
+SELECT * FROM name_cte ORDER BY name;
+→ [{"name":"Bob"},{"name":"Charlie"}]
+
+-- Multiple CTEs
+WITH
+  cte1 AS (SELECT id, name FROM base_t WHERE id = 1),
+  cte2 AS (SELECT id, name FROM base_t WHERE id = 2)
+SELECT * FROM cte1 UNION ALL SELECT * FROM cte2 ORDER BY id;
+→ [{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]
+
+-- CTE used in INSERT
+CREATE TABLE target_t (id INTEGER, name_upper TEXT);
+WITH source_cte AS (
+  SELECT id, upper(name) as upper_name FROM base_t WHERE id = 3
+)
+INSERT INTO target_t (id, name_upper) SELECT id, upper_name FROM source_cte;
+SELECT * FROM target_t;
+→ [{"id":3,"name_upper":"CHARLIE"}]
+DROP TABLE target_t;
+
+-- Basic Recursive CTE (Counting)
+WITH RECURSIVE counter(n) AS (
+  SELECT 1
+  UNION ALL
+  SELECT n + 1 FROM counter WHERE n < 5
+)
+SELECT n FROM counter ORDER BY n;
+→ [{"n":1},{"n":2},{"n":3},{"n":4},{"n":5}]
+
+-- Recursive CTE with base table (e.g., simple hierarchy/path)
+CREATE TABLE hierarchy (id INTEGER PRIMARY KEY, parent_id INTEGER NULL, name TEXT);
+INSERT INTO hierarchy VALUES (1, null, 'Root'), (2, 1, 'Child A'), (3, 1, 'Child B'), (4, 2, 'Grandchild A1');
+
+WITH RECURSIVE path_cte(id, name, level) AS (
+  SELECT id, name, 0 FROM hierarchy WHERE parent_id IS NULL
+  UNION ALL
+  SELECT h.id, p.name || ' -> ' || h.name, p.level + 1
+  FROM hierarchy h JOIN path_cte p ON h.parent_id = p.id
+)
+SELECT name, level FROM path_cte ORDER BY level, name;
+→ [{"name":"Root","level":0},{"name":"Root -> Child A","level":1},{"name":"Root -> Child B","level":1},{"name":"Root -> Child A -> Grandchild A1","level":2}]
+
+-- Recursive CTE with aliased table in JOIN and qualified SELECT
+-- Bug reproduction: "Table 'E' not found in FROM clause for qualified SELECT *"
+CREATE TABLE Entity (id INTEGER PRIMARY KEY, component_id INTEGER NULL, type TEXT);
+INSERT INTO Entity VALUES (1, null, 'c'), (2, 1, 'c'), (3, 1, 'c'), (4, 2, 'c'), (5, 3, 'x');
+
+-- Test 1: Qualified column reference E.id in recursive part
+WITH RECURSIVE descendants(id) AS (
+  SELECT 1
+  UNION ALL
+  SELECT E.id FROM Entity E
+  JOIN descendants D ON E.component_id = D.id
+  WHERE E.type = 'c'
+)
+SELECT id FROM descendants ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Test 2: SELECT * from recursive CTE with qualified column in recursive part
+WITH RECURSIVE descendants(id) AS (
+  SELECT 1
+  UNION ALL
+  SELECT E.id FROM Entity E
+  JOIN descendants D ON E.component_id = D.id
+  WHERE E.type = 'c'
+)
+SELECT * FROM descendants ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Test 3: E.* in recursive part (qualified SELECT *)
+WITH RECURSIVE descendants(id, component_id, type) AS (
+  SELECT id, component_id, type FROM Entity WHERE id = 1
+  UNION ALL
+  SELECT E.* FROM Entity E
+  JOIN descendants D ON E.component_id = D.id
+  WHERE E.type = 'c'
+)
+SELECT id FROM descendants ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Test 4: D.* (CTE alias) in recursive part
+WITH RECURSIVE descendants(id) AS (
+  SELECT 1
+  UNION ALL
+  SELECT E.id FROM Entity E
+  JOIN descendants D ON E.component_id = D.id
+  WHERE E.type = 'c'
+)
+SELECT D.* FROM descendants D ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Test 5: Internal recursive CTE reference with alias and qualified SELECT *
+-- The recursive reference "descendants D" inside the recursive part
+WITH RECURSIVE descendants(id, component_id, type) AS (
+  SELECT id, component_id, type FROM Entity WHERE id = 1
+  UNION ALL
+  SELECT E.id, E.component_id, E.type FROM Entity E
+  JOIN descendants D ON E.component_id = D.id
+  WHERE E.type = 'c'
+)
+SELECT D.* FROM descendants D ORDER BY id;
+→ [{"id":1,"component_id":null,"type":"c"},{"id":2,"component_id":1,"type":"c"},{"id":3,"component_id":1,"type":"c"},{"id":4,"component_id":2,"type":"c"}]
+
+DROP TABLE Entity;
+
+-- Non-recursive CTE referencing an earlier CTE in the same WITH clause
+WITH
+  cte1 AS (SELECT id, name FROM base_t),
+  cte2 AS (SELECT id, name FROM cte1 WHERE id > 1)
+SELECT * FROM cte2 ORDER BY id;
+→ [{"id":2,"name":"Bob"},{"id":3,"name":"Charlie"}]
+
+-- Non-recursive CTE chain: cte3 references cte2, which references cte1
+WITH
+  cte1 AS (SELECT id, name FROM base_t),
+  cte2 AS (SELECT id, name FROM cte1 WHERE id <= 2),
+  cte3 AS (SELECT name FROM cte2 WHERE id = 1)
+SELECT * FROM cte3;
+→ [{"name":"Alice"}]
+
+-- Non-recursive CTE with explicit column names that differ from the source query
+-- Verifies that column types are mapped by position, not by name
+WITH cte(x, y) AS (SELECT 1 AS a, 'hello' AS b)
+SELECT typeof(x), typeof(y) FROM cte;
+→ [{"typeof(x)":"integer","typeof(y)":"text"}]
+
+DROP TABLE base_t;
+DROP TABLE hierarchy;

package/test/logic/13.1-cte-multiple-recursive.sqllogic

@@ -0,0 +1,104 @@
+-- Testing multiple CTEs in a WITH RECURSIVE clause where later CTEs reference earlier ones
+
+CREATE TABLE Entity (
+  id INTEGER PRIMARY KEY,
+  component_id INTEGER NULL,
+  p_x REAL, p_y REAL, p_z REAL,
+  r_x REAL, r_y REAL, r_z REAL,
+  s_x REAL, s_y REAL, s_z REAL
+);
+
+INSERT INTO Entity VALUES
+  (1, null, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0),
+  (2, 1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0),
+  (3, 1, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0),
+  (4, 2, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5);
+
+-- Test case 1: Simple multiple CTEs in WITH RECURSIVE, second references first
+-- This tests that entity_tree is in scope when building ancestor_walk
+WITH RECURSIVE
+  entity_tree(id) AS (
+    SELECT id FROM Entity WHERE id = 1
+    UNION ALL
+    SELECT E.id FROM Entity E JOIN entity_tree T ON E.component_id = T.id
+  ),
+  ancestor_walk(entity_id, ancestor_id, depth) AS (
+    SELECT E.id, E.component_id, 0
+    FROM Entity E
+    WHERE E.id IN (SELECT id FROM entity_tree) AND E.component_id IS NOT NULL
+    UNION ALL
+    SELECT W.entity_id, P.component_id, W.depth + 1
+    FROM ancestor_walk W
+    JOIN Entity P ON W.ancestor_id = P.id
+    WHERE P.component_id IS NOT NULL
+  )
+SELECT entity_id, ancestor_id, depth
+FROM ancestor_walk
+ORDER BY entity_id, depth DESC;
+→ [{"entity_id":2,"ancestor_id":1,"depth":0},{"entity_id":3,"ancestor_id":1,"depth":0},{"entity_id":4,"ancestor_id":1,"depth":1},{"entity_id":4,"ancestor_id":2,"depth":0}]
+
+-- Test case 2: Full query from the bug report (with joins to get entity attributes)
+WITH RECURSIVE
+  entity_tree(id) AS (
+    SELECT id FROM Entity WHERE id = 1
+    UNION ALL
+    SELECT E.id FROM Entity E JOIN entity_tree T ON E.component_id = T.id
+  ),
+  ancestor_walk(entity_id, ancestor_id, depth) AS (
+    SELECT E.id, E.component_id, 0
+    FROM Entity E
+    WHERE E.id IN (SELECT id FROM entity_tree) AND E.component_id IS NOT NULL
+    UNION ALL
+    SELECT W.entity_id, P.component_id, W.depth + 1
+    FROM ancestor_walk W
+    JOIN Entity P ON W.ancestor_id = P.id
+    WHERE P.component_id IS NOT NULL
+  )
+SELECT
+  W.entity_id,
+  W.ancestor_id,
+  W.depth as ancestor_depth,
+  A.p_x, A.p_y, A.p_z,
+  A.r_x, A.r_y, A.r_z,
+  A.s_x, A.s_y, A.s_z
+FROM ancestor_walk W
+JOIN Entity A ON W.ancestor_id = A.id
+ORDER BY W.entity_id, W.depth DESC;
+→ [{"entity_id":2,"ancestor_id":1,"ancestor_depth":0,"p_x":0.0,"p_y":0.0,"p_z":0.0,"r_x":0.0,"r_y":0.0,"r_z":0.0,"s_x":1.0,"s_y":1.0,"s_z":1.0},{"entity_id":3,"ancestor_id":1,"ancestor_depth":0,"p_x":0.0,"p_y":0.0,"p_z":0.0,"r_x":0.0,"r_y":0.0,"r_z":0.0,"s_x":1.0,"s_y":1.0,"s_z":1.0},{"entity_id":4,"ancestor_id":1,"ancestor_depth":1,"p_x":0.0,"p_y":0.0,"p_z":0.0,"r_x":0.0,"r_y":0.0,"r_z":0.0,"s_x":1.0,"s_y":1.0,"s_z":1.0},{"entity_id":4,"ancestor_id":2,"ancestor_depth":0,"p_x":1.0,"p_y":0.0,"p_z":0.0,"r_x":0.0,"r_y":0.0,"r_z":0.0,"s_x":1.0,"s_y":1.0,"s_z":1.0}]
+
+-- Test case 3: Non-recursive CTE followed by recursive CTE referencing it
+WITH RECURSIVE
+  filtered_entities(id) AS (
+    SELECT id FROM Entity WHERE p_x >= 0.0
+  ),
+  entity_tree(id) AS (
+    SELECT id FROM filtered_entities WHERE id = 1
+    UNION ALL
+    SELECT E.id FROM Entity E JOIN entity_tree T ON E.component_id = T.id
+  )
+SELECT id FROM entity_tree ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":4}]
+
+-- Test case 4: Three CTEs where third references first two
+-- Note: cte3 uses UNION (not UNION ALL) to avoid being treated as recursive
+WITH RECURSIVE
+  cte1(id) AS (
+    SELECT 1
+    UNION ALL
+    SELECT id + 1 FROM cte1 WHERE id < 3
+  ),
+  cte2(id) AS (
+    SELECT 10
+    UNION ALL
+    SELECT id + 1 FROM cte2 WHERE id < 12
+  ),
+  cte3(id) AS (
+    SELECT id FROM cte1
+    UNION
+    SELECT id FROM cte2
+  )
+SELECT id FROM cte3 ORDER BY id;
+→ [{"id":1},{"id":2},{"id":3},{"id":10},{"id":11},{"id":12}]
+
+DROP TABLE Entity;
+

package/test/logic/13.10-cte-qualified-name.sqllogic

@@ -0,0 +1,136 @@
+-- 13.10-cte-qualified-name.sqllogic - a schema-qualified FROM name never binds a CTE
+--
+-- A common table expression lives in no schema, so writing the schema in front of a name
+-- (`main.c`) can only mean the real schema object. `buildFrom` (planner/building/select.ts)
+-- used to look its `cteNodes` map up on the BARE name and ignore `table.schema`, so
+-- `with c as (…) select … from main.c` silently read the CTE — wrong rows, no error.
+--
+-- The write path was already correct (`resolveCteTarget` returns undefined when
+-- `table.schema` is set), as are the lens compiler and the rename rewriter. This file pins
+-- both halves: a qualifier always reaches the schema object, and a BARE name still shadows
+-- to the CTE exactly as before.
+--
+-- See docs/vu-operators.md § Common Table Expressions and the CTE-name DML target.
+
+-- `c` is a real table with 3 rows; `p` has 1 row, so a CTE `c` over `p` has 1 row —
+-- the two disagree, so the wrong binding is always observable.
+create table c (k integer primary key);
+insert into c values (1), (2), (3);
+create table p (id integer primary key);
+insert into p values (10);
+-- run
+
+-- ===== Qualified name reads the real table =====
+
+with c as (select id as k from p) select count(*) as n from main.c;
+→ [{"n":3}]
+
+-- The values come from the real table too, not just the count.
+with c as (select id as k from p) select k from main.c order by k;
+→ [{"k":1},{"k":2},{"k":3}]
+
+-- ===== Bare name still reads the CTE (unchanged) =====
+
+with c as (select id as k from p) select count(*) as n from c;
+→ [{"n":1}]
+
+with c as (select id as k from p) select k from c order by k;
+→ [{"k":10}]
+
+-- ===== Alias on the qualified name still works =====
+
+with c as (select id as k from p) select count(*) as n from main.c as x;
+→ [{"n":3}]
+
+with c as (select id as k from p) select x.k as k from main.c as x order by x.k;
+→ [{"k":1},{"k":2},{"k":3}]
+
+-- ===== Both bindings in ONE statement =====
+-- The join proves the two names resolve independently: 3 real rows × 1 CTE row.
+
+with c as (select id as k from p)
+select count(*) as n from main.c as real_c cross join c as cte_c;
+→ [{"n":3}]
+
+with c as (select id as k from p)
+select real_c.k as rk, cte_c.k as ck from main.c as real_c cross join c as cte_c order by rk;
+→ [{"rk":1,"ck":10},{"rk":2,"ck":10},{"rk":3,"ck":10}]
+
+-- ===== Qualified name inside a subquery =====
+
+with c as (select id as k from p)
+select (select count(*) from main.c) as qualified, (select count(*) from c) as bare;
+→ [{"qualified":3,"bare":1}]
+
+-- ===== Recursion is unaffected — the self-reference is BARE =====
+
+with recursive r(n) as (
+  select 1
+  union all
+  select n + 1 from r where n < 3
+)
+select count(*) as n from r;
+→ [{"n":3}]
+
+-- ...and a qualified reference to a recursive CTE's name is still a schema lookup, which
+-- finds nothing.
+with recursive r(n) as (
+  select 1
+  union all
+  select n + 1 from r where n < 3
+)
+select count(*) as n from main.r;
+-- error: Table not found: main.r
+
+-- ...and the same inside the recursive body: the working-table binding is reached by the
+-- BARE self-reference only, so a qualified self-reference is an ordinary schema lookup.
+with recursive r(n) as (
+  select 1
+  union all
+  select n + 1 from main.r where n < 3
+)
+select count(*) as n from r;
+-- error: Table not found: main.r
+
+-- ===== A qualified name reaches a VIEW too, not only a base table =====
+-- The fall-through arm resolves view / maintained table / base table alike; the CTE used to
+-- win over all three.
+
+create view cv as select k from c;
+-- run
+
+with cv as (select id as k from p) select count(*) as n from main.cv;
+→ [{"n":3}]
+
+with cv as (select id as k from p) select count(*) as n from cv;
+→ [{"n":1}]
+
+drop view cv;
+-- run
+
+-- ===== No same-named schema object: ordinary table-not-found, not a silent CTE bind =====
+-- The qualified miss reports `Table not found: <schema>.<name>` (resolveTableSchema's
+-- explicit-schema arm in planner/building/schema-resolution.ts); the search-path wording
+-- `not found in schema path: …` is the UNqualified miss.
+
+with nope as (select id as k from p) select k from main.nope;
+-- error: Table not found: main.nope
+
+-- ===== Writes are unchanged — already correct before this fix =====
+
+with c as (select id as k from p) insert into main.c values (99);
+
+select k from c order by k;
+→ [{"k":1},{"k":2},{"k":3},{"k":99}]
+
+-- No `with` clause here, so `c` is the plain real table — restore the 3-row state.
+delete from c where k = 99;
+-- run
+
+select count(*) as n from c;
+→ [{"n":3}]
+
+-- Cleanup
+drop table p;
+drop table c;
+-- run