@quereus/quereus 4.20.0 → 4.20.2

package/test/logic/27-window-edge-cases.sqllogic

@@ -0,0 +1,206 @@
+-- Window Function Edge Cases
+-- Tests targeting frame boundary corner cases, partition edge behavior,
+-- and composition scenarios not covered by 07.5-window.sqllogic
+
+-- =============================================================================
+-- Setup
+-- =============================================================================
+
+CREATE TABLE w (id INTEGER PRIMARY KEY, val INTEGER, grp TEXT);
+INSERT INTO w VALUES
+(1, 10, 'A'), (2, 20, 'A'), (3, 30, 'A'), (4, 40, 'B'), (5, 50, 'B');
+
+-- =============================================================================
+-- Zero-width frame: ROWS BETWEEN 0 PRECEDING AND 0 FOLLOWING
+-- Should include only the current row
+-- =============================================================================
+
+SELECT id, val,
+       sum(val) OVER (ORDER BY id ROWS BETWEEN 0 PRECEDING AND 0 FOLLOWING) as s,
+       count(*) OVER (ORDER BY id ROWS BETWEEN 0 PRECEDING AND 0 FOLLOWING) as c
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"s":10,"c":1},{"id":2,"val":20,"s":20,"c":1},{"id":3,"val":30,"s":30,"c":1},{"id":4,"val":40,"s":40,"c":1},{"id":5,"val":50,"s":50,"c":1}]
+
+-- =============================================================================
+-- Frame excluding current row: ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING
+-- Frame is exactly the one row before the current row
+-- =============================================================================
+
+SELECT id, val,
+       sum(val) OVER (ORDER BY id ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) as prev_sum
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"prev_sum":null},{"id":2,"val":20,"prev_sum":10},{"id":3,"val":30,"prev_sum":20},{"id":4,"val":40,"prev_sum":30},{"id":5,"val":50,"prev_sum":40}]
+
+-- Similarly for FOLLOWING: ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING
+SELECT id, val,
+       sum(val) OVER (ORDER BY id ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING) as next_sum
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"next_sum":20},{"id":2,"val":20,"next_sum":30},{"id":3,"val":30,"next_sum":40},{"id":4,"val":40,"next_sum":50},{"id":5,"val":50,"next_sum":null}]
+
+-- =============================================================================
+-- Empty partition: WHERE filter removes all rows for a partition key value
+-- No phantom partition should appear
+-- =============================================================================
+
+SELECT id, val,
+       row_number() OVER (PARTITION BY grp ORDER BY id) as rn,
+       count(*) OVER (PARTITION BY grp) as cnt
+FROM w WHERE grp = 'C' ORDER BY id;
+→ []
+
+-- =============================================================================
+-- Single-row partition with all window functions
+-- =============================================================================
+
+CREATE TABLE single (id INTEGER PRIMARY KEY, val INTEGER);
+INSERT INTO single VALUES (1, 42);
+
+SELECT val,
+       row_number() OVER (ORDER BY id) as rn,
+       rank() OVER (ORDER BY id) as rnk,
+       dense_rank() OVER (ORDER BY id) as drnk,
+       lag(val) OVER (ORDER BY id) as lg,
+       lead(val) OVER (ORDER BY id) as ld,
+       sum(val) OVER (ORDER BY id) as s,
+       percent_rank() OVER (ORDER BY id) as pr,
+       cume_dist() OVER (ORDER BY id) as cd
+FROM single;
+→ [{"val":42,"rn":1,"rnk":1,"drnk":1,"lg":null,"ld":null,"s":42,"pr":0,"cd":1}]
+
+DROP TABLE single;
+
+-- =============================================================================
+-- Mixed ASC/DESC in window ORDER BY
+-- Verify frame boundaries respect the composite ordering
+-- =============================================================================
+
+CREATE TABLE mixed_order (id INTEGER PRIMARY KEY, a INTEGER, b INTEGER, val INTEGER);
+INSERT INTO mixed_order VALUES
+(1, 1, 30, 100),
+(2, 1, 20, 200),
+(3, 1, 10, 300),
+(4, 2, 30, 400),
+(5, 2, 20, 500);
+
+-- ORDER BY a ASC, b DESC means: (1,30), (1,20), (1,10), (2,30), (2,20)
+SELECT id, a, b, val,
+       row_number() OVER (ORDER BY a ASC, b DESC) as rn,
+       sum(val) OVER (ORDER BY a ASC, b DESC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as running
+FROM mixed_order ORDER BY a ASC, b DESC;
+→ [{"id":1,"a":1,"b":30,"val":100,"rn":1,"running":100},{"id":2,"a":1,"b":20,"val":200,"rn":2,"running":300},{"id":3,"a":1,"b":10,"val":300,"rn":3,"running":600},{"id":4,"a":2,"b":30,"val":400,"rn":4,"running":1000},{"id":5,"a":2,"b":20,"val":500,"rn":5,"running":1500}]
+
+-- Verify lag/lead follow the composite ordering
+SELECT id, a, b, val,
+       lag(val) OVER (ORDER BY a ASC, b DESC) as prev_val,
+       lead(val) OVER (ORDER BY a ASC, b DESC) as next_val
+FROM mixed_order ORDER BY a ASC, b DESC;
+→ [{"id":1,"a":1,"b":30,"val":100,"prev_val":null,"next_val":200},{"id":2,"a":1,"b":20,"val":200,"prev_val":100,"next_val":300},{"id":3,"a":1,"b":10,"val":300,"prev_val":200,"next_val":400},{"id":4,"a":2,"b":30,"val":400,"prev_val":300,"next_val":500},{"id":5,"a":2,"b":20,"val":500,"prev_val":400,"next_val":null}]
+
+DROP TABLE mixed_order;
+
+-- =============================================================================
+-- Large LAG/LEAD offsets beyond partition
+-- Should return default value (NULL) when offset exceeds partition size
+-- =============================================================================
+
+SELECT id, val, grp,
+       lag(val, 100) OVER (PARTITION BY grp ORDER BY id) as lag100,
+       lead(val, 100) OVER (PARTITION BY grp ORDER BY id) as lead100
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"grp":"A","lag100":null,"lead100":null},{"id":2,"val":20,"grp":"A","lag100":null,"lead100":null},{"id":3,"val":30,"grp":"A","lag100":null,"lead100":null},{"id":4,"val":40,"grp":"B","lag100":null,"lead100":null},{"id":5,"val":50,"grp":"B","lag100":null,"lead100":null}]
+
+-- Large offset with explicit default value
+SELECT id, val,
+       lag(val, 100, -1) OVER (ORDER BY id) as lag_def,
+       lead(val, 100, -1) OVER (ORDER BY id) as lead_def
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"lag_def":-1,"lead_def":-1},{"id":2,"val":20,"lag_def":-1,"lead_def":-1},{"id":3,"val":30,"lag_def":-1,"lead_def":-1},{"id":4,"val":40,"lag_def":-1,"lead_def":-1},{"id":5,"val":50,"lag_def":-1,"lead_def":-1}]
+
+-- =============================================================================
+-- RANGE frame with peers
+-- RANGE BETWEEN CURRENT ROW AND CURRENT ROW on data with duplicate order keys
+-- Should include all peer rows, not just the current row
+-- =============================================================================
+
+CREATE TABLE peers (id INTEGER PRIMARY KEY, val INTEGER, score INTEGER);
+INSERT INTO peers VALUES
+(1, 10, 100),
+(2, 10, 200),
+(3, 20, 300),
+(4, 20, 400),
+(5, 20, 500),
+(6, 30, 600);
+
+SELECT id, val, score,
+       count(*) OVER (ORDER BY val RANGE BETWEEN CURRENT ROW AND CURRENT ROW) as peer_count,
+       sum(score) OVER (ORDER BY val RANGE BETWEEN CURRENT ROW AND CURRENT ROW) as peer_sum
+FROM peers ORDER BY id;
+→ [{"id":1,"val":10,"score":100,"peer_count":2,"peer_sum":300},{"id":2,"val":10,"score":200,"peer_count":2,"peer_sum":300},{"id":3,"val":20,"score":300,"peer_count":3,"peer_sum":1200},{"id":4,"val":20,"score":400,"peer_count":3,"peer_sum":1200},{"id":5,"val":20,"score":500,"peer_count":3,"peer_sum":1200},{"id":6,"val":30,"score":600,"peer_count":1,"peer_sum":600}]
+
+-- Contrast with ROWS which should only include the current row
+SELECT id, val, score,
+       count(*) OVER (ORDER BY val ROWS BETWEEN CURRENT ROW AND CURRENT ROW) as row_count,
+       sum(score) OVER (ORDER BY val ROWS BETWEEN CURRENT ROW AND CURRENT ROW) as row_sum
+FROM peers ORDER BY id;
+→ [{"id":1,"val":10,"score":100,"row_count":1,"row_sum":100},{"id":2,"val":10,"score":200,"row_count":1,"row_sum":200},{"id":3,"val":20,"score":300,"row_count":1,"row_sum":300},{"id":4,"val":20,"score":400,"row_count":1,"row_sum":400},{"id":5,"val":20,"score":500,"row_count":1,"row_sum":500},{"id":6,"val":30,"score":600,"row_count":1,"row_sum":600}]
+
+DROP TABLE peers;
+
+-- =============================================================================
+-- Window function over zero rows
+-- Should return zero rows, not error
+-- =============================================================================
+
+SELECT row_number() OVER (ORDER BY id) as rn FROM w WHERE 1 = 0;
+→ []
+
+SELECT sum(val) OVER (ORDER BY id) as s,
+       count(*) OVER (ORDER BY id) as c,
+       rank() OVER (ORDER BY id) as r
+FROM w WHERE 1 = 0;
+→ []
+
+-- =============================================================================
+-- Multiple different window definitions in one query
+-- Each OVER clause has different PARTITION BY and ORDER BY — verify independence
+-- =============================================================================
+
+SELECT id, val, grp,
+       row_number() OVER (ORDER BY id) as global_rn,
+       row_number() OVER (PARTITION BY grp ORDER BY id) as grp_rn,
+       sum(val) OVER (PARTITION BY grp) as grp_total,
+       sum(val) OVER () as grand_total,
+       lag(val) OVER (PARTITION BY grp ORDER BY id) as grp_prev,
+       lag(val) OVER (ORDER BY id) as global_prev
+FROM w ORDER BY id;
+→ [{"id":1,"val":10,"grp":"A","global_rn":1,"grp_rn":1,"grp_total":60,"grand_total":150,"grp_prev":null,"global_prev":null},{"id":2,"val":20,"grp":"A","global_rn":2,"grp_rn":2,"grp_total":60,"grand_total":150,"grp_prev":10,"global_prev":10},{"id":3,"val":30,"grp":"A","global_rn":3,"grp_rn":3,"grp_total":60,"grand_total":150,"grp_prev":20,"global_prev":20},{"id":4,"val":40,"grp":"B","global_rn":4,"grp_rn":1,"grp_total":90,"grand_total":150,"grp_prev":null,"global_prev":30},{"id":5,"val":50,"grp":"B","global_rn":5,"grp_rn":2,"grp_total":90,"grand_total":150,"grp_prev":40,"global_prev":40}]
+
+-- =============================================================================
+-- Window function in subquery used in outer aggregate
+-- Composition of window + aggregate
+-- =============================================================================
+
+-- sum of row_numbers: 1+2+3+4+5 = 15
+SELECT sum(rn) as total_rn FROM (
+    SELECT row_number() OVER (ORDER BY id) as rn FROM w
+);
+→ [{"total_rn":15}]
+
+-- avg of per-group row_numbers: group A has rn 1,2,3 → avg 2; group B has 1,2 → avg 1.5
+-- overall avg of (1,2,3,1,2) = 9/5 = 1.8
+SELECT avg(grp_rn) as avg_rn FROM (
+    SELECT row_number() OVER (PARTITION BY grp ORDER BY id) as grp_rn FROM w
+);
+→ [{"avg_rn":1.8}]
+
+-- max of running sums
+SELECT max(rs) as max_running FROM (
+    SELECT sum(val) OVER (ORDER BY id ROWS UNBOUNDED PRECEDING) as rs FROM w
+);
+→ [{"max_running":150}]
+
+-- =============================================================================
+-- Cleanup
+-- =============================================================================
+
+DROP TABLE w;

package/test/logic/27.1-window-groups-frame.sqllogic

@@ -0,0 +1,13 @@
+-- adapted from SQLite test/window1.test, test/window2.test, test/window7.test, test/window8.test
+-- GROUPS frame mode is not yet supported by the Quereus parser. Document
+-- the rejection.
+
+create table gf (id integer primary key, val integer);
+insert into gf values (1, 10), (2, 10), (3, 20);
+
+select id, val,
+       count(*) over (order by val groups current row) as peer_count
+from gf order by id;
+-- error: groups
+
+drop table gf;

package/test/logic/27.2-window-exclude.sqllogic

@@ -0,0 +1,13 @@
+-- adapted from SQLite test/window1.test, test/window2.test, test/window5.test, test/window8.test
+-- EXCLUDE clause modifiers (NO OTHERS / CURRENT ROW / GROUP / TIES) are not
+-- yet supported by the Quereus parser. Document the rejection.
+
+create table ex (id integer primary key, val integer);
+insert into ex values (1, 10), (2, 20);
+
+select id, val,
+       sum(val) over (order by val rows between unbounded preceding and unbounded following exclude no others) as s
+from ex order by id;
+-- error: exclude
+
+drop table ex;

package/test/logic/27.3-window-json-aggregation.sqllogic

@@ -0,0 +1,66 @@
+-- 27.3-window-json-aggregation.sqllogic
+-- adapted from SQLite test/json103.test (json103-400, json103-410)
+-- json_group_array() and json_group_object() used as window functions over a frame.
+-- Per Quereus design (see AGENTS.md / framework notes): json_group_array and
+-- json_group_object are registered via createAggregateFunction only and are not
+-- invocable as window functions; the planner rejects the OVER form.
+
+CREATE TABLE w_jagg (id INTEGER PRIMARY KEY, x TEXT);
+INSERT INTO w_jagg VALUES
+  (1, '1'),
+  (2, 'a,b'),
+  (3, '3'),
+  (4, 'x"y'),
+  (5, '5'),
+  (6, '6'),
+  (7, '7');
+-- run
+
+-- json_group_array as window aggregate is rejected
+SELECT id, json_group_array(x) OVER (ORDER BY id ROWS 2 PRECEDING) as ga FROM w_jagg ORDER BY id;
+-- error: Unknown window function: json_group_array
+
+-- json_group_object as window aggregate is rejected
+SELECT id, json_group_object(cast(id as text), x) OVER (ORDER BY id ROWS 2 PRECEDING) as go FROM w_jagg ORDER BY id;
+-- error: Unknown window function: json_group_object
+
+-- json_group_array with PARTITION BY also rejected
+CREATE TABLE w_jagg_part (grp TEXT, val INTEGER);
+INSERT INTO w_jagg_part VALUES
+  ('a', 10),
+  ('a', 20),
+  ('a', 30),
+  ('b', 100),
+  ('b', 200);
+-- run
+
+SELECT grp, val, json_group_array(val) OVER (PARTITION BY grp ORDER BY val ROWS UNBOUNDED PRECEDING) as ga
+FROM w_jagg_part ORDER BY grp, val;
+-- error: Unknown window function: json_group_array
+
+-- json_group_array as plain (non-window) aggregate, GROUP BY — supported
+SELECT grp, json_group_array(val) as ga FROM w_jagg_part GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","ga":[10,20,30]},{"grp":"b","ga":[100,200]}]
+
+DROP TABLE w_jagg;
+DROP TABLE w_jagg_part;
+
+-- Window min()/max() over a JSON column rank structurally, matching the plain
+-- aggregate and ORDER BY (docs/types.md "Semantic ordering"). Canonical-text order
+-- would report mn=[10], mx=[9].
+CREATE TABLE w_jmm (id INTEGER PRIMARY KEY, d JSON);
+INSERT INTO w_jmm VALUES (1, '[8,1]'), (2, '[9]'), (3, '[10]');
+-- run
+
+SELECT id, d FROM w_jmm ORDER BY d;
+→ [{"id":1,"d":[8,1]},{"id":2,"d":[9]},{"id":3,"d":[10]}]
+
+SELECT DISTINCT min(d) OVER () AS mn, max(d) OVER () AS mx FROM w_jmm;
+→ [{"mn":[8,1],"mx":[10]}]
+
+-- Sliding frame: each window ranks structurally on its own.
+SELECT id, min(d) OVER (ORDER BY id ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) AS mn
+FROM w_jmm ORDER BY id;
+→ [{"id":1,"mn":[8,1]},{"id":2,"mn":[8,1]},{"id":3,"mn":[9]}]
+
+DROP TABLE w_jmm;