diff options
| author | Pavan Deolasee | 2016-01-27 11:53:25 +0000 |
|---|---|---|
| committer | Pavan Deolasee | 2016-10-18 09:47:52 +0000 |
| commit | ddc95c703be878c98e24562365e336f7dbfb466d (patch) | |
| tree | b0f37f347eaefc182c45819f2d3fc245973ccafc | |
| parent | d30ee6999a54e3c7cc67a792211757d31295f205 (diff) | |
Fix a bug where a query was getting incorrectly FQSed when the GROUP BY clause
contains only non-distribution keys.
Also rerun all the xc_groupby tests with enable_fast_query_shipping ON so that
similar issues can be caught more easily
| -rw-r--r-- | src/backend/optimizer/util/pgxcship.c | 2 | ||||
| -rw-r--r-- | src/test/regress/expected/xc_groupby.out | 2882 | ||||
| -rw-r--r-- | src/test/regress/sql/xc_groupby.sql | 385 |
3 files changed, 3268 insertions, 1 deletions
diff --git a/src/backend/optimizer/util/pgxcship.c b/src/backend/optimizer/util/pgxcship.c index 2197abe7f4..5a90dd11af 100644 --- a/src/backend/optimizer/util/pgxcship.c +++ b/src/backend/optimizer/util/pgxcship.c @@ -974,7 +974,7 @@ pgxc_shippability_walker(Node *node, Shippability_context *sc_context) * participating in the query. All the rows of that relation with * the same value of distribution column reside on same node. */ - if ((query->hasAggs || query->havingQual) && + if ((query->hasAggs || query->havingQual || query->groupClause) && !pgxc_query_has_distcolgrouping(query)) pgxc_set_shippability_reason(sc_context, SS_NEED_SINGLENODE); diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out index 64ce223a5b..6bebddc0b8 100644 --- a/src/test/regress/expected/xc_groupby.out +++ b/src/test/regress/expected/xc_groupby.out @@ -2839,3 +2839,2885 @@ drop table xc_groupby_def; drop table xc_groupby_g; reset enable_hashagg; reset enable_fast_query_shipping; +-- Now repeat all the tests with FQS turned on +set enable_fast_query_shipping to on; +-- Combination 1: enable_hashagg on and distributed tables +set enable_hashagg to on; +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int); +create table xc_groupby_tab2 (val int, val2 int); +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + count | sum | avg | ?column? | val2 +-------+-----+--------------------+------------------+------ + 3 | 6 | 2.0000000000000000 | 2 | 1 + 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 + 2 | 8 | 4.0000000000000000 | 4 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: count(*), sum(val), avg(val), val2 + -> HashAggregate + Output: count(*), sum(val), avg(val), val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(10 rows) + +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + count | sum | avg | ?column? | val2 | val2 +-------+-----+---------------------+------------------+------+------ + 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 + 6 | 96 | 16.0000000000000000 | 16 | 2 | 2 + 3 | | | | 3 | + 3 | | | | | 4 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Remote Subquery Scan on all + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> GroupAggregate + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Merge Full Join + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Merge Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2) + -> Remote Subquery Scan on all + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Distribute results by H: val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + -> Materialize + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + -> Remote Subquery Scan on all + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Distribute results by H: val2 + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val2 + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(32 rows) + +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + sum +----- + 17 + 8 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2)) + Group Key: (xc_groupby_tab1.val2 % 2) + -> HashAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: sum(xc_groupby_tab1.val), xc_groupby_tab1.val2, xc_groupby_tab1.val2 + -> HashAggregate + Output: sum(xc_groupby_tab1.val), xc_groupby_tab1.val2, xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val, xc_groupby_tab1.val2 +(13 rows) + +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; + val2 +------ + 1 + 3 + 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +------------------------------------------------------ + HashAggregate + Output: val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: val2 + -> HashAggregate + Output: val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(10 rows) + +select val + val2 from xc_groupby_tab1 group by val + val2; + ?column? +---------- + 8 + 4 + 3 + 9 + 2 + 7 +(6 rows) + +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; + QUERY PLAN +----------------------------------------------------------------------- + HashAggregate + Output: ((val + val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) + -> Remote Subquery Scan on all + Output: (val + val2) + -> HashAggregate + Output: ((val + val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) + -> Seq Scan on public.xc_groupby_tab1 + Output: (val + val2) +(10 rows) + +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + ?column? | val | val2 +----------+-----+------ + 8 | 6 | 2 + 4 | 2 | 2 + 4 | 1 | 3 + 9 | 6 | 3 + 3 | 2 | 1 + 2 | 1 | 1 + 4 | 3 | 1 + 7 | 4 | 3 +(8 rows) + +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM xc_groupby_tab1 GROUP BY val, val2 + -> HashAggregate + Output: (val + val2), val, val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(8 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + ?column? | val | val2 +----------+-----+------ + 6 | 2 | 4 + 2 | 1 | 1 + 6 | 4 | 2 + 7 | 3 | 4 + 5 | 3 | 2 + 5 | 4 | 1 +(6 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 FROM xc_groupby_tab1, xc_groupby_tab2 WHERE (xc_groupby_tab1.val = xc_groupby_tab2.val) GROUP BY xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> HashAggregate + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Merge Join + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(19 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + ?column? +---------- + 5 + 7 + 2 + 6 +(4 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------- + HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Remote Subquery Scan on all + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Merge Join + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(21 rows) + +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + ?column? | val2 +---------------------+------ + 11.0000000000000000 | 1 + 17.6666666666666667 | 3 + 14.0000000000000000 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: count(*), sum(val), avg(val), val2 + -> HashAggregate + Output: count(*), sum(val), avg(val), val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(10 rows) + +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + sum | avg | ?column? +-----+--------------------+---------- + 8 | 4.0000000000000000 | 4 + 11 | 3.6666666666666667 | 6 + 6 | 2.0000000000000000 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +-------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((2 * val2)) + Group Key: (2 * xc_groupby_tab1.val2) + -> Remote Subquery Scan on all + Output: sum(val), avg(val), (2 * val2) + -> HashAggregate + Output: sum(val), avg(val), ((2 * val2)) + Group Key: (2 * xc_groupby_tab1.val2) + -> Seq Scan on public.xc_groupby_tab1 + Output: (2 * val2), val +(10 rows) + +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)); +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); +select a,count(a) from xc_groupby_def group by a order by a; + a | count +----+------- + 1 | 1 + 2 | 2 + 3 | 1 + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 + | 0 +(11 rows) + +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all + Output: a, count(a) + -> Sort + Output: a, (count(a)) + Sort Key: xc_groupby_def.a + -> HashAggregate + Output: a, count(a) + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b +(10 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + + 8.0000000000000000 + 1.00000000000000000000 + 5.0000000000000000 + 9.0000000000000000 + 6.0000000000000000 + 2.0000000000000000 + 4.0000000000000000 + 3.0000000000000000 + 10.0000000000000000 + 7.0000000000000000 +(11 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + + 8.0000000000000000 + 1.00000000000000000000 + 5.0000000000000000 + 9.0000000000000000 + 6.0000000000000000 + 2.0000000000000000 + 4.0000000000000000 + 3.0000000000000000 + 10.0000000000000000 + 7.0000000000000000 +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +----------------------------------------------- + Remote Subquery Scan on all + Output: avg(a), a + -> HashAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b +(7 rows) + +select avg(a) from xc_groupby_def group by b; + avg +-------------------- + 4.0000000000000000 + 4.5000000000000000 + 6.2000000000000000 + +(4 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(a))), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: avg(a), b + -> HashAggregate + Output: avg(a), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(10 rows) + +select sum(a) from xc_groupby_def group by b; + sum +----- + 8 + 18 + 31 + +(4 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------- + HashAggregate + Output: pg_catalog.sum((sum(a))), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: sum(a), b + -> HashAggregate + Output: sum(a), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(10 rows) + +select count(*) from xc_groupby_def group by b; + count +------- + 3 + 4 + 5 + 1 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: count(*), b + -> HashAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(10 rows) + +select count(*) from xc_groupby_def where a is not null group by a; + count +------- + 1 + 1 + 1 + 1 + 1 + 2 + 1 + 1 + 1 + 1 +(10 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + QUERY PLAN +------------------------------------------------------ + Remote Subquery Scan on all + Output: count(*), a + -> HashAggregate + Output: count(*), a + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b + Filter: (xc_groupby_def.a IS NOT NULL) +(8 rows) + +select * from (select b from xc_groupby_def group by b) q order by q.b; + b +------- + One + Three + Two + +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +---------------------------------------------------------------------- + Sort + Output: xc_groupby_def.b + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: xc_groupby_def.a, xc_groupby_def.b +(13 rows) + +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + b | count +-------+------- + One | 1 + Three | 5 + Two | 4 + | 0 +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------------- + Sort + Output: xc_groupby_def.b, (count((count(xc_groupby_def.b)))) + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: xc_groupby_def.b, count(xc_groupby_def.b) + -> HashAggregate + Output: xc_groupby_def.b, count(xc_groupby_def.b) + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: xc_groupby_def.a, xc_groupby_def.b +(13 rows) + +select count(*) from xc_groupby_def where b is null group by b; + count +------- + 3 +(1 row) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + QUERY PLAN +-------------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: count(*), b + -> HashAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b + Filter: (xc_groupby_def.b IS NULL) +(11 rows) + +create table xc_groupby_g(a int, b float, c numeric); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); +select sum(a) from xc_groupby_g group by a; + sum +----- + 2 + 2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; + QUERY PLAN +--------------------------------------------- + Remote Subquery Scan on all + Output: sum(a), a + -> HashAggregate + Output: sum(a), a + Group Key: xc_groupby_g.a + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(7 rows) + +select sum(b) from xc_groupby_g group by b; + sum +----- + 4.2 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------- + HashAggregate + Output: sum((sum(b))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: sum(b), b + -> HashAggregate + Output: sum(b), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(10 rows) + +select sum(c) from xc_groupby_g group by b; + sum +----- + 6.4 + 5.2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------- + HashAggregate + Output: pg_catalog.sum((sum(c))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: sum(c), b + -> HashAggregate + Output: sum(c), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(10 rows) + +select avg(a) from xc_groupby_g group by b; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(a))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: avg(a), b + -> HashAggregate + Output: avg(a), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(10 rows) + +select avg(b) from xc_groupby_g group by c; + avg +----- + 2.3 + 2.1 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +--------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(b))), c + Group Key: xc_groupby_g.c + -> Remote Subquery Scan on all + Output: avg(b), c + -> HashAggregate + Output: avg(b), c + Group Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(10 rows) + +select avg(c) from xc_groupby_g group by c; + avg +-------------------- + 5.2000000000000000 + 3.2000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +--------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(c))), c + Group Key: xc_groupby_g.c + -> Remote Subquery Scan on all + Output: avg(c), c + -> HashAggregate + Output: avg(c), c + Group Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(10 rows) + +drop table xc_groupby_def; +drop table xc_groupby_g; +-- Combination 2, enable_hashagg on and replicated tables. +-- repeat the same tests for replicated tables +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int) distribute by replication; +create table xc_groupby_tab2 (val int, val2 int) distribute by replication; +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + count | sum | avg | ?column? | val2 +-------+-----+--------------------+------------------+------ + 3 | 6 | 2.0000000000000000 | 2 | 1 + 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 + 2 | 8 | 4.0000000000000000 | 4 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Remote Fast Query Execution + Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), ((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision), xc_groupby_tab1.val2 + Remote query: SELECT count(*) AS count, sum(val) AS sum, avg(val) AS avg, ((sum(val))::double precision / (count(*))::double precision), val2 FROM xc_groupby_tab1 GROUP BY val2 + -> HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(8 rows) + +-- joins and group by +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; + count | sum | avg | ?column? | c1 | c2 +-------+-----+---------------------+------------------+----+---- + 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 + 6 | 96 | 16.0000000000000000 | 16 | 2 | 2 + 3 | | | | 3 | + 3 | | | | | 4 +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: count, sum, avg, "?column?", c1, c2 + -> GroupAggregate + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Merge Full Join + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Merge Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2) + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val2 + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(21 rows) + +-- aggregates over aggregates +select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; + sum +----- + 8 + 17 +(2 rows) + +explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: q.sum + -> Sort + Output: q.sum + Sort Key: q.sum + -> Subquery Scan on q + Output: q.sum + -> HashAggregate + Output: sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)) + Group Key: (xc_groupby_tab1.val2 % 2) + -> HashAggregate + Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val, xc_groupby_tab1.val2 +(15 rows) + +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; + val2 +------ + 1 + 3 + 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +---------------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_tab1.val2 + Remote query: SELECT val2 FROM xc_groupby_tab1 GROUP BY val2 + -> HashAggregate + Output: val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(8 rows) + +select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; + sum +----- + 2 + 3 + 4 + 7 + 8 + 9 +(6 rows) + +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; + QUERY PLAN +-------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: sum + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) + -> Seq Scan on public.xc_groupby_tab1 + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2) +(10 rows) + +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 4 | 1 | 3 + 3 | 2 | 1 + 4 | 2 | 2 + 4 | 3 | 1 + 7 | 4 | 3 + 8 | 6 | 2 + 9 | 6 | 3 +(8 rows) + +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: "?column?", val, val2 + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> HashAggregate + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val, xc_groupby_tab1.val2 +(10 rows) + +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 6 | 2 | 4 + 5 | 3 | 2 + 7 | 3 | 4 + 5 | 4 | 1 + 6 | 4 | 2 +(6 rows) + +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: "?column?", val, val2 + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> HashAggregate + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Merge Join + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(21 rows) + +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; + sum +----- + 2 + 5 + 6 + 7 +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; + QUERY PLAN +----------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: sum + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Merge Join + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(21 rows) + +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + ?column? | val2 +---------------------+------ + 11.0000000000000000 | 1 + 17.6666666666666667 | 3 + 14.0000000000000000 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT (((count(*) + sum(val)))::numeric + avg(val)), val2 FROM xc_groupby_tab1 GROUP BY val2 + -> HashAggregate + Output: (((count(*) + sum(val)))::numeric + avg(val)), val2 + Group Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(8 rows) + +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + sum | avg | ?column? +-----+--------------------+---------- + 8 | 4.0000000000000000 | 4 + 11 | 3.6666666666666667 | 6 + 6 | 2.0000000000000000 | 2 +(3 rows) + +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2) + Remote query: SELECT sum(val) AS sum, avg(val) AS avg, (2 * val2) FROM xc_groupby_tab1 GROUP BY (2 * val2) + -> HashAggregate + Output: sum(val), avg(val), ((2 * val2)) + Group Key: (2 * xc_groupby_tab1.val2) + -> Seq Scan on public.xc_groupby_tab1 + Output: (2 * val2), val +(8 rows) + +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)) distribute by replication; +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); +select a,count(a) from xc_groupby_def group by a order by a; + a | count +----+------- + 1 | 1 + 2 | 2 + 3 | 1 + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 + | 0 +(11 rows) + +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; + QUERY PLAN +--------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_def.a, count(xc_groupby_def.a) + Remote query: SELECT a, count(a) AS count FROM xc_groupby_def GROUP BY a ORDER BY a + -> Sort + Output: a, (count(a)) + Sort Key: xc_groupby_def.a + -> HashAggregate + Output: a, count(a) + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b +(11 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + + 8.0000000000000000 + 4.0000000000000000 + 1.00000000000000000000 + 5.0000000000000000 + 3.0000000000000000 + 10.0000000000000000 + 9.0000000000000000 + 6.0000000000000000 + 2.0000000000000000 + 7.0000000000000000 +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.a + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY a + -> HashAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b +(8 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + + 8.0000000000000000 + 4.0000000000000000 + 1.00000000000000000000 + 5.0000000000000000 + 3.0000000000000000 + 10.0000000000000000 + 9.0000000000000000 + 6.0000000000000000 + 2.0000000000000000 + 7.0000000000000000 +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.a + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY a + -> HashAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b +(8 rows) + +select avg(a) from xc_groupby_def group by b; + avg +-------------------- + 4.0000000000000000 + 4.5000000000000000 + 6.2000000000000000 + +(4 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.b + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY b + -> HashAggregate + Output: avg(a), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(8 rows) + +select sum(a) from xc_groupby_def group by b; + sum +----- + 8 + 18 + 31 + +(4 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_def.a), xc_groupby_def.b + Remote query: SELECT sum(a) AS sum FROM xc_groupby_def GROUP BY b + -> HashAggregate + Output: sum(a), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(8 rows) + +select count(*) from xc_groupby_def group by b; + count +------- + 3 + 4 + 5 + 1 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; + QUERY PLAN +------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.b + Remote query: SELECT count(*) AS count FROM xc_groupby_def GROUP BY b + -> HashAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b +(8 rows) + +select count(*) from xc_groupby_def where a is not null group by a; + count +------- + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 2 + 1 +(10 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + QUERY PLAN +----------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.a + Remote query: SELECT count(*) AS count FROM xc_groupby_def WHERE (a IS NOT NULL) GROUP BY a + -> HashAggregate + Output: count(*), a + Group Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a, b + Filter: (xc_groupby_def.a IS NOT NULL) +(9 rows) + +select * from (select b from xc_groupby_def group by b) q order by q.b; + b +------- + One + Three + Two + +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +---------------------------------------------------------------- + Remote Subquery Scan on all + Output: b + -> Sort + Output: xc_groupby_def.b + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: xc_groupby_def.a, xc_groupby_def.b +(10 rows) + +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + b | count +-------+------- + One | 1 + Three | 5 + Two | 4 + | 0 +(4 rows) + +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------- + Remote Subquery Scan on all + Output: b, count + -> Sort + Output: xc_groupby_def.b, (count(xc_groupby_def.b)) + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b, count(xc_groupby_def.b) + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: xc_groupby_def.a, xc_groupby_def.b +(10 rows) + +select count(*) from xc_groupby_def where b is null group by b; + count +------- + 3 +(1 row) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + QUERY PLAN +------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.b + Remote query: SELECT count(*) AS count FROM xc_groupby_def WHERE (b IS NULL) GROUP BY b + -> HashAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: a, b + Filter: (xc_groupby_def.b IS NULL) +(9 rows) + +create table xc_groupby_g(a int, b float, c numeric) distribute by replication; +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); +select sum(a) from xc_groupby_g group by a; + sum +----- + 2 + 2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.a), xc_groupby_g.a + Remote query: SELECT sum(a) AS sum FROM xc_groupby_g GROUP BY a + -> HashAggregate + Output: sum(a), a + Group Key: xc_groupby_g.a + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +select sum(b) from xc_groupby_g group by b; + sum +----- + 4.2 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.b), xc_groupby_g.b + Remote query: SELECT sum(b) AS sum FROM xc_groupby_g GROUP BY b + -> HashAggregate + Output: sum(b), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +select sum(c) from xc_groupby_g group by b; + sum +----- + 6.4 + 5.2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.c), xc_groupby_g.b + Remote query: SELECT sum(c) AS sum FROM xc_groupby_g GROUP BY b + -> HashAggregate + Output: sum(c), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +select avg(a) from xc_groupby_g group by b; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.a), xc_groupby_g.b + Remote query: SELECT avg(a) AS avg FROM xc_groupby_g GROUP BY b + -> HashAggregate + Output: avg(a), b + Group Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +select avg(b) from xc_groupby_g group by c; + avg +----- + 2.3 + 2.1 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.b), xc_groupby_g.c + Remote query: SELECT avg(b) AS avg FROM xc_groupby_g GROUP BY c + -> HashAggregate + Output: avg(b), c + Group Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +select avg(c) from xc_groupby_g group by c; + avg +-------------------- + 5.2000000000000000 + 3.2000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.c), xc_groupby_g.c + Remote query: SELECT avg(c) AS avg FROM xc_groupby_g GROUP BY c + -> HashAggregate + Output: avg(c), c + Group Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: a, b, c +(8 rows) + +drop table xc_groupby_def; +drop table xc_groupby_g; +reset enable_hashagg; +-- Combination 3 enable_hashagg off and distributed tables +set enable_hashagg to off; +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int); +create table xc_groupby_tab2 (val int, val2 int); +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + count | sum | avg | ?column? | val2 +-------+-----+--------------------+------------------+------ + 3 | 6 | 2.0000000000000000 | 2 | 1 + 2 | 8 | 4.0000000000000000 | 4 | 2 + 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((pg_catalog.sum((sum(val))))::double precision / (pg_catalog.count(*))::double precision), val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: count(*), sum(val), avg(val), val2 + -> GroupAggregate + Output: count(*), sum(val), avg(val), val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: val2, val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2, val +(13 rows) + +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + count | sum | avg | ?column? | val2 | val2 +-------+-----+---------------------+------------------+------+------ + 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 + 6 | 96 | 16.0000000000000000 | 16 | 2 | 2 + 3 | | | | 3 | + 3 | | | | | 4 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Remote Subquery Scan on all + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> GroupAggregate + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Merge Full Join + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Merge Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2) + -> Remote Subquery Scan on all + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Distribute results by H: val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + -> Materialize + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + -> Remote Subquery Scan on all + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Distribute results by H: val2 + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val2 + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(32 rows) + +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + sum +----- + 8 + 17 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: sum(q1.y), q1.x + Group Key: q1.x + -> Sort + Output: q1.x, q1.y + Sort Key: q1.x + -> Subquery Scan on q1 + Output: q1.x, q1.y + -> GroupAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: sum(xc_groupby_tab1.val), xc_groupby_tab1.val2, xc_groupby_tab1.val2 + -> GroupAggregate + Output: sum(xc_groupby_tab1.val), xc_groupby_tab1.val2, xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val +(21 rows) + +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; + val2 +------ + 1 + 2 + 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +------------------------------------------------------ + Group + Output: val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: val2 + -> Sort + Output: val2 + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2 +(10 rows) + +select val + val2 from xc_groupby_tab1 group by val + val2; + ?column? +---------- + 2 + 3 + 4 + 7 + 8 + 9 +(6 rows) + +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; + QUERY PLAN +------------------------------------------------------------------------ + Group + Output: ((val + val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) + -> Remote Subquery Scan on all + Output: (val + val2) + -> Sort + Output: ((val + val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> Seq Scan on public.xc_groupby_tab1 + Output: (val + val2) +(10 rows) + +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 4 | 1 | 3 + 3 | 2 | 1 + 4 | 2 | 2 + 8 | 6 | 2 + 9 | 6 | 3 + 4 | 3 | 1 + 7 | 4 | 3 +(8 rows) + +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM xc_groupby_tab1 GROUP BY val, val2 + -> Group + Output: (val + val2), val, val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Sort + Output: val, val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(11 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 6 | 2 | 4 + 5 | 3 | 2 + 7 | 3 | 4 + 5 | 4 | 1 + 6 | 4 | 2 +(6 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 FROM xc_groupby_tab1, xc_groupby_tab2 WHERE (xc_groupby_tab1.val = xc_groupby_tab2.val) GROUP BY xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Group + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Merge Join + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(22 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + ?column? +---------- + 2 + 5 + 6 + 7 +(4 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------- + Group + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Group Key: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Remote Subquery Scan on all + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> Merge Join + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(21 rows) + +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + ?column? | val2 +---------------------+------ + 11.0000000000000000 | 1 + 14.0000000000000000 | 2 + 17.6666666666666667 | 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2 + Group Key: xc_groupby_tab1.val2 + -> Remote Subquery Scan on all + Output: count(*), sum(val), avg(val), val2 + -> GroupAggregate + Output: count(*), sum(val), avg(val), val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: val2, val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2, val +(13 rows) + +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + sum | avg | ?column? +-----+--------------------+---------- + 6 | 2.0000000000000000 | 2 + 8 | 4.0000000000000000 | 4 + 11 | 3.6666666666666667 | 6 +(3 rows) + +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +-------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), ((2 * val2)) + Group Key: (2 * xc_groupby_tab1.val2) + -> Remote Subquery Scan on all + Output: sum(val), avg(val), (2 * val2) + -> GroupAggregate + Output: sum(val), avg(val), ((2 * val2)) + Group Key: ((2 * xc_groupby_tab1.val2)) + -> Sort + Output: ((2 * val2)), val + Sort Key: ((2 * xc_groupby_tab1.val2)) + -> Seq Scan on public.xc_groupby_tab1 + Output: (2 * val2), val +(13 rows) + +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)); +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); +select a,count(a) from xc_groupby_def group by a order by a; + a | count +----+------- + 1 | 1 + 2 | 2 + 3 | 1 + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 + | 0 +(11 rows) + +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all + Output: a, count(a) + -> GroupAggregate + Output: a, count(a) + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a +(10 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 + 3.0000000000000000 + 4.0000000000000000 + 5.0000000000000000 + 6.0000000000000000 + 7.0000000000000000 + 8.0000000000000000 + 9.0000000000000000 + 10.0000000000000000 + +(11 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 + 3.0000000000000000 + 4.0000000000000000 + 5.0000000000000000 + 6.0000000000000000 + 7.0000000000000000 + 8.0000000000000000 + 9.0000000000000000 + 10.0000000000000000 + +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +----------------------------------------------------- + Remote Subquery Scan on all + Output: avg(a), a + -> GroupAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a +(10 rows) + +select avg(a) from xc_groupby_def group by b; + avg +-------------------- + + 6.2000000000000000 + 4.5000000000000000 + 4.0000000000000000 +(4 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------------- + GroupAggregate + Output: pg_catalog.avg((avg(a))), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: avg(a), b + -> GroupAggregate + Output: avg(a), b + Group Key: xc_groupby_def.b + -> Sort + Output: b, a + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b, a +(13 rows) + +select sum(a) from xc_groupby_def group by b; + sum +----- + + 31 + 18 + 8 +(4 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------------- + GroupAggregate + Output: pg_catalog.sum((sum(a))), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: sum(a), b + -> GroupAggregate + Output: sum(a), b + Group Key: xc_groupby_def.b + -> Sort + Output: b, a + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b, a +(13 rows) + +select count(*) from xc_groupby_def group by b; + count +------- + 1 + 5 + 4 + 3 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: count(*), b + -> GroupAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(13 rows) + +select count(*) from xc_groupby_def where a is not null group by a; + count +------- + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +(10 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + QUERY PLAN +------------------------------------------------------------ + Remote Subquery Scan on all + Output: count(*), a + -> GroupAggregate + Output: count(*), a + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a + Filter: (xc_groupby_def.a IS NOT NULL) +(11 rows) + +select b from xc_groupby_def group by b; + b +------- + One + Three + Two + +(4 rows) + +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------- + Group + Output: b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(10 rows) + +select b,count(b) from xc_groupby_def group by b; + b | count +-------+------- + One | 1 + Three | 5 + Two | 4 + | 0 +(4 rows) + +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; + QUERY PLAN +----------------------------------------------------------- + GroupAggregate + Output: b, count((count(b))) + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: b, count(b) + -> GroupAggregate + Output: b, count(b) + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(13 rows) + +select count(*) from xc_groupby_def where b is null group by b; + count +------- + 3 +(1 row) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + QUERY PLAN +-------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), b + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: count(*), b + -> GroupAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b + Filter: (xc_groupby_def.b IS NULL) +(14 rows) + +create table xc_groupby_g(a int, b float, c numeric); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); +select sum(a) from xc_groupby_g group by a; + sum +----- + 2 + 2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; + QUERY PLAN +--------------------------------------------------- + Remote Subquery Scan on all + Output: sum(a), a + -> GroupAggregate + Output: sum(a), a + Group Key: xc_groupby_g.a + -> Sort + Output: a + Sort Key: xc_groupby_g.a + -> Seq Scan on public.xc_groupby_g + Output: a +(10 rows) + +select sum(b) from xc_groupby_g group by b; + sum +----- + 4.2 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------------- + GroupAggregate + Output: sum((sum(b))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: sum(b), b + -> GroupAggregate + Output: sum(b), b + Group Key: xc_groupby_g.b + -> Sort + Output: b + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b +(13 rows) + +select sum(c) from xc_groupby_g group by b; + sum +----- + 6.4 + 5.2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------------- + GroupAggregate + Output: pg_catalog.sum((sum(c))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: sum(c), b + -> GroupAggregate + Output: sum(c), b + Group Key: xc_groupby_g.b + -> Sort + Output: b, c + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b, c +(13 rows) + +select avg(a) from xc_groupby_g group by b; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +--------------------------------------------------------- + GroupAggregate + Output: pg_catalog.avg((avg(a))), b + Group Key: xc_groupby_g.b + -> Remote Subquery Scan on all + Output: avg(a), b + -> GroupAggregate + Output: avg(a), b + Group Key: xc_groupby_g.b + -> Sort + Output: b, a + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b, a +(13 rows) + +select avg(b) from xc_groupby_g group by c; + avg +----- + 2.1 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +--------------------------------------------------------- + GroupAggregate + Output: pg_catalog.avg((avg(b))), c + Group Key: xc_groupby_g.c + -> Remote Subquery Scan on all + Output: avg(b), c + -> GroupAggregate + Output: avg(b), c + Group Key: xc_groupby_g.c + -> Sort + Output: c, b + Sort Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: c, b +(13 rows) + +select avg(c) from xc_groupby_g group by c; + avg +-------------------- + 3.2000000000000000 + 5.2000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +--------------------------------------------------------- + GroupAggregate + Output: pg_catalog.avg((avg(c))), c + Group Key: xc_groupby_g.c + -> Remote Subquery Scan on all + Output: avg(c), c + -> GroupAggregate + Output: avg(c), c + Group Key: xc_groupby_g.c + -> Sort + Output: c + Sort Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: c +(13 rows) + +drop table xc_groupby_def; +drop table xc_groupby_g; +-- Combination 4 enable_hashagg off and replicated tables. +-- repeat the same tests for replicated tables +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int) distribute by replication; +create table xc_groupby_tab2 (val int, val2 int) distribute by replication; +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + count | sum | avg | ?column? | val2 +-------+-----+--------------------+------------------+------ + 3 | 6 | 2.0000000000000000 | 2 | 1 + 2 | 8 | 4.0000000000000000 | 4 | 2 + 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Remote Fast Query Execution + Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), ((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision), xc_groupby_tab1.val2 + Remote query: SELECT count(*) AS count, sum(val) AS sum, avg(val) AS avg, ((sum(val))::double precision / (count(*))::double precision), val2 FROM xc_groupby_tab1 GROUP BY val2 + -> GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: val2, val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2, val +(11 rows) + +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + count | sum | avg | ?column? | val2 | val2 +-------+-----+---------------------+------------------+------+------ + 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 + 6 | 96 | 16.0000000000000000 | 16 | 2 | 2 + 3 | | | | 3 | + 3 | | | | | 4 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Remote query: SELECT count(*) AS count, sum((xc_groupby_tab1.val * xc_groupby_tab2.val)) AS sum, avg((xc_groupby_tab1.val * xc_groupby_tab2.val)) AS avg, ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 FROM (xc_groupby_tab1 FULL JOIN xc_groupby_tab2 ON ((xc_groupby_tab1.val2 = xc_groupby_tab2.val2))) GROUP BY xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> GroupAggregate + Output: count(*), sum((xc_groupby_tab1.val * xc_groupby_tab2.val)), avg((xc_groupby_tab1.val * xc_groupby_tab2.val)), ((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Merge Full Join + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Merge Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2) + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val2 + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(22 rows) + +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + sum +----- + 8 + 17 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + Remote Subquery Scan on all + Output: sum(q1.y), q1.x + -> GroupAggregate + Output: sum(q1.y), q1.x + Group Key: q1.x + -> Sort + Output: q1.x, q1.y + Sort Key: q1.x + -> Subquery Scan on q1 + Output: q1.x, q1.y + -> GroupAggregate + Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val +(18 rows) + +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; + val2 +------ + 1 + 2 + 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +---------------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_tab1.val2 + Remote query: SELECT val2 FROM xc_groupby_tab1 GROUP BY val2 + -> Group + Output: val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: val2 + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2 +(11 rows) + +select val + val2 from xc_groupby_tab1 group by val + val2; + ?column? +---------- + 2 + 3 + 4 + 7 + 8 + 9 +(6 rows) + +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; + QUERY PLAN +-------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2) + Remote query: SELECT (val + val2) FROM xc_groupby_tab1 GROUP BY (val + val2) + -> Group + Output: ((val + val2)) + Group Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> Sort + Output: ((val + val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> Seq Scan on public.xc_groupby_tab1 + Output: (val + val2) +(11 rows) + +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 4 | 1 | 3 + 3 | 2 | 1 + 4 | 2 | 2 + 4 | 3 | 1 + 7 | 4 | 3 + 8 | 6 | 2 + 9 | 6 | 3 +(8 rows) + +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM xc_groupby_tab1 GROUP BY val, val2 + -> Group + Output: (val + val2), val, val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Sort + Output: val, val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val, val2 +(11 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + ?column? | val | val2 +----------+-----+------ + 2 | 1 | 1 + 6 | 2 | 4 + 5 | 3 | 2 + 7 | 3 | 4 + 5 | 4 | 1 + 6 | 4 | 2 +(6 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 FROM xc_groupby_tab1, xc_groupby_tab2 WHERE (xc_groupby_tab1.val = xc_groupby_tab2.val) GROUP BY xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Group + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Group Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Sort + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Merge Join + Output: xc_groupby_tab1.val, xc_groupby_tab2.val2 + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(22 rows) + +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + ?column? +---------- + 2 + 5 + 6 + 7 +(4 rows) + +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + Remote query: SELECT (xc_groupby_tab1.val + xc_groupby_tab2.val2) FROM xc_groupby_tab1, xc_groupby_tab2 WHERE (xc_groupby_tab1.val = xc_groupby_tab2.val) GROUP BY (xc_groupby_tab1.val + xc_groupby_tab2.val2) + -> Group + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Group Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> Sort + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> Merge Join + Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2) + Merge Cond: (xc_groupby_tab1.val = xc_groupby_tab2.val) + -> Sort + Output: xc_groupby_tab1.val + Sort Key: xc_groupby_tab1.val + -> Seq Scan on public.xc_groupby_tab1 + Output: xc_groupby_tab1.val + -> Sort + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val + Sort Key: xc_groupby_tab2.val + -> Seq Scan on public.xc_groupby_tab2 + Output: xc_groupby_tab2.val2, xc_groupby_tab2.val +(22 rows) + +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + ?column? | val2 +---------------------+------ + 11.0000000000000000 | 1 + 14.0000000000000000 | 2 + 17.6666666666666667 | 3 +(3 rows) + +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: (((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT (((count(*) + sum(val)))::numeric + avg(val)), val2 FROM xc_groupby_tab1 GROUP BY val2 + -> GroupAggregate + Output: (((count(*) + sum(val)))::numeric + avg(val)), val2 + Group Key: xc_groupby_tab1.val2 + -> Sort + Output: val2, val + Sort Key: xc_groupby_tab1.val2 + -> Seq Scan on public.xc_groupby_tab1 + Output: val2, val +(11 rows) + +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + sum | avg | ?column? +-----+--------------------+---------- + 6 | 2.0000000000000000 | 2 + 8 | 4.0000000000000000 | 4 + 11 | 3.6666666666666667 | 6 +(3 rows) + +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2) + Remote query: SELECT sum(val) AS sum, avg(val) AS avg, (2 * val2) FROM xc_groupby_tab1 GROUP BY (2 * val2) + -> GroupAggregate + Output: sum(val), avg(val), ((2 * val2)) + Group Key: ((2 * xc_groupby_tab1.val2)) + -> Sort + Output: ((2 * val2)), val + Sort Key: ((2 * xc_groupby_tab1.val2)) + -> Seq Scan on public.xc_groupby_tab1 + Output: (2 * val2), val +(11 rows) + +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)) distribute by replication; +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); +select a,count(a) from xc_groupby_def group by a order by a; + a | count +----+------- + 1 | 1 + 2 | 2 + 3 | 1 + 4 | 1 + 5 | 1 + 6 | 1 + 7 | 1 + 8 | 1 + 9 | 1 + 10 | 1 + | 0 +(11 rows) + +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; + QUERY PLAN +--------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_def.a, count(xc_groupby_def.a) + Remote query: SELECT a, count(a) AS count FROM xc_groupby_def GROUP BY a ORDER BY a + -> GroupAggregate + Output: a, count(a) + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a +(11 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 + 3.0000000000000000 + 4.0000000000000000 + 5.0000000000000000 + 6.0000000000000000 + 7.0000000000000000 + 8.0000000000000000 + 9.0000000000000000 + 10.0000000000000000 + +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.a + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY a + -> GroupAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a +(11 rows) + +select avg(a) from xc_groupby_def group by a; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 + 3.0000000000000000 + 4.0000000000000000 + 5.0000000000000000 + 6.0000000000000000 + 7.0000000000000000 + 8.0000000000000000 + 9.0000000000000000 + 10.0000000000000000 + +(11 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.a + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY a + -> GroupAggregate + Output: avg(a), a + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a +(11 rows) + +select avg(a) from xc_groupby_def group by b; + avg +-------------------- + + 6.2000000000000000 + 4.5000000000000000 + 4.0000000000000000 +(4 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_def.a), xc_groupby_def.b + Remote query: SELECT avg(a) AS avg FROM xc_groupby_def GROUP BY b + -> GroupAggregate + Output: avg(a), b + Group Key: xc_groupby_def.b + -> Sort + Output: b, a + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b, a +(11 rows) + +select sum(a) from xc_groupby_def group by b; + sum +----- + + 31 + 18 + 8 +(4 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; + QUERY PLAN +--------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_def.a), xc_groupby_def.b + Remote query: SELECT sum(a) AS sum FROM xc_groupby_def GROUP BY b + -> GroupAggregate + Output: sum(a), b + Group Key: xc_groupby_def.b + -> Sort + Output: b, a + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b, a +(11 rows) + +select count(*) from xc_groupby_def group by b; + count +------- + 1 + 5 + 4 + 3 +(4 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; + QUERY PLAN +------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.b + Remote query: SELECT count(*) AS count FROM xc_groupby_def GROUP BY b + -> GroupAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(11 rows) + +select count(*) from xc_groupby_def where a is not null group by a; + count +------- + 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +(10 rows) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + QUERY PLAN +----------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.a + Remote query: SELECT count(*) AS count FROM xc_groupby_def WHERE (a IS NOT NULL) GROUP BY a + -> GroupAggregate + Output: count(*), a + Group Key: xc_groupby_def.a + -> Sort + Output: a + Sort Key: xc_groupby_def.a + -> Seq Scan on public.xc_groupby_def + Output: a + Filter: (xc_groupby_def.a IS NOT NULL) +(12 rows) + +select b from xc_groupby_def group by b; + b +------- + One + Three + Two + +(4 rows) + +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; + QUERY PLAN +--------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_def.b + Remote query: SELECT b FROM xc_groupby_def GROUP BY b + -> Group + Output: b + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(11 rows) + +select b,count(b) from xc_groupby_def group by b; + b | count +-------+------- + One | 1 + Three | 5 + Two | 4 + | 0 +(4 rows) + +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; + QUERY PLAN +---------------------------------------------------------------------------- + Remote Fast Query Execution + Output: xc_groupby_def.b, count(xc_groupby_def.b) + Remote query: SELECT b, count(b) AS count FROM xc_groupby_def GROUP BY b + -> GroupAggregate + Output: b, count(b) + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b +(11 rows) + +select count(*) from xc_groupby_def where b is null group by b; + count +------- + 3 +(1 row) + +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + QUERY PLAN +------------------------------------------------------------------------------------------- + Remote Fast Query Execution + Output: count(*), xc_groupby_def.b + Remote query: SELECT count(*) AS count FROM xc_groupby_def WHERE (b IS NULL) GROUP BY b + -> GroupAggregate + Output: count(*), b + Group Key: xc_groupby_def.b + -> Sort + Output: b + Sort Key: xc_groupby_def.b + -> Seq Scan on public.xc_groupby_def + Output: b + Filter: (xc_groupby_def.b IS NULL) +(12 rows) + +create table xc_groupby_g(a int, b float, c numeric) distribute by replication; +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); +select sum(a) from xc_groupby_g group by a; + sum +----- + 2 + 2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.a), xc_groupby_g.a + Remote query: SELECT sum(a) AS sum FROM xc_groupby_g GROUP BY a + -> GroupAggregate + Output: sum(a), a + Group Key: xc_groupby_g.a + -> Sort + Output: a + Sort Key: xc_groupby_g.a + -> Seq Scan on public.xc_groupby_g + Output: a +(11 rows) + +select sum(b) from xc_groupby_g group by b; + sum +----- + 4.2 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.b), xc_groupby_g.b + Remote query: SELECT sum(b) AS sum FROM xc_groupby_g GROUP BY b + -> GroupAggregate + Output: sum(b), b + Group Key: xc_groupby_g.b + -> Sort + Output: b + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b +(11 rows) + +select sum(c) from xc_groupby_g group by b; + sum +----- + 6.4 + 5.2 +(2 rows) + +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: sum(xc_groupby_g.c), xc_groupby_g.b + Remote query: SELECT sum(c) AS sum FROM xc_groupby_g GROUP BY b + -> GroupAggregate + Output: sum(c), b + Group Key: xc_groupby_g.b + -> Sort + Output: b, c + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b, c +(11 rows) + +select avg(a) from xc_groupby_g group by b; + avg +------------------------ + 1.00000000000000000000 + 2.0000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.a), xc_groupby_g.b + Remote query: SELECT avg(a) AS avg FROM xc_groupby_g GROUP BY b + -> GroupAggregate + Output: avg(a), b + Group Key: xc_groupby_g.b + -> Sort + Output: b, a + Sort Key: xc_groupby_g.b + -> Seq Scan on public.xc_groupby_g + Output: b, a +(11 rows) + +select avg(b) from xc_groupby_g group by c; + avg +----- + 2.1 + 2.3 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.b), xc_groupby_g.c + Remote query: SELECT avg(b) AS avg FROM xc_groupby_g GROUP BY c + -> GroupAggregate + Output: avg(b), c + Group Key: xc_groupby_g.c + -> Sort + Output: c, b + Sort Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: c, b +(11 rows) + +select avg(c) from xc_groupby_g group by c; + avg +-------------------- + 3.2000000000000000 + 5.2000000000000000 +(2 rows) + +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------- + Remote Fast Query Execution + Output: avg(xc_groupby_g.c), xc_groupby_g.c + Remote query: SELECT avg(c) AS avg FROM xc_groupby_g GROUP BY c + -> GroupAggregate + Output: avg(c), c + Group Key: xc_groupby_g.c + -> Sort + Output: c + Sort Key: xc_groupby_g.c + -> Seq Scan on public.xc_groupby_g + Output: c +(11 rows) + +drop table xc_groupby_def; +drop table xc_groupby_g; +reset enable_hashagg; +reset enable_fast_query_shipping; diff --git a/src/test/regress/sql/xc_groupby.sql b/src/test/regress/sql/xc_groupby.sql index a51f68b2c5..8c362912c1 100644 --- a/src/test/regress/sql/xc_groupby.sql +++ b/src/test/regress/sql/xc_groupby.sql @@ -389,3 +389,388 @@ drop table xc_groupby_g; reset enable_hashagg; reset enable_fast_query_shipping; + +-- Now repeat all the tests with FQS turned on +set enable_fast_query_shipping to on; + +-- Combination 1: enable_hashagg on and distributed tables +set enable_hashagg to on; +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int); +create table xc_groupby_tab2 (val int, val2 int); +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select val + val2 from xc_groupby_tab1 group by val + val2; +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; + +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)); +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); + +select a,count(a) from xc_groupby_def group by a order by a; +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; +select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; +select sum(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; +select count(*) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where a is not null group by a; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + +select * from (select b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +select count(*) from xc_groupby_def where b is null group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + +create table xc_groupby_g(a int, b float, c numeric); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); + +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + +drop table xc_groupby_def; +drop table xc_groupby_g; + +-- Combination 2, enable_hashagg on and replicated tables. +-- repeat the same tests for replicated tables +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int) distribute by replication; +create table xc_groupby_tab2 (val int, val2 int) distribute by replication; +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +-- joins and group by +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; +-- aggregates over aggregates +select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; + +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)) distribute by replication; +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); + +select a,count(a) from xc_groupby_def group by a order by a; +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; +select sum(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; +select count(*) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where a is not null group by a; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + +select * from (select b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +select count(*) from xc_groupby_def where b is null group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + +create table xc_groupby_g(a int, b float, c numeric) distribute by replication; +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); + +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + +drop table xc_groupby_def; +drop table xc_groupby_g; +reset enable_hashagg; + +-- Combination 3 enable_hashagg off and distributed tables +set enable_hashagg to off; +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int); +create table xc_groupby_tab2 (val int, val2 int); +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select val + val2 from xc_groupby_tab1 group by val + val2; +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; + +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)); +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); + +select a,count(a) from xc_groupby_def group by a order by a; +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; +select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; +select sum(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; +select count(*) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where a is not null group by a; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + +select b from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; +select b,count(b) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where b is null group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + +create table xc_groupby_g(a int, b float, c numeric); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); + +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + +drop table xc_groupby_def; +drop table xc_groupby_g; + +-- Combination 4 enable_hashagg off and replicated tables. +-- repeat the same tests for replicated tables +-- create required tables and fill them with data +create table xc_groupby_tab1 (val int, val2 int) distribute by replication; +create table xc_groupby_tab2 (val int, val2 int) distribute by replication; +insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); +insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; +-- joins and group by +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +-- aggregates over aggregates +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +-- group by without aggregate +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select val + val2 from xc_groupby_tab1 group by val + val2; +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +-- group by with aggregates in expression +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +-- group by with expressions in group by clause +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +drop table xc_groupby_tab1; +drop table xc_groupby_tab2; + +-- some tests involving nulls, characters, float type etc. +create table xc_groupby_def(a int, b varchar(25)) distribute by replication; +insert into xc_groupby_def VALUES (NULL, NULL); +insert into xc_groupby_def VALUES (1, NULL); +insert into xc_groupby_def VALUES (NULL, 'One'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (2, 'Two'); +insert into xc_groupby_def VALUES (3, 'Three'); +insert into xc_groupby_def VALUES (4, 'Three'); +insert into xc_groupby_def VALUES (5, 'Three'); +insert into xc_groupby_def VALUES (6, 'Two'); +insert into xc_groupby_def VALUES (7, NULL); +insert into xc_groupby_def VALUES (8, 'Two'); +insert into xc_groupby_def VALUES (9, 'Three'); +insert into xc_groupby_def VALUES (10, 'Three'); + +select a,count(a) from xc_groupby_def group by a order by a; +explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by a; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a; +select avg(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by b; +select sum(a) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_def group by b; +select count(*) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where a is not null group by a; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a; + +select b from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; +select b,count(b) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; +select count(*) from xc_groupby_def where b is null group by b; +explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; + +create table xc_groupby_g(a int, b float, c numeric) distribute by replication; +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(1,2.1,3.2); +insert into xc_groupby_g values(2,2.3,5.2); + +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + +drop table xc_groupby_def; +drop table xc_groupby_g; + +reset enable_hashagg; +reset enable_fast_query_shipping; |