should be it

external/duckdb/test/sql/aggregate/group/group_by_all.test

@@ -0,0 +1,128 @@
+# name: test/sql/aggregate/group/group_by_all.test
+# description: Test GROUP BY ALL
+# group: [group]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+PRAGMA verify_external
+
+statement ok
+CREATE TABLE integers(g integer, i integer);
+
+statement ok
+INSERT INTO integers values (0, 1), (0, 2), (1, 3), (1, NULL);
+
+query II
+SELECT g, SUM(i) FROM integers GROUP BY ALL ORDER BY 1
+----
+0	3
+1	3
+
+query II
+SELECT SUM(i), g FROM integers GROUP BY ALL ORDER BY 2
+----
+3	0
+3	1
+
+# we can also use the star syntax
+query II
+SELECT g, SUM(i) FROM integers GROUP BY * ORDER BY 1
+----
+0	3
+1	3
+
+query II
+SELECT g, SUM(i) FROM integers GROUP BY 1 ORDER BY ALL
+----
+0	3
+1	3
+
+query II
+SELECT g, SUM(i) FROM integers GROUP BY 1 ORDER BY *
+----
+0	3
+1	3
+
+# multiple aggregates
+query IIIII
+SELECT g, SUM(i), COUNT(*), COUNT(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1
+----
+0	3	2	2	0
+1	3	2	1	2
+
+# complex groups: here we group by the entire calculation
+query III
+SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1
+----
+NULL	NULL	1
+0	2	0
+1	4	1
+
+# i.e. we group like this
+query III
+SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY 1 ORDER BY 1
+----
+NULL	NULL	1
+0	2	0
+1	4	1
+
+# NOT like this
+query III
+SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY i ORDER BY 1 NULLS FIRST, 2
+----
+NULL	NULL	1
+0	2	0
+1	1	0
+1	3	1
+
+# we can do this with multiple columns in the group too
+query III
+SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1 NULLS FIRST
+----
+NULL	NULL	1
+0	5	1
+1	1	0
+
+query III
+SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY 1 ORDER BY 1 NULLS FIRST
+----
+NULL	NULL	1
+0	5	1
+1	1	0
+
+query III
+SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY g, i ORDER BY 1 NULLS FIRST, 2
+----
+NULL	NULL	1
+0	2	0
+0	3	1
+1	1	0
+
+# we CANNOT mix aggregates and groups
+statement error
+SELECT (g+i)%2 + SUM(i), SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1
+----
+
+# multiple groups
+
+
+query IIIII
+SELECT g, i, g%2, SUM(i), SUM(g) FROM integers GROUP BY 1, 2, 3 ORDER BY 1, 2, 3, 4
+----
+0	1	0	1	0
+0	2	0	2	0
+1	NULL	1	NULL	1
+1	3	1	3	1
+
+query IIIII
+SELECT g, i, g%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1, 2 NULLS FIRST, 3, 4
+----
+0	1	0	1	0
+0	2	0	2	0
+1	NULL	1	NULL	1
+1	3	1	3	1

external/duckdb/test/sql/aggregate/group/group_by_all_having.test

@@ -0,0 +1,28 @@
+# name: test/sql/aggregate/group/group_by_all_having.test
+# description: Test group by all with having
+# group: [group]
+
+statement ok
+PRAGMA enable_verification;
+
+query I
+SELECT * FROM (SELECT 1) t0(c0) GROUP BY c0 HAVING c0>0
+----
+1
+
+query I
+SELECT c0 FROM (SELECT 1) t0(c0) GROUP BY ALL HAVING c0>0
+----
+1
+
+query I
+SELECT c0 FROM (SELECT 1, 1 UNION ALL SELECT 1, 2) t0(c0, c1) GROUP BY ALL ORDER BY c0
+----
+1
+
+# new column "c1" referenced in HAVING - it is added to the set of grouping columns
+query I
+SELECT c0 FROM (SELECT 1, 1 UNION ALL SELECT 1, 2) t0(c0, c1) GROUP BY ALL HAVING c1>0 ORDER BY c0
+----
+1
+1

external/duckdb/test/sql/aggregate/group/group_by_all_order.test

@@ -0,0 +1,41 @@
+# name: test/sql/aggregate/group/group_by_all_order.test
+# description: Test GROUP BY ALL with ORDER BY
+# group: [group]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+PRAGMA verify_external
+
+statement ok
+CREATE TABLE integers(g integer, i integer);
+
+statement ok
+INSERT INTO integers values (0, 1), (0, 2), (1, 3), (1, NULL);
+
+query I
+SELECT SUM(i) FROM integers
+----
+6
+
+query I
+SELECT SUM(i) FROM integers GROUP BY ALL
+----
+6
+
+query I
+SELECT SUM(i) FROM integers GROUP BY ALL ORDER BY ALL
+----
+6
+
+statement error
+SELECT SUM(i) FROM integers GROUP BY ALL ORDER BY g
+----
+GROUP BY ALL will only group entries in the SELECT list
+
+query II
+SELECT g, SUM(i) FROM integers GROUP BY ALL ORDER BY g
+----
+0	3
+1	3

external/duckdb/test/sql/aggregate/group/group_by_limits.test

@@ -0,0 +1,166 @@
+# name: test/sql/aggregate/group/group_by_limits.test
+# description: Test aggregates on numeric limits
+# group: [group]
+
+statement ok
+PRAGMA enable_verification
+
+# TINYINT limits
+statement ok
+CREATE TABLE t(t_k0 TINYINT);
+
+statement ok
+INSERT INTO t VALUES (-128), (127);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+-128	 1
+127	1
+
+statement ok
+DROP TABLE t;
+
+# SMALLINT limits
+statement ok
+CREATE TABLE t(t_k0 SMALLINT);
+
+statement ok
+INSERT INTO t VALUES (-32768), (32767);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+-32768	 1
+32767	1
+
+statement ok
+DROP TABLE t;
+
+# INTEGER limits
+statement ok
+CREATE TABLE t(t_k0 INTEGER);
+
+statement ok
+INSERT INTO t VALUES (-2147483648), (2147483647);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+-2147483648	 1
+2147483647	1
+
+statement ok
+DROP TABLE t;
+
+# BIGINT limits
+statement ok
+CREATE TABLE t(t_k0 BIGINT);
+
+statement ok
+INSERT INTO t VALUES (-9223372036854775808), (9223372036854775807);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+-9223372036854775808	 1
+9223372036854775807	1
+
+statement ok
+DROP TABLE t;
+
+# HUGEINT limits
+statement ok
+CREATE TABLE t(t_k0 HUGEINT);
+
+statement ok
+INSERT INTO t VALUES (-170141183460469231731687303715884105728), (170141183460469231731687303715884105727);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+-170141183460469231731687303715884105728	 1
+170141183460469231731687303715884105727	1
+
+statement ok
+DROP TABLE t;
+
+# UTINYINT limits
+statement ok
+CREATE TABLE t(t_k0 UTINYINT);
+
+statement ok
+INSERT INTO t VALUES (0), (255);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+0	 1
+255	1
+
+statement ok
+DROP TABLE t;
+
+# USMALLINT limits
+statement ok
+CREATE TABLE t(t_k0 USMALLINT);
+
+statement ok
+INSERT INTO t VALUES (0), (65535);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+0	 1
+65535	1
+
+statement ok
+DROP TABLE t;
+
+# UINTEGER limits
+statement ok
+CREATE TABLE t(t_k0 UINTEGER);
+
+statement ok
+INSERT INTO t VALUES (0), (4294967295);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+0	 1
+4294967295	1
+
+statement ok
+DROP TABLE t;
+
+# UBIGINT limits
+statement ok
+CREATE TABLE t(t_k0 UBIGINT);
+
+statement ok
+INSERT INTO t VALUES (0), (18446744073709551615);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+0	 1
+18446744073709551615	1
+
+statement ok
+DROP TABLE t;
+
+# UHUGEINT limits
+statement ok
+CREATE TABLE t(t_k0 UHUGEINT);
+
+statement ok
+INSERT INTO t VALUES (0), ('340282366920938463463374607431768211455'::UHUGEINT);
+
+query II
+SELECT t_k0, COUNT(*) FROM t GROUP BY t_k0 ORDER BY 1;
+----
+0	 1
+340282366920938463463374607431768211455	1
+
+statement ok
+DROP TABLE t;

external/duckdb/test/sql/aggregate/group/test_group_by.test

@@ -0,0 +1,198 @@
+# name: test/sql/aggregate/group/test_group_by.test
+# description: Test aggregation/group by statements
+# group: [group]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+PRAGMA verify_external
+
+statement ok
+CREATE TABLE test (a INTEGER, b INTEGER);
+
+statement ok
+INSERT INTO test VALUES (11, 22), (13, 22), (12, 21)
+
+# aggregates cannot be nested
+statement error
+SELECT SUM(SUM(41)), COUNT(*);
+----
+
+# simple aggregates without group by
+query RIR
+SELECT SUM(a), COUNT(*), AVG(a) FROM test;
+----
+36.000000	3	12.000000
+
+query I
+SELECT COUNT(*) FROM test;
+----
+3
+
+query RI
+SELECT SUM(a), COUNT(*) FROM test WHERE a = 11;
+----
+11.000000	1
+
+query RRR
+SELECT SUM(a), SUM(b), SUM(a) + SUM (b) FROM test;
+----
+36.000000	65.000000	101.000000
+
+query RR
+SELECT SUM(a+2), SUM(a) + 2 * COUNT(*) FROM test;
+----
+42.000000	42.000000
+
+# aggregations with group by
+query IRRR
+SELECT b, SUM(a), SUM(a+2), AVG(a) FROM test GROUP BY b ORDER BY b;
+----
+21	12.000000	14.000000	12.000000
+22	24.000000	28.000000	12.000000
+
+# ORDER BY aggregation that does not occur in SELECT clause
+query IR
+SELECT b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a);
+----
+21	12.000000
+22	24.000000
+
+query IR
+SELECT b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a) DESC;
+----
+22	24.000000
+21	12.000000
+
+query IRIR
+SELECT b, SUM(a), COUNT(*), SUM(a+2) FROM test GROUP BY b ORDER BY b;
+----
+21	12.000000	1	14.000000
+22	24.000000	2	28.000000
+
+# group by alias
+query IR
+SELECT b % 2 AS f, SUM(a) FROM test GROUP BY f ORDER BY f;
+----
+0	24.000000
+1	12.000000
+
+# group by with filter
+query IRIR
+SELECT b, SUM(a), COUNT(*), SUM(a+2) FROM test WHERE a <= 12 GROUP BY b ORDER BY b;
+----
+21	12.000000	1	14.000000
+22	11.000000	1	13.000000
+
+# nested aggregate in group by
+statement error
+SELECT b % 2 AS f, COUNT(SUM(a)) FROM test GROUP BY f;
+----
+
+statement ok
+INSERT INTO test VALUES (12, 21), (12, 21), (12, 21)
+
+# group by with filter and multiple values per groups
+query IRIR
+SELECT b, SUM(a), COUNT(*), SUM(a+2) FROM test WHERE a <= 12 GROUP BY b ORDER BY b;
+----
+21	48.000000	4	56.000000
+22	11.000000	1	13.000000
+
+# group by with filter and multiple values per groups
+statement ok
+CREATE TABLE integers(i INTEGER, j INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (3, 4), (3, 4), (2, 4);
+
+# use GROUP BY column in math operator
+query II
+SELECT i, i + 10 FROM integers GROUP BY i ORDER BY i
+----
+2	12
+3	13
+
+# using non-group column and non-aggregate should throw an error
+statement error
+SELECT i, SUM(j), j FROM integers GROUP BY i ORDER BY i
+----
+
+# but it works if we wrap it in FIRST() or LAST()
+query IRI
+SELECT i, SUM(j), FIRST(j) FROM integers GROUP BY i ORDER BY i
+----
+2	4.000000	4
+3	8.000000	4
+
+query IRI
+SELECT i, SUM(j), LAST(j) FROM integers GROUP BY i ORDER BY i
+----
+2	4.000000	4
+3	8.000000	4
+
+# group by constant alias
+query IR
+SELECT 1 AS k, SUM(i) FROM integers GROUP BY k ORDER BY 2;
+----
+1	8.000000
+
+# use an alias that is identical to a column name (should prioritize column name)
+query IR
+SELECT 1 AS i, SUM(i) FROM integers GROUP BY i ORDER BY 2;
+----
+1	2.000000
+1	6.000000
+
+# refer to the same alias twice
+query IR
+SELECT i % 2 AS k, SUM(i) FROM integers GROUP BY k, k ORDER BY 1;
+----
+0	2.000000
+1	6.000000
+
+statement ok
+DROP TABLE integers;
+
+statement ok
+CREATE TABLE integers(i INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (NULL);
+
+# group by NULL
+query IR
+SELECT i, SUM(i) FROM integers GROUP BY i ORDER BY 1;
+----
+NULL	NULL
+1	1.000000
+2	2.000000
+3	3.000000
+
+# column reference should have preference over alias reference in grouping
+query IIR
+SELECT i, i % 2 AS i, SUM(i) FROM integers GROUP BY i ORDER BY 1;
+----
+NULL	NULL	NULL
+1	1	1.000000
+2	0	2.000000
+3	1	3.000000
+
+# aliases can only be referenced in the GROUP BY as the root column: operations not allowed
+# CONTROVERSIAL: this query DOES work in SQLite
+statement error
+SELECT 1 AS k, SUM(i) FROM integers GROUP BY k+1 ORDER BY 2;
+----
+aliases cannot be used as part of an expression in the GROUP BY
+
+# group by column refs should be recognized, even if one uses an explicit table specifier and the other does not
+query IR
+SELECT test.b, SUM(a) FROM test GROUP BY b ORDER BY COUNT(a) DESC;
+----
+21	48.000000
+22	24.000000
+

external/duckdb/test/sql/aggregate/group/test_group_by_alias.test

@@ -0,0 +1,102 @@
+# name: test/sql/aggregate/group/test_group_by_alias.test
+# description: Test aliases in group by/aggregation
+# group: [group]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE integers(i INTEGER)
+
+statement ok
+INSERT INTO integers VALUES (1), (2), (3), (NULL)
+
+# use alias in HAVING clause
+# CONTROVERSIAL: this query DOES NOT work in PostgreSQL
+query IR
+SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY k HAVING k>0;
+----
+1	4.000000
+
+# this is identical to this query
+# CONTROVERSIAL: this query does not work in MonetDB
+query IR
+SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY k HAVING i%2>0;
+----
+1	4.000000
+
+# select groups by constant (similar to order by constant)
+query IR
+SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY 1 HAVING i%2>0;
+----
+1	4.000000
+
+# constant out of range
+statement error
+SELECT i % 2 AS k, SUM(i) FROM integers WHERE i IS NOT NULL GROUP BY 42 HAVING i%2>0;
+----
+
+# entry in GROUP BY should refer to base column
+# ...BUT the alias in ORDER BY should refer to the alias from the select list
+# note that both Postgres and MonetDB reject this query because of ambiguity. SQLite accepts it though so we do
+# too.
+query IIR
+SELECT i, i % 2 AS i, SUM(i) FROM integers GROUP BY i ORDER BY i, 3;
+----
+NULL	NULL	NULL
+2	0	2.000000
+1	1	1.000000
+3	1	3.000000
+
+# changing the name of the alias makes it more explicit what should happen
+query IIR
+SELECT i, i % 2 AS k, SUM(i) FROM integers GROUP BY i ORDER BY k, 3;
+----
+NULL	NULL	NULL
+2	0	2.000000
+1	1	1.000000
+3	1	3.000000
+
+# this now orders by the actual grouping column
+query IIR
+SELECT i, i % 2 AS k, SUM(i) FROM integers GROUP BY i ORDER BY i;
+----
+NULL	NULL	NULL
+1	1	1.000000
+2	0	2.000000
+3	1	3.000000
+
+# cannot use GROUP BY column in an aggregation...
+statement error
+SELECT i % 2 AS k, SUM(k) FROM integers GROUP BY k
+----
+
+# ...unless it is one of the base columns
+query IR
+SELECT i, SUM(i) FROM integers GROUP BY i ORDER BY i
+----
+NULL	NULL
+1	1.000000
+2	2.000000
+3	3.000000
+
+# ORDER on a non-grouping column
+# this query is refused by Postgres and MonetDB
+# but SQLite resolves it by first pushing a "FIRST(i)" aggregate into the projection, and then ordering by that
+# aggregate
+statement error
+SELECT (10-i) AS k, SUM(i) FROM integers GROUP BY k ORDER BY i;
+----
+
+# we can manually get this behavior by pushing FIRST
+query IR
+SELECT (10-i) AS k, SUM(i) FROM integers GROUP BY k ORDER BY FIRST(i);
+----
+NULL	NULL
+9	1.000000
+8	2.000000
+7	3.000000
+

external/duckdb/test/sql/aggregate/group/test_group_by_error.test

@@ -0,0 +1,19 @@
+# name: test/sql/aggregate/group/test_group_by_error.test
+# description: Test GROUP BY errors
+# group: [group]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+CREATE TABLE tbl(i INT)
+
+statement error
+SELECT * FROM tbl GROUP BY DEFAULT
+----
+cannot contain DEFAULT
+
+statement error
+SELECT * FROM tbl GROUP BY SUM(41)
+----
+cannot contain aggregates

external/duckdb/test/sql/aggregate/group/test_group_by_large_string.test

@@ -0,0 +1,22 @@
+# name: test/sql/aggregate/group/test_group_by_large_string.test
+# description: GROUP BY large strings
+# group: [group]
+
+statement ok
+PRAGMA enable_verification
+
+statement ok
+PRAGMA verify_external
+
+statement ok
+CREATE TABLE test (a VARCHAR, b INTEGER);
+
+statement ok
+INSERT INTO test VALUES ('helloworld', 22), ('thisisalongstring', 22), ('helloworld', 21)
+
+query TR
+SELECT a, SUM(b) FROM test GROUP BY a ORDER BY a
+----
+helloworld	43.000000
+thisisalongstring	22.000000
+

external/duckdb/test/sql/aggregate/group/test_group_by_multi_column.test

@@ -0,0 +1,17 @@
+# name: test/sql/aggregate/group/test_group_by_multi_column.test
+# description: Group by multiple columns
+# group: [group]
+
+statement ok
+CREATE TABLE integers(i INTEGER, j INTEGER, k INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (1, 1, 2), (1, 2, 2), (1, 1, 2), (2, 1, 2), (1, 2, 4), (1, 2, NULL);
+
+query IIRII
+SELECT i, j, SUM(k), COUNT(*), COUNT(k) FROM integers GROUP BY i, j ORDER BY 1, 2
+----
+1	1	4.000000	2	2
+1	2	6.000000	3	2
+2	1	2.000000	1	1
+

external/duckdb/test/sql/aggregate/group/test_group_by_nested.test

@@ -0,0 +1,251 @@
+# name: test/sql/aggregate/group/test_group_by_nested.test
+# description: GROUP BY nested types (STRUCTs, LISTs)
+# group: [group]
+
+require notmusl
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+PRAGMA enable_verification
+
+foreach storage_type VIEW TABLE
+
+# Key is LIST<INTEGER>
+statement ok
+CREATE ${storage_type} intlists AS SELECT * FROM (VALUES
+	(21, [1]),
+	(22, [NULL]),
+	(23, []),
+	(24, [2, 3]),
+	(NULL::INTEGER, [13]),
+	(32, [NULL]),
+	(34, [2, 3])
+	) lv(v, k);
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM intlists GROUP BY k ORDER BY 2
+----
+[13]	NULL
+[1]	21
+[]	23
+[NULL]	54
+[2, 3]	58
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM intlists GROUP BY k, c ORDER BY 2, 3
+----
+[13]	21	NULL
+[1]	21	21
+[]	21	23
+[NULL]	21	54
+[2, 3]	21	58
+
+# Key is LIST<VARCHAR>
+statement ok
+CREATE ${storage_type} strlists AS SELECT * FROM (VALUES
+	(21, ['a']),
+	(22, [NULL]),
+	(23, []),
+	(24, ['Branta Canadensis', 'c']),
+	(NULL::INTEGER, ['Somateria mollissima']),
+	(32, [NULL]),
+	(34, ['Branta Canadensis', 'c'])
+	) lv(v, k);
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM strlists GROUP BY k ORDER BY 2
+----
+[Somateria mollissima]	NULL
+[a]	21
+[]	23
+[NULL]	54
+[Branta Canadensis, c]	58
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM strlists GROUP BY k, c ORDER BY 2, 3
+----
+[Somateria mollissima]	21	NULL
+[a]	21	21
+[]	21	23
+[NULL]	21	54
+[Branta Canadensis, c]	21	58
+
+# Key is STRUCT<x: INTEGER, y: VARCHAR>
+statement ok
+CREATE ${storage_type} structs AS SELECT * FROM (VALUES
+	(21, {'x': 1, 'y': 'a'}),
+	(22, {'x': NULL, 'y': NULL}),
+	(23, {'x': 0, 'y': ''}),
+	(24, {'x': 2, 'y': 'c'}),
+	(NULL::INTEGER, {'x': 13, 'y': 'Somateria mollissima'}),
+	(32, {'x': NULL, 'y': NULL}),
+	(34, {'x': 2, 'y': 'c'})
+	) sv(v, k);
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM structs GROUP BY k ORDER BY 2
+----
+{'x': 13, 'y': Somateria mollissima}	NULL
+{'x': 1, 'y': a}	21
+{'x': 0, 'y': ''}	23
+{'x': NULL, 'y': NULL}	54
+{'x': 2, 'y': c}	58
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM structs GROUP BY k, c ORDER BY 2, 3
+----
+{'x': 13, 'y': Somateria mollissima}	21	NULL
+{'x': 1, 'y': a}	21	21
+{'x': 0, 'y': ''}	21	23
+{'x': NULL, 'y': NULL}	21	54
+{'x': 2, 'y': c}	21	58
+
+# Key is STRUCT<x: LIST<INTEGER>, y: LIST<VARCHAR> >
+statement ok
+CREATE ${storage_type} struct_lint_lstr AS SELECT * FROM (VALUES
+	(21, {'x': [1], 'y': ['a']}),
+	(22, {'x': [NULL], 'y': [NULL]}),
+	(23, {'x': [], 'y': []}),
+	(24, {'x': [2, 3], 'y': ['Branta Canadensis', 'c']}),
+	(NULL::INTEGER, {'x': [13], 'y': ['Somateria mollissima']}),
+	(32, {'x': [NULL], 'y': [NULL]}),
+	(34, {'x': [2, 3], 'y': ['Branta Canadensis', 'c']})
+	) sv(v, k);
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM struct_lint_lstr
+GROUP BY k
+ORDER BY 2
+----
+{'x': [13], 'y': [Somateria mollissima]}	NULL
+{'x': [1], 'y': [a]}	21
+{'x': [], 'y': []}	23
+{'x': [NULL], 'y': [NULL]}	54
+{'x': [2, 3], 'y': [Branta Canadensis, c]}	58
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM struct_lint_lstr
+GROUP BY k, c
+ORDER BY 2, 3
+----
+{'x': [13], 'y': [Somateria mollissima]}	21	NULL
+{'x': [1], 'y': [a]}	21	21
+{'x': [], 'y': []}	21	23
+{'x': [NULL], 'y': [NULL]}	21	54
+{'x': [2, 3], 'y': [Branta Canadensis, c]}	21	58
+
+# Key is STRUCT<x: LIST<STRUCT<l4: LIST<INT>, i4 INT> >, y: LIST<VARCHAR> >.
+statement ok
+CREATE ${storage_type} r2l3r4l5i4i2l3v AS SELECT * FROM (VALUES
+	(21, {'x': [{'l4': [51], 'i4': 41}], 'y': ['a']}),
+	(22, {'x': [NULL], 'y': [NULL]}),
+	(23, {'x': [], 'y': []}),
+	(24, {'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': ['Branta Canadensis', 'c']}),
+	(NULL::INTEGER, {'x': [{'l4': [62], 'i4': 47}], 'y': ['Somateria mollissima']}),
+	(32, {'x': [NULL], 'y': [NULL]}),
+	(34, {'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': ['Branta Canadensis', 'c']})
+	) sv(v, k);
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM r2l3r4l5i4i2l3v
+GROUP BY k
+ORDER BY 2
+----
+{'x': [{'l4': [62], 'i4': 47}], 'y': [Somateria mollissima]}	NULL
+{'x': [{'l4': [51], 'i4': 41}], 'y': [a]}	21
+{'x': [], 'y': []}	23
+{'x': [NULL], 'y': [NULL]}	54
+{'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': [Branta Canadensis, c]}	58
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM r2l3r4l5i4i2l3v
+GROUP BY k, c
+ORDER BY 2, 3
+----
+{'x': [{'l4': [62], 'i4': 47}], 'y': [Somateria mollissima]}	21	NULL
+{'x': [{'l4': [51], 'i4': 41}], 'y': [a]}	21	21
+{'x': [], 'y': []}	21	23
+{'x': [NULL], 'y': [NULL]}	21	54
+{'x': [{'l4': [52, 53], 'i4': 42}, {'l4': [54, 55], 'i4': 43}], 'y': [Branta Canadensis, c]}	21	58
+
+# Key is LIST<INTEGER[2000]>
+statement ok
+CREATE ${storage_type} longlists AS
+SELECT *
+FROM ((VALUES
+	(21, [1]),
+	(22, [NULL]),
+	(23, []),
+	(NULL::INTEGER, [13]),
+	(32, [NULL])
+	)
+UNION ALL
+	select 24 as i, list(r) as pk from range(2000) tbl(r)
+UNION ALL
+	select 34 as i, list(r) as pk from range(2000) tbl(r)
+) sv(v, k);
+
+# mode output_hash
+
+# Single hash
+query II
+SELECT k, SUM(v) FROM longlists
+GROUP BY k
+ORDER BY 2
+----
+10 values hashing to 84a164dd1cc3272550b757ae0947dabf
+
+# Combined hash
+query III
+SELECT k, LEAST(v, 21) as c, SUM(v) FROM longlists
+GROUP BY k, c
+ORDER BY 2, 3
+----
+15 values hashing to 221ccf64a566554dde15e57c459708c8
+
+# Multiple constant keys
+query II
+select [1,2,3] a, count(*)
+from range(5) tbl(b)
+group by a;
+----
+[1, 2, 3]	5
+
+query II
+select {'x': 1, 'y': 2, 'z': 3} a, count(*)
+from range(5) tbl(b)
+group by a;
+----
+{'x': 1, 'y': 2, 'z': 3}	5
+
+statement ok
+DROP ${storage_type} intlists;
+
+statement ok
+DROP ${storage_type} strlists;
+
+statement ok
+DROP ${storage_type} structs;
+
+statement ok
+DROP ${storage_type} struct_lint_lstr;
+
+statement ok
+DROP ${storage_type} r2l3r4l5i4i2l3v;
+
+statement ok
+DROP ${storage_type} longlists;
+
+endloop

external/duckdb/test/sql/aggregate/group/test_group_by_parallel.test_slow

@@ -0,0 +1,72 @@
+# name: test/sql/aggregate/group/test_group_by_parallel.test_slow
+# description: Test parallel group by
+# group: [group]
+
+statement ok
+PRAGMA threads=4
+
+statement ok
+PRAGMA verify_external
+
+# small number of groups (100)
+statement ok
+create temporary table d as select mod(range, 100) g, 42 p from range(10000000);
+
+query IIII
+select g, count(*), min(p), max(p) c from d group by g order by g limit 10;
+----
+0	100000	42	42
+1	100000	42	42
+2	100000	42	42
+3	100000	42	42
+4	100000	42	42
+5	100000	42	42
+6	100000	42	42
+7	100000	42	42
+8	100000	42	42
+9	100000	42	42
+
+statement ok
+drop table d;
+
+# medium number of groups (100000)
+statement ok
+create temporary table d as select mod(range, 100000) g, 42 p from range(10000000);
+
+query IIII
+select g, count(*), min(p), max(p) c from d group by g order by g limit 10;
+----
+0	100	42	42
+1	100	42	42
+2	100	42	42
+3	100	42	42
+4	100	42	42
+5	100	42	42
+6	100	42	42
+7	100	42	42
+8	100	42	42
+9	100	42	42
+
+statement ok
+drop table d;
+
+# large number of groups (1000000)
+statement ok
+create temporary table d as select mod(range, 1000000) g, 42 p from range(1000000);
+
+query IIII
+select g, count(*), min(p), max(p) c from d group by g order by g limit 10;
+----
+0	1	42	42
+1	1	42	42
+2	1	42	42
+3	1	42	42
+4	1	42	42
+5	1	42	42
+6	1	42	42
+7	1	42	42
+8	1	42	42
+9	1	42	42
+
+statement ok
+drop table d;

external/duckdb/test/sql/aggregate/group/test_group_null.test

@@ -0,0 +1,20 @@
+# name: test/sql/aggregate/group/test_group_null.test
+# description: GROUP BY NULL value
+# group: [group]
+
+statement ok
+SET default_null_order='nulls_first';
+
+statement ok
+CREATE TABLE integers(i INTEGER, j INTEGER);
+
+statement ok
+INSERT INTO integers VALUES (3, 4), (NULL, 4), (2, 4);
+
+query IR
+SELECT i, SUM(j) FROM integers GROUP BY i ORDER BY i
+----
+NULL	4.000000
+2	4.000000
+3	4.000000
+

external/duckdb/test/sql/aggregate/group/tpch_group_by_all.test_slow

@@ -0,0 +1,118 @@
+# name: test/sql/aggregate/group/tpch_group_by_all.test_slow
+# description: Test TPC-H SF0.01 GROUP BY ALL
+# group: [group]
+
+require tpch
+
+statement ok
+CALL dbgen(sf=0.01);
+
+statement ok
+PRAGMA verify_external
+
+query I
+SELECT
+    l_returnflag,
+    l_linestatus,
+    sum(l_quantity) AS sum_qty,
+    sum(l_extendedprice) AS sum_base_price,
+    sum(l_extendedprice * (1 - l_discount)) AS sum_disc_price,
+    sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) AS sum_charge,
+    avg(l_quantity) AS avg_qty,
+    avg(l_extendedprice) AS avg_price,
+    avg(l_discount) AS avg_disc,
+    count(*) AS count_order
+FROM
+    lineitem
+WHERE
+    l_shipdate <= CAST('1998-09-02' AS date)
+GROUP BY ALL
+ORDER BY ALL;
+----
+<FILE>:extension/tpch/dbgen/answers/sf0.01/q01.csv
+
+query I
+SELECT
+    l_orderkey,
+    sum(l_extendedprice * (1 - l_discount)) AS revenue,
+    o_orderdate,
+    o_shippriority
+FROM
+    customer,
+    orders,
+    lineitem
+WHERE
+    c_mktsegment = 'BUILDING'
+    AND c_custkey = o_custkey
+    AND l_orderkey = o_orderkey
+    AND o_orderdate < CAST('1995-03-15' AS date)
+    AND l_shipdate > CAST('1995-03-15' AS date)
+GROUP BY
+    l_orderkey,
+    o_orderdate,
+    o_shippriority
+ORDER BY
+    revenue DESC,
+    o_orderdate
+LIMIT 10;
+----
+<FILE>:extension/tpch/dbgen/answers/sf0.01/q03.csv
+
+query I
+SELECT
+    c_custkey,
+    c_name,
+    sum(l_extendedprice * (1 - l_discount)) AS revenue,
+    c_acctbal,
+    n_name,
+    c_address,
+    c_phone,
+    c_comment
+FROM
+    customer,
+    orders,
+    lineitem,
+    nation
+WHERE
+    c_custkey = o_custkey
+    AND l_orderkey = o_orderkey
+    AND o_orderdate >= CAST('1993-10-01' AS date)
+    AND o_orderdate < CAST('1994-01-01' AS date)
+    AND l_returnflag = 'R'
+    AND c_nationkey = n_nationkey
+GROUP BY
+    c_custkey,
+    c_name,
+    c_acctbal,
+    c_phone,
+    n_name,
+    c_address,
+    c_comment
+ORDER BY
+    revenue DESC
+LIMIT 20;
+----
+<FILE>:extension/tpch/dbgen/answers/sf0.01/q10.csv
+
+query I
+SELECT
+    c_count,
+    count(*) AS custdist
+FROM (
+    SELECT
+        c_custkey,
+        count(o_orderkey)
+    FROM
+        customer
+    LEFT OUTER JOIN orders ON c_custkey = o_custkey
+    AND o_comment NOT LIKE '%special%requests%'
+GROUP BY
+    c_custkey) AS c_orders (c_custkey,
+        c_count)
+GROUP BY
+    c_count
+ORDER BY
+    custdist DESC,
+    c_count DESC;
+----
+<FILE>:extension/tpch/dbgen/answers/sf0.01/q13.csv