@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/07-aggregates.sqllogic

@@ -0,0 +1,193 @@
+-- aggregates.sqllogic - Testing aggregate functions and GROUP BY/HAVING
+
+CREATE TABLE agg_t (id INTEGER PRIMARY KEY, grp TEXT, val INTEGER NULL);
+INSERT INTO agg_t VALUES (1, 'a', 10), (2, 'b', 20), (3, 'a', 30), (4, 'b', 40), (5, 'c', 50), (6, 'a', null);
+
+-- Basic aggregates
+SELECT count(*), count(val), sum(val), avg(val), min(val), max(val) FROM agg_t;
+→ [{"count(*)":6,"count(val)":5,"sum(val)":150,"avg(val)":30,"min(val)":10,"max(val)":50}]
+
+-- GROUP BY
+SELECT grp, count(*) as cnt, sum(val) as total FROM agg_t GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","cnt":3,"total":40},{"grp":"b","cnt":2,"total":60},{"grp":"c","cnt":1,"total":50}]
+
+-- GROUP BY with NULL value in aggregation
+SELECT grp, count(val) FROM agg_t GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","count(val)":2},{"grp":"b","count(val)":2},{"grp":"c","count(val)":1}]
+
+-- HAVING clause
+SELECT grp, sum(val) as total FROM agg_t GROUP BY grp HAVING total > 40 ORDER BY grp;
+→ [{"grp":"b","total":60},{"grp":"c","total":50}]
+
+-- HAVING clause referencing alias
+SELECT grp, sum(val) as total FROM agg_t GROUP BY grp HAVING total > 40 ORDER BY grp;
+→ [{"grp":"b","total":60},{"grp":"c","total":50}]
+
+-- HAVING on a GROUP BY column is pushed below the aggregate (rule-aggregate-predicate-pushdown).
+-- Result rows must be unchanged by the rewrite.
+SELECT grp, sum(val) as total FROM agg_t GROUP BY grp HAVING grp > 'a' ORDER BY grp;
+→ [{"grp":"b","total":60},{"grp":"c","total":50}]
+
+-- Mixed HAVING: GROUP-BY-column conjunct is pushed below, aggregate-output conjunct stays above.
+SELECT grp, sum(val) as total FROM agg_t GROUP BY grp HAVING grp >= 'b' AND sum(val) > 40 ORDER BY grp;
+→ [{"grp":"b","total":60},{"grp":"c","total":50}]
+
+-- HAVING without GROUP BY
+SELECT sum(val) FROM agg_t HAVING sum(val) > 100;
+→ [{"sum(val)":150}]
+
+-- Aggregate with empty input
+CREATE TABLE empty_agg(x NULL);
+SELECT count(*), sum(x) FROM empty_agg;
+→ [{"count(*)":0,"sum(x)":null}]
+DROP TABLE empty_agg;
+
+-- group_concat
+SELECT group_concat(val) FROM agg_t WHERE grp = 'a';
+→ [{"group_concat(val)":"10,30"}]
+SELECT group_concat(val, '|') FROM agg_t WHERE grp = 'b' ORDER BY val;
+→ [{"group_concat(val, '|')":"20|40"}]
+
+-- DISTINCT aggregates (Example: COUNT)
+SELECT count(distinct grp) FROM agg_t;
+→ [{"count(distinct grp)":3}]
+INSERT INTO agg_t VALUES (7, 'c', 50);
+SELECT count(distinct val) FROM agg_t WHERE grp = 'c';
+→ [{"count(distinct val)":1}]
+
+-- HAVING with COUNT(DISTINCT) - aggregate only in HAVING, not in SELECT
+SELECT grp FROM agg_t GROUP BY grp HAVING count(distinct val) > 1 ORDER BY grp;
+→ [{"grp":"a"},{"grp":"b"}]
+
+-- HAVING with COUNT(DISTINCT) - aggregate in both SELECT and HAVING
+SELECT grp, count(distinct val) as cd FROM agg_t GROUP BY grp HAVING count(distinct val) > 1 ORDER BY grp;
+→ [{"grp":"a","cd":2},{"grp":"b","cd":2}]
+
+-- HAVING with SUM(DISTINCT)
+SELECT grp FROM agg_t GROUP BY grp HAVING sum(distinct val) > 45 ORDER BY grp;
+→ [{"grp":"b"},{"grp":"c"}]
+
+-- SELECT has COUNT(val), HAVING has COUNT(DISTINCT val) - must be different aggregates
+SELECT grp, count(val) as cv FROM agg_t GROUP BY grp HAVING count(distinct val) = 1 ORDER BY grp;
+→ [{"grp":"c","cv":2}]
+
+-- HAVING expression with multiple DISTINCT aggregates
+SELECT grp FROM agg_t GROUP BY grp HAVING count(distinct val) + count(distinct grp) > 2 ORDER BY grp;
+→ [{"grp":"a"},{"grp":"b"}]
+
+-- Constant literals are allowed in aggregate queries
+SELECT grp, count(*) as cnt, 0 AS constant FROM agg_t GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","cnt":3,"constant":0},{"grp":"b","cnt":2,"constant":0},{"grp":"c","cnt":2,"constant":0}]
+
+-- Non-grouped columns not allowed with aggregates
+SELECT grp, count(*), val FROM agg_t GROUP BY grp;
+-- error: Column 'val' must appear in the GROUP BY clause or be used in an aggregate function
+
+-- Scalar functions wrapping aggregates
+SELECT coalesce(max(id), 0) FROM agg_t;
+→ [{"coalesce(max(id), 0)":7}]
+
+SELECT coalesce(max(val), 0) FROM agg_t;
+→ [{"coalesce(max(val), 0)":50}]
+
+SELECT coalesce(min(val), -1) FROM agg_t;
+→ [{"coalesce(min(val), -1)":10}]
+
+-- Scalar wrapping aggregate with GROUP BY
+SELECT grp, coalesce(max(val), 0) FROM agg_t GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","coalesce(max(val), 0)":30},{"grp":"b","coalesce(max(val), 0)":40},{"grp":"c","coalesce(max(val), 0)":50}]
+
+-- Arithmetic on aggregate results
+SELECT max(val) + 1 FROM agg_t;
+→ [{"max(val) + 1":51}]
+
+DROP TABLE agg_t;
+
+-- GROUP BY with NULL group key
+CREATE TABLE agg_null_grp (id INTEGER PRIMARY KEY, grp TEXT NULL, val INTEGER);
+INSERT INTO agg_null_grp VALUES
+	(1, 'a', 10),
+	(2, null, 20),
+	(3, 'a', 30),
+	(4, null, 40),
+	(5, 'b', 50);
+
+SELECT grp, count(*) as cnt, sum(val) as total FROM agg_null_grp GROUP BY grp ORDER BY grp NULLS FIRST;
+→ [{"grp":null,"cnt":2,"total":60},{"grp":"a","cnt":2,"total":40},{"grp":"b","cnt":1,"total":50}]
+
+DROP TABLE agg_null_grp;
+
+-- Test aggregate function commutativity (order independence)
+CREATE TABLE agg_order_test (id INTEGER PRIMARY KEY, val REAL NULL);
+INSERT INTO agg_order_test VALUES (1, 1), (2, 2), (3, 3), (4, null), (5, 4.5), (6, -1);
+
+SELECT SUM(val), COUNT(val), MAX(val), MIN(val) FROM agg_order_test;
+→ [{"sum(val)":9.5,"count(val)":5,"max(val)":4.5,"min(val)":-1}]
+
+-- Clear and insert in different order - results should be identical
+DELETE FROM agg_order_test;
+INSERT INTO agg_order_test VALUES (1, 4.5), (2, null), (3, -1), (4, 3), (5, 1), (6, 2);
+
+SELECT SUM(val), COUNT(val), MAX(val), MIN(val) FROM agg_order_test;
+→ [{"sum(val)":9.5,"count(val)":5,"max(val)":4.5,"min(val)":-1}]
+
+-- Test with more complex mixed data
+DELETE FROM agg_order_test;
+INSERT INTO agg_order_test VALUES (1, 0), (2, 1), (3, null), (4, 2), (5, null), (6, 3);
+
+SELECT SUM(val), AVG(val), COUNT(val), COUNT(*) FROM agg_order_test;
+→ [{"sum(val)":6,"avg(val)":1.5,"count(val)":4,"count(*)":6}]
+
+DROP TABLE agg_order_test;
+
+-- GROUP BY FD simplification — PK-driven
+-- `id` is the PK, so `id → name` and `id → email` hold. The optimizer drops
+-- `name` and `email` from GROUP BY and re-emits them as MIN() picker
+-- aggregates. Result rows must be unchanged by the rewrite.
+CREATE TABLE agg_fd_pk (id INTEGER PRIMARY KEY, name TEXT, email TEXT);
+INSERT INTO agg_fd_pk VALUES
+	(1, 'a', 'a@x'),
+	(2, 'b', 'b@x'),
+	(3, 'b', 'b@y');
+
+SELECT id, name, email FROM agg_fd_pk GROUP BY id, name, email ORDER BY id;
+→ [{"id":1,"name":"a","email":"a@x"},{"id":2,"name":"b","email":"b@x"},{"id":3,"name":"b","email":"b@y"}]
+
+DROP TABLE agg_fd_pk;
+
+-- GROUP BY FD simplification — EC-driven
+-- `WHERE a = b` makes a ≡ b under the filter, so the optimizer drops one of
+-- the two from GROUP BY and re-emits it as a MIN() picker. Result rows must
+-- match the un-simplified semantics.
+CREATE TABLE agg_fd_ec (id INTEGER PRIMARY KEY, a INTEGER, b INTEGER);
+INSERT INTO agg_fd_ec VALUES (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 1, 1);
+
+SELECT a, b FROM agg_fd_ec WHERE a = b GROUP BY a, b ORDER BY a;
+→ [{"a":1,"b":1},{"a":2,"b":2},{"a":3,"b":3}]
+
+DROP TABLE agg_fd_ec;
+
+-- count(distinct blob_col) — the DISTINCT tree's entry is the bare BLOB scalar
+-- (a Uint8Array), which inheritree's default freeze-on-insert cannot store
+-- (bug-in-subquery-blob-values-crash).
+--
+-- The GROUP BY column here LEADS the primary key, so the index scan already
+-- supplies grouped order and the optimizer picks StreamAggregate — which is what
+-- makes this file (rather than 92-hash-aggregate-edge-cases) the right home for
+-- the grouped case: it reaches the stream emitter's per-group distinct-tree reset.
+-- A GROUP BY on an unindexed column costs out to HashAggregate instead; that
+-- variant is covered in 92-hash-aggregate-edge-cases.
+CREATE TABLE agg_blob (grp TEXT, id INTEGER, b BLOB NULL, PRIMARY KEY (grp, id));
+INSERT INTO agg_blob VALUES
+	('a', 1, x'6162'), ('a', 2, x'6162'), ('a', 3, x'6164'),
+	('b', 4, x'6162'), ('b', 5, null);
+
+-- No GROUP BY: always StreamAggregate, single accumulator + single tree
+SELECT count(distinct b) AS cd FROM agg_blob;
+→ [{"cd":2}]
+
+-- Grouped: a fresh tree per group (first-group and new-group reset paths)
+SELECT grp, count(distinct b) AS cd FROM agg_blob GROUP BY grp ORDER BY grp;
+→ [{"grp":"a","cd":2},{"grp":"b","cd":1}]
+
+DROP TABLE agg_blob;

package/test/logic/07.1-aggregate-filter-clause.sqllogic

@@ -0,0 +1,12 @@
+-- adapted from SQLite test/aggfunc.test, test/window4.test, test/window6.test
+-- FILTER (WHERE …) clause restricts which rows feed an aggregate or window aggregate.
+-- Quereus parser does not currently accept FILTER (WHERE ...) on aggregates.
+-- Document the rejection.
+
+create table af (id integer primary key, grp text, val integer null, flag integer);
+insert into af values (1, 'a', 10, 1), (2, 'a', 20, 0);
+
+select count(*) filter (where val > 15) as c from af;
+-- error: filter
+
+drop table af;

package/test/logic/07.2-aggregate-order-by.sqllogic

@@ -0,0 +1,11 @@
+-- adapted from SQLite test/aggfunc.test (aggorderby)
+-- ORDER BY inside an aggregate function call (e.g. group_concat(... ORDER BY ...))
+-- is not currently supported by the Quereus parser. Document the rejection.
+
+create table ob (id integer primary key, grp text, val text, pri integer);
+insert into ob values (1, 'a', 'x', 2), (2, 'a', 'y', 1);
+
+select group_concat(val order by pri) as gc from ob;
+-- error: order
+
+drop table ob;