From: Tomas Vondra Date: Fri, 3 Mar 2017 16:08:43 +0000 (+0100) Subject: accept plan changes caused by Aggregate -> Partial/Finalize Aggregate X-Git-Tag: XL_10_R1BETA1~384 X-Git-Url: http://git.postgresql.org/gitweb/static/gitweb.js?a=commitdiff_plain;h=4106a669cdc1b6be1a26f32da943a4465307590d;p=postgres-xl.git accept plan changes caused by Aggregate -> Partial/Finalize Aggregate Most of the plan changes are obviously correct, caused by trivial changes due to upstream now supporting partial aggregation. There are a few larger changes (including e.g. switch from hash to sort), but those are supported by also checking the query results. --- diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out index 49dcb1814b..f95530f345 100644 --- a/src/test/regress/expected/join.out +++ b/src/test/regress/expected/join.out @@ -3360,9 +3360,9 @@ select count(*) from join int4_tbl on b.thousand = f1; QUERY PLAN ------------------------------------------------------------------------------------------------- - Aggregate + Finalize Aggregate -> Remote Subquery Scan on all - -> Aggregate + -> Partial Aggregate -> Nested Loop Left Join Join Filter: (a.unique2 = b.unique1) -> Remote Subquery Scan on all @@ -4726,9 +4726,9 @@ explain (num_nodes off, nodes off, costs off) tenk1 b join lateral (values(a.unique1)) ss(x) on b.unique2 = ss.x; QUERY PLAN ------------------------------------------------------------------------------ - Aggregate + Finalize Aggregate -> Remote Subquery Scan on all - -> Aggregate + -> Partial Aggregate -> Merge Join Merge Cond: (b.unique2 = a.unique1) -> Remote Subquery Scan on all @@ -5632,12 +5632,12 @@ set enable_hashjoin TO false; EXPLAIN VERBOSE SELECT count(*) FROM testr WHERE NOT EXISTS (SELECT * FROM testh WHERE testr.b = testh.b); QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- - Aggregate (cost=41632.20..41632.21 rows=1 width=0) - Output: pg_catalog.count(*) - -> Remote Subquery Scan on all (datanode_1,datanode_2) (cost=0.00..41629.38 rows=1130 width=0) - Output: count(*) - -> Aggregate (cost=0.00..41629.38 rows=1 width=0) - Output: count(*) + Finalize Aggregate (cost=41732.22..41732.23 rows=1 width=8) + Output: count(*) + -> Remote Subquery Scan on all (datanode_1,datanode_2) (cost=41732.20..41732.22 rows=1 width=8) + Output: PARTIAL count(*) + -> Partial Aggregate (cost=41632.20..41632.21 rows=1 width=8) + Output: PARTIAL count(*) -> Nested Loop Anti Join (cost=0.00..41629.38 rows=1130 width=0) Join Filter: (testr.b = testh.b) -> Remote Subquery Scan on all (datanode_1) (cost=100.00..152.94 rows=2260 width=4) diff --git a/src/test/regress/expected/tablesample.out b/src/test/regress/expected/tablesample.out index 49587295a4..35fd45379b 100644 --- a/src/test/regress/expected/tablesample.out +++ b/src/test/regress/expected/tablesample.out @@ -194,9 +194,9 @@ explain (costs off) select count(*) from person tablesample bernoulli (100); QUERY PLAN ------------------------------------------------------------- - Aggregate + Finalize Aggregate -> Remote Subquery Scan on all (datanode_1,datanode_2) - -> Aggregate + -> Partial Aggregate -> Append -> Sample Scan on person Sampling: bernoulli ('100'::real) diff --git a/src/test/regress/expected/xc_FQS.out b/src/test/regress/expected/xc_FQS.out index ba56c7df0c..b635a9c689 100644 --- a/src/test/regress/expected/xc_FQS.out +++ b/src/test/regress/expected/xc_FQS.out @@ -89,14 +89,14 @@ select sum(val), avg(val), count(*) from tab1_rr; (1 row) explain (verbose on, nodes off, costs off) select sum(val), avg(val), count(*) from tab1_rr; - QUERY PLAN ---------------------------------------------------------------------------------------- - Aggregate - Output: pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), pg_catalog.count(*) + QUERY PLAN +---------------------------------------------------------------------------- + Finalize Aggregate + Output: sum(val), avg(val), count(*) -> Remote Subquery Scan on all - Output: sum(val), avg(val), count(*) - -> Aggregate - Output: sum(val), avg(val), count(*) + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) + -> Partial Aggregate + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) -> Seq Scan on public.tab1_rr Output: val, val2 (8 rows) @@ -360,12 +360,12 @@ select avg(val) from tab1_rr where val = 7; explain (verbose on, nodes off, costs off) select avg(val) from tab1_rr where val = 7; QUERY PLAN ----------------------------------------------- - Aggregate - Output: pg_catalog.avg((avg(val))) + Finalize Aggregate + Output: avg(val) -> Remote Subquery Scan on all - Output: avg(val) - -> Aggregate - Output: avg(val) + Output: PARTIAL avg(val) + -> Partial Aggregate + Output: PARTIAL avg(val) -> Seq Scan on public.tab1_rr Output: val, val2 Filter: (tab1_rr.val = 7) @@ -506,14 +506,14 @@ select sum(val), avg(val), count(*) from tab1_hash; (1 row) explain (verbose on, nodes off, costs off) select sum(val), avg(val), count(*) from tab1_hash; - QUERY PLAN ---------------------------------------------------------------------------------------- - Aggregate - Output: pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), pg_catalog.count(*) + QUERY PLAN +---------------------------------------------------------------------------- + Finalize Aggregate + Output: sum(val), avg(val), count(*) -> Remote Subquery Scan on all - Output: sum(val), avg(val), count(*) - -> Aggregate - Output: sum(val), avg(val), count(*) + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) + -> Partial Aggregate + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) -> Seq Scan on public.tab1_hash Output: val, val2 (8 rows) @@ -918,14 +918,14 @@ select sum(val), avg(val), count(*) from tab1_modulo; (1 row) explain (verbose on, nodes off, costs off) select sum(val), avg(val), count(*) from tab1_modulo; - QUERY PLAN ---------------------------------------------------------------------------------------- - Aggregate - Output: pg_catalog.sum((sum(val))), pg_catalog.avg((avg(val))), pg_catalog.count(*) + QUERY PLAN +---------------------------------------------------------------------------- + Finalize Aggregate + Output: sum(val), avg(val), count(*) -> Remote Subquery Scan on all - Output: sum(val), avg(val), count(*) - -> Aggregate - Output: sum(val), avg(val), count(*) + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) + -> Partial Aggregate + Output: PARTIAL sum(val), PARTIAL avg(val), PARTIAL count(*) -> Seq Scan on public.tab1_modulo Output: val, val2 (8 rows) diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out index 0b0f0b2826..0d8d489573 100644 --- a/src/test/regress/expected/xc_groupby.out +++ b/src/test/regress/expected/xc_groupby.out @@ -22,15 +22,15 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro (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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: val, val2 @@ -92,18 +92,18 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va (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 --------------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------- HashAggregate - Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2)) + Output: 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 + -> Finalize HashAggregate + Output: 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 + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) + -> Partial HashAggregate + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: xc_groupby_tab1.val, xc_groupby_tab1.val2 @@ -121,12 +121,12 @@ 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; QUERY PLAN ------------------------------------------------------ - HashAggregate + Finalize HashAggregate Output: val2 Group Key: xc_groupby_tab1.val2 -> Remote Subquery Scan on all Output: val2 - -> HashAggregate + -> Partial HashAggregate Output: val2 Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 @@ -147,12 +147,12 @@ 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; QUERY PLAN ----------------------------------------------------------------------- - HashAggregate + Finalize HashAggregate Output: ((val + val2)) Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) -> Remote Subquery Scan on all Output: (val + val2) - -> HashAggregate + -> Partial HashAggregate Output: ((val + val2)) Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) -> Seq Scan on public.xc_groupby_tab1 @@ -265,15 +265,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; (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 + QUERY PLAN +---------------------------------------------------------------------------------- + Finalize HashAggregate + Output: (((count(*) + sum(val)))::numeric + 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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: val, val2 @@ -289,15 +289,15 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; (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)) + QUERY PLAN +------------------------------------------------------------------------ + Finalize HashAggregate + Output: sum(val), 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)) + Output: (2 * val2), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: ((2 * val2)), PARTIAL sum(val), PARTIAL avg(val) Group Key: (2 * xc_groupby_tab1.val2) -> Seq Scan on public.xc_groupby_tab1 Output: (2 * val2), val @@ -409,13 +409,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize HashAggregate + Output: avg(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: avg(a), b - -> HashAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + -> Partial HashAggregate + Output: b, PARTIAL avg(a) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -433,13 +433,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.sum((sum(a))), b + Finalize HashAggregate + Output: sum(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: sum(a), b - -> HashAggregate - Output: sum(a), b + Output: b, PARTIAL sum(a) + -> Partial HashAggregate + Output: b, PARTIAL sum(a) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -457,13 +457,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.count(*), b + Finalize HashAggregate + Output: count(*), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: count(*), b - -> HashAggregate - Output: count(*), b + Output: b, PARTIAL count(*) + -> Partial HashAggregate + Output: b, PARTIAL count(*) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -510,20 +510,21 @@ 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; QUERY PLAN ---------------------------------------------------------------------- - Sort + Finalize GroupAggregate Output: xc_groupby_def.b - Sort Key: xc_groupby_def.b - -> HashAggregate + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all Output: xc_groupby_def.b - Group Key: xc_groupby_def.b - -> Remote Subquery Scan on all + Sort Key: xc_groupby_def.b + -> Sort Output: xc_groupby_def.b - -> HashAggregate + Sort Key: xc_groupby_def.b + -> Partial 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) +(14 rows) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; b | count @@ -535,22 +536,23 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; (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) + QUERY PLAN +------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: xc_groupby_def.b, count(xc_groupby_def.b) + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: xc_groupby_def.b, PARTIAL count(xc_groupby_def.b) + Sort Key: xc_groupby_def.b + -> Sort + Output: xc_groupby_def.b, (PARTIAL count(xc_groupby_def.b)) + Sort Key: xc_groupby_def.b + -> Partial HashAggregate + Output: xc_groupby_def.b, PARTIAL 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) +(14 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -608,13 +610,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: sum((sum(b))), b + Finalize HashAggregate + Output: sum(b), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(b), b - -> HashAggregate - Output: sum(b), b + Output: b, PARTIAL sum(b) + -> Partial HashAggregate + Output: b, PARTIAL sum(b) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -630,13 +632,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.sum((sum(c))), b + Finalize HashAggregate + Output: sum(c), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(c), b - -> HashAggregate - Output: sum(c), b + Output: b, PARTIAL sum(c) + -> Partial HashAggregate + Output: b, PARTIAL sum(c) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -652,13 +654,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize HashAggregate + Output: avg(a), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: avg(a), b - -> HashAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + -> Partial HashAggregate + Output: b, PARTIAL avg(a) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -674,13 +676,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(b))), c + Finalize HashAggregate + Output: avg(b), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(b), c - -> HashAggregate - Output: avg(b), c + Output: c, PARTIAL avg(b) + -> Partial HashAggregate + Output: c, PARTIAL avg(b) Group Key: xc_groupby_g.c -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -696,13 +698,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(c))), c + Finalize HashAggregate + Output: avg(c), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(c), c - -> HashAggregate - Output: avg(c), c + Output: c, PARTIAL avg(c) + -> Partial HashAggregate + Output: c, PARTIAL avg(c) Group Key: xc_groupby_g.c -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -1389,22 +1391,23 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro (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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 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; @@ -1462,8 +1465,8 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va (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 --------------------------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------- GroupAggregate Output: sum(q1.y), q1.x Group Key: q1.x @@ -1472,20 +1475,21 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( 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 + -> Finalize GroupAggregate + Output: 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 + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) 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) +(22 rows) -- group by without aggregate select val2 from xc_groupby_tab1 group by val2; @@ -1650,22 +1654,23 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; (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 + QUERY PLAN +---------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: (((count(*) + sum(val)))::numeric + 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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 rows) -- group by with expressions in group by clause select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; @@ -1677,22 +1682,23 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; (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)) + QUERY PLAN +------------------------------------------------------------------------ + Finalize GroupAggregate + Output: sum(val), 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)) + Output: (2 * val2), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: (2 * xc_groupby_tab1.val2) + -> Partial GroupAggregate + Output: ((2 * val2)), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 rows) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -1803,20 +1809,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize GroupAggregate + Output: avg(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: avg(a), b - -> GroupAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL avg(a) 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) +(14 rows) select sum(a) from xc_groupby_def group by b; sum @@ -1830,20 +1837,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.sum((sum(a))), b + Finalize GroupAggregate + Output: sum(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: sum(a), b - -> GroupAggregate - Output: sum(a), b + Output: b, PARTIAL sum(a) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(a) 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) +(14 rows) select count(*) from xc_groupby_def group by b; count @@ -1857,20 +1865,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.count(*), b + Finalize GroupAggregate + Output: count(*), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: count(*), b - -> GroupAggregate - Output: count(*), b + Output: b, PARTIAL count(*) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL count(*) 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) +(14 rows) select count(*) from xc_groupby_def where a is not null group by a; count @@ -1940,20 +1949,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: b, count((count(b))) + Finalize GroupAggregate + Output: b, count(b) Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: b, count(b) - -> GroupAggregate - Output: b, count(b) + Output: b, PARTIAL count(b) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL 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) +(14 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -2017,20 +2027,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: sum((sum(b))), b + Finalize GroupAggregate + Output: sum(b), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(b), b - -> GroupAggregate - Output: sum(b), b + Output: b, PARTIAL sum(b) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(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) +(14 rows) select sum(c) from xc_groupby_g group by b; sum @@ -2042,20 +2053,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.sum((sum(c))), b + Finalize GroupAggregate + Output: sum(c), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(c), b - -> GroupAggregate - Output: sum(c), b + Output: b, PARTIAL sum(c) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(c) 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) +(14 rows) select avg(a) from xc_groupby_g group by b; avg @@ -2067,20 +2079,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize GroupAggregate + Output: avg(a), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: avg(a), b - -> GroupAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL avg(a) 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) +(14 rows) select avg(b) from xc_groupby_g group by c; avg @@ -2092,20 +2105,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(b))), c + Finalize GroupAggregate + Output: avg(b), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(b), c - -> GroupAggregate - Output: avg(b), c + Output: c, PARTIAL avg(b) + Sort Key: xc_groupby_g.c + -> Partial GroupAggregate + Output: c, PARTIAL avg(b) 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) +(14 rows) select avg(c) from xc_groupby_g group by c; avg @@ -2117,20 +2131,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(c))), c + Finalize GroupAggregate + Output: avg(c), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(c), c - -> GroupAggregate - Output: avg(c), c + Output: c, PARTIAL avg(c) + Sort Key: xc_groupby_g.c + -> Partial GroupAggregate + Output: c, PARTIAL avg(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) +(14 rows) drop table xc_groupby_def; drop table xc_groupby_g; @@ -2870,15 +2885,15 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro (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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: val, val2 @@ -2940,18 +2955,18 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va (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 --------------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------- HashAggregate - Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2)) + Output: 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 + -> Finalize HashAggregate + Output: 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 + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) + -> Partial HashAggregate + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: xc_groupby_tab1.val, xc_groupby_tab1.val2 @@ -2969,12 +2984,12 @@ 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; QUERY PLAN ------------------------------------------------------ - HashAggregate + Finalize HashAggregate Output: val2 Group Key: xc_groupby_tab1.val2 -> Remote Subquery Scan on all Output: val2 - -> HashAggregate + -> Partial HashAggregate Output: val2 Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 @@ -2995,12 +3010,12 @@ 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; QUERY PLAN ----------------------------------------------------------------------- - HashAggregate + Finalize HashAggregate Output: ((val + val2)) Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) -> Remote Subquery Scan on all Output: (val + val2) - -> HashAggregate + -> Partial HashAggregate Output: ((val + val2)) Group Key: (xc_groupby_tab1.val + xc_groupby_tab1.val2) -> Seq Scan on public.xc_groupby_tab1 @@ -3113,15 +3128,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; (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 + QUERY PLAN +---------------------------------------------------------------------------------- + Finalize HashAggregate + Output: (((count(*) + sum(val)))::numeric + 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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_groupby_tab1.val2 -> Seq Scan on public.xc_groupby_tab1 Output: val, val2 @@ -3137,15 +3152,15 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; (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)) + QUERY PLAN +------------------------------------------------------------------------ + Finalize HashAggregate + Output: sum(val), 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)) + Output: (2 * val2), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: ((2 * val2)), PARTIAL sum(val), PARTIAL avg(val) Group Key: (2 * xc_groupby_tab1.val2) -> Seq Scan on public.xc_groupby_tab1 Output: (2 * val2), val @@ -3257,13 +3272,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize HashAggregate + Output: avg(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: avg(a), b - -> HashAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + -> Partial HashAggregate + Output: b, PARTIAL avg(a) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -3281,13 +3296,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.sum((sum(a))), b + Finalize HashAggregate + Output: sum(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: sum(a), b - -> HashAggregate - Output: sum(a), b + Output: b, PARTIAL sum(a) + -> Partial HashAggregate + Output: b, PARTIAL sum(a) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -3305,13 +3320,13 @@ 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; QUERY PLAN ----------------------------------------------------- - HashAggregate - Output: pg_catalog.count(*), b + Finalize HashAggregate + Output: count(*), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: count(*), b - -> HashAggregate - Output: count(*), b + Output: b, PARTIAL count(*) + -> Partial HashAggregate + Output: b, PARTIAL count(*) Group Key: xc_groupby_def.b -> Seq Scan on public.xc_groupby_def Output: a, b @@ -3358,20 +3373,21 @@ 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; QUERY PLAN ---------------------------------------------------------------------- - Sort + Finalize GroupAggregate Output: xc_groupby_def.b - Sort Key: xc_groupby_def.b - -> HashAggregate + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all Output: xc_groupby_def.b - Group Key: xc_groupby_def.b - -> Remote Subquery Scan on all + Sort Key: xc_groupby_def.b + -> Sort Output: xc_groupby_def.b - -> HashAggregate + Sort Key: xc_groupby_def.b + -> Partial 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) +(14 rows) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; b | count @@ -3383,22 +3399,23 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; (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) + QUERY PLAN +------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: xc_groupby_def.b, count(xc_groupby_def.b) + Group Key: xc_groupby_def.b + -> Remote Subquery Scan on all + Output: xc_groupby_def.b, PARTIAL count(xc_groupby_def.b) + Sort Key: xc_groupby_def.b + -> Sort + Output: xc_groupby_def.b, (PARTIAL count(xc_groupby_def.b)) + Sort Key: xc_groupby_def.b + -> Partial HashAggregate + Output: xc_groupby_def.b, PARTIAL 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) +(14 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -3456,13 +3473,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: sum((sum(b))), b + Finalize HashAggregate + Output: sum(b), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(b), b - -> HashAggregate - Output: sum(b), b + Output: b, PARTIAL sum(b) + -> Partial HashAggregate + Output: b, PARTIAL sum(b) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -3478,13 +3495,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.sum((sum(c))), b + Finalize HashAggregate + Output: sum(c), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(c), b - -> HashAggregate - Output: sum(c), b + Output: b, PARTIAL sum(c) + -> Partial HashAggregate + Output: b, PARTIAL sum(c) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -3500,13 +3517,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize HashAggregate + Output: avg(a), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: avg(a), b - -> HashAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + -> Partial HashAggregate + Output: b, PARTIAL avg(a) Group Key: xc_groupby_g.b -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -3522,13 +3539,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(b))), c + Finalize HashAggregate + Output: avg(b), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(b), c - -> HashAggregate - Output: avg(b), c + Output: c, PARTIAL avg(b) + -> Partial HashAggregate + Output: c, PARTIAL avg(b) Group Key: xc_groupby_g.c -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -3544,13 +3561,13 @@ 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; QUERY PLAN --------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(c))), c + Finalize HashAggregate + Output: avg(c), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(c), c - -> HashAggregate - Output: avg(c), c + Output: c, PARTIAL avg(c) + -> Partial HashAggregate + Output: c, PARTIAL avg(c) Group Key: xc_groupby_g.c -> Seq Scan on public.xc_groupby_g Output: a, b, c @@ -4255,22 +4272,23 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro (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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 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; @@ -4328,8 +4346,8 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va (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 --------------------------------------------------------------------------------------------------------------------------- + QUERY PLAN +-------------------------------------------------------------------------------------------------------- GroupAggregate Output: sum(q1.y), q1.x Group Key: q1.x @@ -4338,20 +4356,21 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( 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 + -> Finalize GroupAggregate + Output: 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 + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: xc_groupby_tab1.val2, PARTIAL sum(xc_groupby_tab1.val) 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) +(22 rows) -- group by without aggregate select val2 from xc_groupby_tab1 group by val2; @@ -4516,22 +4535,23 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; (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 + QUERY PLAN +---------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: (((count(*) + sum(val)))::numeric + 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 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_groupby_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 rows) -- group by with expressions in group by clause select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; @@ -4543,22 +4563,23 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; (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)) + QUERY PLAN +------------------------------------------------------------------------ + Finalize GroupAggregate + Output: sum(val), 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)) + Output: (2 * val2), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: (2 * xc_groupby_tab1.val2) + -> Partial GroupAggregate + Output: ((2 * val2)), PARTIAL sum(val), PARTIAL avg(val) 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) +(14 rows) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -4669,20 +4690,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize GroupAggregate + Output: avg(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: avg(a), b - -> GroupAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL avg(a) 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) +(14 rows) select sum(a) from xc_groupby_def group by b; sum @@ -4696,20 +4718,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.sum((sum(a))), b + Finalize GroupAggregate + Output: sum(a), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: sum(a), b - -> GroupAggregate - Output: sum(a), b + Output: b, PARTIAL sum(a) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(a) 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) +(14 rows) select count(*) from xc_groupby_def group by b; count @@ -4723,20 +4746,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: pg_catalog.count(*), b + Finalize GroupAggregate + Output: count(*), b Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: count(*), b - -> GroupAggregate - Output: count(*), b + Output: b, PARTIAL count(*) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL count(*) 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) +(14 rows) select count(*) from xc_groupby_def where a is not null group by a; count @@ -4806,20 +4830,21 @@ 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; QUERY PLAN ----------------------------------------------------------- - GroupAggregate - Output: b, count((count(b))) + Finalize GroupAggregate + Output: b, count(b) Group Key: xc_groupby_def.b -> Remote Subquery Scan on all - Output: b, count(b) - -> GroupAggregate - Output: b, count(b) + Output: b, PARTIAL count(b) + Sort Key: xc_groupby_def.b + -> Partial GroupAggregate + Output: b, PARTIAL 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) +(14 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -4883,20 +4908,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: sum((sum(b))), b + Finalize GroupAggregate + Output: sum(b), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(b), b - -> GroupAggregate - Output: sum(b), b + Output: b, PARTIAL sum(b) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(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) +(14 rows) select sum(c) from xc_groupby_g group by b; sum @@ -4908,20 +4934,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.sum((sum(c))), b + Finalize GroupAggregate + Output: sum(c), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: sum(c), b - -> GroupAggregate - Output: sum(c), b + Output: b, PARTIAL sum(c) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL sum(c) 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) +(14 rows) select avg(a) from xc_groupby_g group by b; avg @@ -4933,20 +4960,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(a))), b + Finalize GroupAggregate + Output: avg(a), b Group Key: xc_groupby_g.b -> Remote Subquery Scan on all - Output: avg(a), b - -> GroupAggregate - Output: avg(a), b + Output: b, PARTIAL avg(a) + Sort Key: xc_groupby_g.b + -> Partial GroupAggregate + Output: b, PARTIAL avg(a) 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) +(14 rows) select avg(b) from xc_groupby_g group by c; avg @@ -4958,20 +4986,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(b))), c + Finalize GroupAggregate + Output: avg(b), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(b), c - -> GroupAggregate - Output: avg(b), c + Output: c, PARTIAL avg(b) + Sort Key: xc_groupby_g.c + -> Partial GroupAggregate + Output: c, PARTIAL avg(b) 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) +(14 rows) select avg(c) from xc_groupby_g group by c; avg @@ -4983,20 +5012,21 @@ 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; QUERY PLAN --------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(c))), c + Finalize GroupAggregate + Output: avg(c), c Group Key: xc_groupby_g.c -> Remote Subquery Scan on all - Output: avg(c), c - -> GroupAggregate - Output: avg(c), c + Output: c, PARTIAL avg(c) + Sort Key: xc_groupby_g.c + -> Partial GroupAggregate + Output: c, PARTIAL avg(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) +(14 rows) drop table xc_groupby_def; drop table xc_groupby_g; diff --git a/src/test/regress/expected/xc_having.out b/src/test/regress/expected/xc_having.out index 7c726a39c1..47c845ea59 100644 --- a/src/test/regress/expected/xc_having.out +++ b/src/test/regress/expected/xc_having.out @@ -21,15 +21,15 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> HashAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -44,16 +44,16 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) + Filter: (avg(xc_having_tab1.val) > 3.75) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> HashAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -67,16 +67,16 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (2 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2)) + Filter: ((avg(xc_having_tab1.val) > 3.75) OR (xc_having_tab1.val2 > 2)) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2, val2 - -> HashAggregate - Output: count(*), sum(val), avg(val), val2, val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -88,16 +88,16 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (0 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) + Filter: (avg(xc_having_tab1.val) > 3.75) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> HashAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -151,16 +151,16 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8; (1 row) explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; - QUERY PLAN ------------------------------------------------------------ - HashAggregate + QUERY PLAN +----------------------------------------------------- + Finalize HashAggregate Output: val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8) + Filter: (sum(xc_having_tab1.val) > 8) -> Remote Subquery Scan on all - Output: val2, sum(val) - -> HashAggregate - Output: val2, sum(val) + Output: val2, PARTIAL sum(val) + -> Partial HashAggregate + Output: val2, PARTIAL sum(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -175,23 +175,24 @@ select * from (select val + val2 sum from xc_having_tab1 group by val + val2 hav (3 rows) explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; - QUERY PLAN ---------------------------------------------------------------------------------------------------- - Sort + QUERY PLAN +----------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) - -> HashAggregate - Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Group Key: (xc_having_tab1.val + xc_having_tab1.val2) - Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) - -> Remote Subquery Scan on all - Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val) - -> HashAggregate - Output: ((xc_having_tab1.val + xc_having_tab1.val2)), sum(xc_having_tab1.val) + Group Key: (xc_having_tab1.val + xc_having_tab1.val2) + Filter: (sum(xc_having_tab1.val) > 5) + -> Remote Subquery Scan on all + Output: (xc_having_tab1.val + xc_having_tab1.val2), PARTIAL sum(xc_having_tab1.val) + Sort Key: (xc_having_tab1.val + xc_having_tab1.val2) + -> Sort + Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (PARTIAL sum(xc_having_tab1.val)) + Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) + -> Partial HashAggregate + Output: ((xc_having_tab1.val + xc_having_tab1.val2)), PARTIAL sum(xc_having_tab1.val) Group Key: (xc_having_tab1.val + xc_having_tab1.val2) -> Seq Scan on public.xc_having_tab1 Output: (xc_having_tab1.val + xc_having_tab1.val2), xc_having_tab1.val -(14 rows) +(15 rows) -- group by with aggregates in expression select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -201,16 +202,16 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------- - HashAggregate - Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2 + QUERY PLAN +---------------------------------------------------------------------------------------------------- + Finalize HashAggregate + Output: (((count(*) + sum(val)))::numeric + avg(val)), val2 Group Key: xc_having_tab1.val2 - Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2) + Filter: (min(xc_having_tab1.val) < xc_having_tab1.val2) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2, min(val), val2 - -> HashAggregate - Output: count(*), sum(val), avg(val), val2, min(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val), PARTIAL min(val) + -> Partial HashAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val), PARTIAL min(val) Group Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val, val2 @@ -416,15 +417,16 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> GroupAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val @@ -432,7 +434,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -> Seq Scan on public.xc_having_tab1 Output: val2, val Filter: ((xc_having_tab1.val2 + 1) > 3) -(14 rows) +(15 rows) -- having clause containing aggregate select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; @@ -442,23 +444,24 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) + Filter: (avg(xc_having_tab1.val) > 3.75) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> GroupAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val Sort Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val2, val -(14 rows) +(15 rows) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2; count | sum | avg | ?column? | val2 @@ -468,23 +471,24 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (2 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2)) + Filter: ((avg(xc_having_tab1.val) > 3.75) OR (xc_having_tab1.val2 > 2)) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2, val2 - -> GroupAggregate - Output: count(*), sum(val), avg(val), val2, val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val Sort Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val2, val -(14 rows) +(15 rows) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2; count | sum | avg | ?column? | val2 @@ -492,16 +496,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (0 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2; - 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 + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: count(*), sum(val), avg(val), ((sum(val))::double precision / (count(*))::double precision), val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) + Filter: (avg(xc_having_tab1.val) > 3.75) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2 - -> GroupAggregate - Output: count(*), sum(val), avg(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val @@ -509,7 +514,7 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -> Seq Scan on public.xc_having_tab1 Output: val2, val Filter: (xc_having_tab1.val2 > 2) -(15 rows) +(16 rows) -- joins and group by and having select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab1.val*xc_having_tab2.val), sum(xc_having_tab1.val*xc_having_tab2.val)::float8/count(*), xc_having_tab1.val2, xc_having_tab2.val2 from xc_having_tab1 full outer join xc_having_tab2 on xc_having_tab1.val2 = xc_having_tab2.val2 group by xc_having_tab1.val2, xc_having_tab2.val2 having xc_having_tab1.val2 + xc_having_tab2.val2 > 2; @@ -560,21 +565,22 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8; explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; QUERY PLAN ----------------------------------------------------------- - GroupAggregate + Finalize GroupAggregate Output: val2 Group Key: xc_having_tab1.val2 - Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8) + Filter: (sum(xc_having_tab1.val) > 8) -> Remote Subquery Scan on all - Output: val2, sum(val) - -> GroupAggregate - Output: val2, sum(val) + Output: val2, PARTIAL sum(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL sum(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val Sort Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val2, val -(14 rows) +(15 rows) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; ?column? @@ -587,21 +593,22 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; QUERY PLAN ---------------------------------------------------------------------------- - GroupAggregate + Finalize GroupAggregate Output: ((val + val2)) Group Key: (xc_having_tab1.val + xc_having_tab1.val2) - Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) + Filter: (sum(xc_having_tab1.val) > 5) -> Remote Subquery Scan on all - Output: (val + val2), sum(val) - -> GroupAggregate - Output: ((val + val2)), sum(val) + Output: (val + val2), PARTIAL sum(val) + Sort Key: (xc_having_tab1.val + xc_having_tab1.val2) + -> Partial GroupAggregate + Output: ((val + val2)), PARTIAL sum(val) Group Key: ((xc_having_tab1.val + xc_having_tab1.val2)) -> Sort Output: ((val + val2)), val Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) -> Seq Scan on public.xc_having_tab1 Output: (val + val2), val -(14 rows) +(15 rows) -- group by with aggregates in expression select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -611,23 +618,24 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------- - GroupAggregate - Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(val)))))::numeric + pg_catalog.avg((avg(val)))), val2 + QUERY PLAN +---------------------------------------------------------------------------------------------------- + Finalize GroupAggregate + Output: (((count(*) + sum(val)))::numeric + avg(val)), val2 Group Key: xc_having_tab1.val2 - Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2) + Filter: (min(xc_having_tab1.val) < xc_having_tab1.val2) -> Remote Subquery Scan on all - Output: count(*), sum(val), avg(val), val2, min(val), val2 - -> GroupAggregate - Output: count(*), sum(val), avg(val), val2, min(val), val2 + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val), PARTIAL min(val) + Sort Key: xc_having_tab1.val2 + -> Partial GroupAggregate + Output: val2, PARTIAL count(*), PARTIAL sum(val), PARTIAL avg(val), PARTIAL min(val) Group Key: xc_having_tab1.val2 -> Sort Output: val2, val Sort Key: xc_having_tab1.val2 -> Seq Scan on public.xc_having_tab1 Output: val2, val -(14 rows) +(15 rows) drop table xc_having_tab1; drop table xc_having_tab2;