summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--doc-xc/src/sgml/ref/explain.sgmlin24
-rw-r--r--src/backend/commands/explain.c87
-rw-r--r--src/backend/optimizer/plan/createplan.c12
-rw-r--r--src/backend/pgxc/pool/pgxcnode.c2
-rw-r--r--src/include/commands/explain.h4
-rw-r--r--src/test/regress/expected/xc_distkey.out72
-rw-r--r--src/test/regress/expected/xc_groupby.out1570
-rw-r--r--src/test/regress/expected/xc_having.out432
-rw-r--r--src/test/regress/sql/xc_distkey.sql18
-rw-r--r--src/test/regress/sql/xc_groupby.sql204
-rw-r--r--src/test/regress/sql/xc_having.sql64
11 files changed, 1332 insertions, 1157 deletions
diff --git a/doc-xc/src/sgml/ref/explain.sgmlin b/doc-xc/src/sgml/ref/explain.sgmlin
index 4c5e0b617d..24eae5c167 100644
--- a/doc-xc/src/sgml/ref/explain.sgmlin
+++ b/doc-xc/src/sgml/ref/explain.sgmlin
@@ -40,6 +40,8 @@ EXPLAIN [ ANALYZE ] [ VERBOSE ] <replaceable class="parameter">statement</replac
VERBOSE [ <replaceable class="parameter">boolean</replaceable> ]
COSTS [ <replaceable class="parameter">boolean</replaceable> ]
BUFFERS [ <replaceable class="parameter">boolean</replaceable> ]
+ NODES [ <replaceable class="parameter">boolean</replaceable> ]
+ NUM_NODES [ <replaceable class="parameter">boolean</replaceable> ]
FORMAT { TEXT | XML | JSON | YAML }
</synopsis>
</refsynopsisdiv>
@@ -179,6 +181,28 @@ ROLLBACK;
</varlistentry>
<varlistentry>
+ <term><literal>NODES</literal></term>
+ <listitem>
+ <para>
+ Include information on the datanodes involved in the execution of Data
+ Scan Node. This parameter defaults to <literal>TRUE</literal>. This option
+ is available in <productname>Postgres-XC</productname>.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term><literal>NUM_NODES</literal></term>
+ <listitem>
+ <para>
+ Include information on the number of nodes involved in the execution of
+ Data Node Scan node. This parameter defaults to <literal>FALSE</literal>.
+ This option is available in <productname>Postgres-XC</productname>.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
<term><literal>FORMAT</literal></term>
<listitem>
<para>
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 887e0c61b7..31205fccdb 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -16,6 +16,7 @@
#include "access/xact.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_type.h"
+#include "catalog/pgxc_node.h"
#include "commands/defrem.h"
#include "commands/explain.h"
#include "commands/prepare.h"
@@ -135,6 +136,12 @@ ExplainQuery(ExplainStmt *stmt, const char *queryString,
es.costs = defGetBoolean(opt);
else if (strcmp(opt->defname, "buffers") == 0)
es.buffers = defGetBoolean(opt);
+#ifdef PGXC
+ else if (strcmp(opt->defname, "nodes") == 0)
+ es.nodes = defGetBoolean(opt);
+ else if (strcmp(opt->defname, "num_nodes") == 0)
+ es.num_nodes = defGetBoolean(opt);
+#endif /* PGXC */
else if (strcmp(opt->defname, "format") == 0)
{
char *p = defGetString(opt);
@@ -231,6 +238,9 @@ ExplainInitState(ExplainState *es)
/* Set default options. */
memset(es, 0, sizeof(ExplainState));
es->costs = true;
+#ifdef PGXC
+ es->nodes = true;
+#endif /* PGXC */
/* Prepare output buffer. */
es->str = makeStringInfo();
}
@@ -848,29 +858,23 @@ ExplainNode(PlanState *planstate, List *ancestors,
break;
#ifdef PGXC
case T_RemoteQuery:
+ if (es->num_nodes)
{
- RemoteQuery *remote_query = (RemoteQuery *) plan;
- int pnc, nc;
-
- pnc = 0;
- nc = 0;
- if (remote_query->exec_nodes != NULL)
+ ExecNodes *en = ((RemoteQuery *)plan)->exec_nodes;
+ int primary_node_count = en ? list_length(en->primarynodelist) : 0;
+ int node_count = en ? list_length(en->nodeList) : 0;
+ if (es->format == EXPLAIN_FORMAT_TEXT)
+ appendStringInfo(es->str, " (primary node count=%d, node count=%d)",
+ primary_node_count, node_count);
+ else
{
- if (remote_query->exec_nodes->primarynodelist != NULL)
- {
- pnc = list_length(remote_query->exec_nodes->primarynodelist);
- appendStringInfo(es->str, " (Primary Node Count [%d])", pnc);
- }
- if (remote_query->exec_nodes->nodeList)
- {
- nc = list_length(remote_query->exec_nodes->nodeList);
- appendStringInfo(es->str, " (Node Count [%d])", nc);
- }
+ ExplainPropertyInteger("Primary node count", primary_node_count, es);
+ ExplainPropertyInteger("Node count", node_count, es);
}
-#endif
- ExplainScanTarget((Scan *) plan, es);
}
+ ExplainScanTarget((Scan *) plan, es);
break;
+#endif
case T_BitmapIndexScan:
{
BitmapIndexScan *bitmapindexscan = (BitmapIndexScan *) plan;
@@ -1043,6 +1047,50 @@ ExplainNode(PlanState *planstate, List *ancestors,
show_scan_qual(((BitmapIndexScan *) plan)->indexqualorig,
"Index Cond", planstate, ancestors, es);
break;
+#ifdef PGXC
+ case T_RemoteQuery:
+ {
+ RemoteQuery *remote_query = (RemoteQuery *) plan;
+ /* add names of the nodes if they exist */
+ if (remote_query->exec_nodes && es->nodes)
+ {
+ StringInfo node_names = makeStringInfo();
+ ListCell *lcell;
+ char *sep;
+ int node_no;
+ if (remote_query->exec_nodes->primarynodelist)
+ {
+ sep = "";
+ foreach(lcell, remote_query->exec_nodes->primarynodelist)
+ {
+ node_no = lfirst_int(lcell);
+ appendStringInfo(node_names, "%s%s", sep,
+ get_pgxc_nodename(PGXCNodeGetNodeOid(node_no, PGXC_NODE_DATANODE)));
+ sep = ", ";
+ }
+ ExplainPropertyText("Primary node/s", node_names->data, es);
+ }
+ if (remote_query->exec_nodes->nodeList)
+ {
+ resetStringInfo(node_names);
+ sep = "";
+ foreach(lcell, remote_query->exec_nodes->nodeList)
+ {
+ node_no = lfirst_int(lcell);
+ appendStringInfo(node_names, "%s%s", sep,
+ get_pgxc_nodename(PGXCNodeGetNodeOid(node_no, PGXC_NODE_DATANODE)));
+ sep = ", ";
+ }
+ ExplainPropertyText("Node/s", node_names->data, es);
+ }
+ }
+ }
+ if (es->verbose)
+ ExplainPropertyText("Remote query",
+ ((RemoteQuery *)plan)->sql_statement, es);
+ show_scan_qual(plan->qual, "Coordinator quals", planstate, ancestors, es);
+ break;
+#endif
case T_BitmapHeapScan:
show_scan_qual(((BitmapHeapScan *) plan)->bitmapqualorig,
"Recheck Cond", planstate, ancestors, es);
@@ -1051,9 +1099,6 @@ ExplainNode(PlanState *planstate, List *ancestors,
case T_ValuesScan:
case T_CteScan:
case T_WorkTableScan:
-#ifdef PGXC
- case T_RemoteQuery:
-#endif
case T_SubqueryScan:
show_scan_qual(plan->qual, "Filter", planstate, ancestors, es);
break;
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
index 57420d589a..382e56888c 100644
--- a/src/backend/optimizer/plan/createplan.c
+++ b/src/backend/optimizer/plan/createplan.c
@@ -965,8 +965,8 @@ create_remotejoin_plan(PlannerInfo *root, JoinPath *best_path, Plan *parent, Pla
dummy_rte->rtekind = RTE_RELATION;
/* use a dummy relname... */
- dummy_rte->relname = "__FOREIGN_QUERY__";
- dummy_rte->eref = makeAlias("__FOREIGN_QUERY__", NIL);
+ dummy_rte->relname = "__REMOTE_JOIN_QUERY__";
+ dummy_rte->eref = makeAlias("__REMOTE_JOIN_QUERY__", NIL);
/* not sure if we need to set the below explicitly.. */
dummy_rte->inh = false;
dummy_rte->inFromCl = false;
@@ -1022,7 +1022,7 @@ create_remotejoin_plan(PlannerInfo *root, JoinPath *best_path, Plan *parent, Pla
/* set_plan_refs needs this later */
result->base_tlist = base_tlist;
- result->relname = "__FOREIGN_QUERY__";
+ result->relname = "__REMOTE_JOIN_QUERY__";
result->partitioned_replicated = join_info.partitioned_replicated;
/*
@@ -6090,8 +6090,8 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
dummy_rte->rtekind = RTE_RELATION;
/* Use a dummy relname... */
- dummy_rte->relname = "__FOREIGN_QUERY__";
- dummy_rte->eref = makeAlias("__FOREIGN_QUERY__", NIL);
+ dummy_rte->relname = "__REMOTE_GROUP_QUERY__";
+ dummy_rte->eref = makeAlias("__REMOTE_GROUP_QUERY__", NIL);
/* Rest will be zeroed out in makeNode() */
root->parse->rtable = lappend(root->parse->rtable, dummy_rte);
@@ -6108,7 +6108,7 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan)
remote_group->sql_statement = remote_sql_stmt->data;
/* set_plan_refs needs this later */
- remote_group->relname = "__FOREIGN_QUERY__";
+ remote_group->relname = "__REMOTE_GROUP_QUERY__";
remote_group->partitioned_replicated = remote_scan->partitioned_replicated;
remote_group->read_only = query->commandType == CMD_SELECT;
diff --git a/src/backend/pgxc/pool/pgxcnode.c b/src/backend/pgxc/pool/pgxcnode.c
index 423928028c..8df0817972 100644
--- a/src/backend/pgxc/pool/pgxcnode.c
+++ b/src/backend/pgxc/pool/pgxcnode.c
@@ -2275,7 +2275,7 @@ PGXCNodeGetNodeOid(int nodeid, char node_type)
return InvalidOid;
}
- return handles[nodeid - 1].nodeoid;
+ return handles[nodeid].nodeoid;
}
/*
diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h
index d7998c3178..84a73f9dec 100644
--- a/src/include/commands/explain.h
+++ b/src/include/commands/explain.h
@@ -31,6 +31,10 @@ typedef struct ExplainState
bool analyze; /* print actual times */
bool costs; /* print costs */
bool buffers; /* print buffer usage */
+#ifdef PGXC
+ bool nodes; /* print nodes in RemoteQuery node */
+ bool num_nodes; /* print number of nodes in RemoteQuery node */
+#endif /* PGXC */
ExplainFormat format; /* output format */
/* other states */
PlannedStmt *pstmt; /* top of plan */
diff --git a/src/test/regress/expected/xc_distkey.out b/src/test/regress/expected/xc_distkey.out
index 461f779e2b..6b6cd29628 100644
--- a/src/test/regress/expected/xc_distkey.out
+++ b/src/test/regress/expected/xc_distkey.out
@@ -38,16 +38,16 @@ select * from nu_tab where 789.412 = a;
789.41200
(1 row)
-explain select * from nu_tab where a = 123.456;
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where a = 123.456;
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
-explain select * from nu_tab where 789.412 = a;
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where 789.412 = a;
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
create table tx_tab(a text) distribute by modulo(a);
@@ -84,16 +84,16 @@ select * from tx_tab where 'Did the quick brown fox jump over the lazy dog?' = a
Did the quick brown fox jump over the lazy dog?
(1 row)
-explain select * from tx_tab where a = 'hello world';
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'hello world';
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
-explain select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
create table vc_tab(a varchar(255)) distribute by modulo(a);
@@ -127,23 +127,23 @@ select * from vc_tab where 'A quick brown fox' = a;
A quick brown fox
(1 row)
-explain select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
-explain select * from vc_tab where a = 'A quick brown fox';
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'A quick brown fox';
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
-- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
-explain select * from vc_tab where 'A quick brown fox' = a;
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where 'A quick brown fox' = a;
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
create table f8_tab(a float8) distribute by modulo(a);
@@ -328,16 +328,16 @@ select * from i4_tab where 2147483647 = a;
2147483647
(1 row)
-explain select * from i4_tab where 65530 = a;
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where 65530 = a;
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
-explain select * from i4_tab where a = 2147483647;
- QUERY PLAN
--------------------------------------------------------------------
- Data Node Scan (Node Count [1]) (cost=0.00..0.00 rows=0 width=0)
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where a = 2147483647;
+ QUERY PLAN
+-----------------------------------------------------
+ Data Node Scan (primary node count=0, node count=1)
(1 row)
create table bo_tab(a bool) distribute by modulo(a);
diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out
index 36a2697cd1..13ce09e31e 100644
--- a/src/test/regress/expected/xc_groupby.out
+++ b/src/test/regress/expected/xc_groupby.out
@@ -18,16 +18,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.03..1.05 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4
+(7 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;
@@ -39,25 +40,23 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=2.08..2.10 rows=1 width=16)
+ HashAggregate
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
- -> Hash Full Join (cost=1.03..2.06 rows=1 width=16)
+ -> Hash Full Join
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2, xc_groupby_tab2.val, xc_groupby_tab2.val2
Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab1
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) on xc_groupby_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Hash (cost=1.01..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+ -> Hash
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab2
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [2]) on xc_groupby_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(15 rows)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(13 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;
@@ -67,18 +66,19 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
17
(2 rows)
-explain verbose 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 (cost=1.05..1.06 rows=1 width=12)
+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))
- -> HashAggregate (cost=1.02..1.03 rows=1 width=8)
+ -> HashAggregate
Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(8 rows)
+ Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3
+(9 rows)
-- group by without aggregate
select val2 from xc_groupby_tab1 group by val2;
@@ -89,16 +89,17 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain verbose select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1
+(7 rows)
select val + val2 from xc_groupby_tab1 group by val + val2;
?column?
@@ -111,16 +112,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
2
(6 rows)
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1
+(7 rows)
select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
?column? | val | val2
@@ -135,16 +137,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
9 | 6 | 3
(8 rows)
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3
+(7 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
@@ -157,16 +160,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
7 | 3 | 4
(6 rows)
-explain verbose 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
----------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=0.00..0.01 rows=1 width=0)
+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
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1 FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 2, 3
+(7 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?
@@ -177,16 +181,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
5
(4 rows)
-explain verbose 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 (cost=0.00..0.01 rows=1 width=0)
+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))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1) FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 1
+(7 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -197,16 +202,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
17.6666666666666667 | 3
(3 rows)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+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(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4
+(7 rows)
-- group by with expressions in group by clause
select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -217,16 +223,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
8 | 4.0000000000000000 | 4
(3 rows)
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+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(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3
+(7 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -261,21 +268,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
| 0
(11 rows)
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ GroupAggregate
Output: a, count(a)
- -> Sort (cost=1.02..1.03 rows=1 width=4)
+ -> Sort
Output: a
Sort Key: xc_groupby_def.a
- -> Result (cost=0.00..1.01 rows=1 width=4)
+ -> Result
Output: a
- -> Materialize (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on xc_groupby_def
Output: a, b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
- Output: a, b
-(11 rows)
+ Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -309,16 +315,17 @@ select avg(a) from xc_groupby_def group by a;
4.0000000000000000
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by b;
avg
@@ -329,16 +336,17 @@ select avg(a) from xc_groupby_def group by b;
6.2000000000000000
(4 rows)
-explain verbose select avg(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select sum(a) from xc_groupby_def group by b;
sum
@@ -349,16 +357,17 @@ select sum(a) from xc_groupby_def group by b;
31
(4 rows)
-explain verbose select sum(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select count(*) from xc_groupby_def group by b;
count
@@ -369,16 +378,17 @@ select count(*) from xc_groupby_def group by b;
5
(4 rows)
-explain verbose select count(*) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.count(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select count(*) from xc_groupby_def where a is not null group by a;
count
@@ -395,16 +405,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
1
(10 rows)
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.count(*), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT count(*), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2
+(7 rows)
select b from xc_groupby_def group by b;
b
@@ -415,16 +426,17 @@ select b from xc_groupby_def group by b;
Three
(4 rows)
-explain verbose select b from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1
+(7 rows)
select b,count(b) from xc_groupby_def group by b;
b | count
@@ -435,16 +447,17 @@ select b,count(b) from xc_groupby_def group by b;
Three | 5
(4 rows)
-explain verbose select b,count(b) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+ Remote query: SELECT group_1.b, count(group_1.b) FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1
+(7 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -452,16 +465,17 @@ select count(*) from xc_groupby_def where b is null group by b;
3
(1 row)
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+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(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2
+(7 rows)
create table xc_groupby_g(a int, b float, c numeric);
insert into xc_groupby_g values(1,2.1,3.2);
@@ -474,16 +488,17 @@ select sum(a) from xc_groupby_g group by a;
2
(2 rows)
-explain verbose select sum(a) from xc_groupby_g group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.a FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select sum(b) from xc_groupby_g group by b;
sum
@@ -492,16 +507,17 @@ select sum(b) from xc_groupby_g group by b;
4.2
(2 rows)
-explain verbose select sum(b) from xc_groupby_g group by b;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.b), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select sum(c) from xc_groupby_g group by b;
sum
@@ -510,16 +526,17 @@ select sum(c) from xc_groupby_g group by b;
6.4
(2 rows)
-explain verbose select sum(c) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=40)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.c), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(a) from xc_groupby_g group by b;
avg
@@ -528,16 +545,17 @@ select avg(a) from xc_groupby_g group by b;
1.00000000000000000000
(2 rows)
-explain verbose select avg(a) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=12)
+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(xc_groupby_g.a))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=12)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(b) from xc_groupby_g group by c;
avg
@@ -546,16 +564,17 @@ select avg(b) from xc_groupby_g group by c;
2.1
(2 rows)
-explain verbose select avg(b) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=40)
+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(xc_groupby_g.b))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.b), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(c) from xc_groupby_g group by c;
avg
@@ -564,16 +583,17 @@ select avg(c) from xc_groupby_g group by c;
3.2000000000000000
(2 rows)
-explain verbose select avg(c) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=32)
+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(xc_groupby_g.c))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=32)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.c), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -592,16 +612,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.03..1.05 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4
+(7 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;
@@ -613,25 +634,23 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=2.08..2.10 rows=1 width=16)
+ HashAggregate
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
- -> Hash Full Join (cost=1.03..2.06 rows=1 width=16)
+ -> Hash Full Join
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2, xc_groupby_tab2.val, xc_groupby_tab2.val2
Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab1
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) on xc_groupby_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Hash (cost=1.01..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+ -> Hash
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab2
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [1]) on xc_groupby_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(15 rows)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(13 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;
@@ -641,18 +660,19 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
17
(2 rows)
-explain verbose 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 (cost=1.05..1.06 rows=1 width=12)
+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))
- -> HashAggregate (cost=1.02..1.03 rows=1 width=8)
+ -> HashAggregate
Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(8 rows)
+ Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3
+(9 rows)
-- group by without aggregate
select val2 from xc_groupby_tab1 group by val2;
@@ -663,16 +683,17 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain verbose select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1
+(7 rows)
select val + val2 from xc_groupby_tab1 group by val + val2;
?column?
@@ -685,16 +706,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
2
(6 rows)
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1
+(7 rows)
select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
?column? | val | val2
@@ -709,16 +731,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
9 | 6 | 3
(8 rows)
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3
+(7 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
@@ -731,16 +754,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
7 | 3 | 4
(6 rows)
-explain verbose 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
----------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=0.00..0.01 rows=1 width=0)
+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
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1 FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 2, 3
+(7 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?
@@ -751,16 +775,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
5
(4 rows)
-explain verbose 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 (cost=0.00..0.01 rows=1 width=0)
+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))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1) FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 1
+(7 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -771,16 +796,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
17.6666666666666667 | 3
(3 rows)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+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(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4
+(7 rows)
-- group by with expressions in group by clause
select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -791,16 +817,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
8 | 4.0000000000000000 | 4
(3 rows)
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+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(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3
+(7 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -835,21 +862,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
| 0
(11 rows)
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ GroupAggregate
Output: a, count(a)
- -> Sort (cost=1.02..1.03 rows=1 width=4)
+ -> Sort
Output: a
Sort Key: xc_groupby_def.a
- -> Result (cost=0.00..1.01 rows=1 width=4)
+ -> Result
Output: a
- -> Materialize (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on xc_groupby_def
Output: a, b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
- Output: a, b
-(11 rows)
+ Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -867,16 +893,17 @@ select avg(a) from xc_groupby_def group by a;
4.0000000000000000
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -894,16 +921,17 @@ select avg(a) from xc_groupby_def group by a;
4.0000000000000000
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by b;
avg
@@ -914,16 +942,17 @@ select avg(a) from xc_groupby_def group by b;
6.2000000000000000
(4 rows)
-explain verbose select avg(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select sum(a) from xc_groupby_def group by b;
sum
@@ -934,16 +963,17 @@ select sum(a) from xc_groupby_def group by b;
31
(4 rows)
-explain verbose select sum(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select count(*) from xc_groupby_def group by b;
count
@@ -954,16 +984,17 @@ select count(*) from xc_groupby_def group by b;
5
(4 rows)
-explain verbose select count(*) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.count(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2
+(7 rows)
select count(*) from xc_groupby_def where a is not null group by a;
count
@@ -980,16 +1011,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
1
(10 rows)
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.count(*), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT count(*), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2
+(7 rows)
select b from xc_groupby_def group by b;
b
@@ -1000,16 +1032,17 @@ select b from xc_groupby_def group by b;
Three
(4 rows)
-explain verbose select b from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1
+(7 rows)
select b,count(b) from xc_groupby_def group by b;
b | count
@@ -1020,16 +1053,17 @@ select b,count(b) from xc_groupby_def group by b;
Three | 5
(4 rows)
-explain verbose select b,count(b) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+ Remote query: SELECT group_1.b, count(group_1.b) FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1
+(7 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -1037,16 +1071,17 @@ select count(*) from xc_groupby_def where b is null group by b;
3
(1 row)
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=68)
+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(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2
+(7 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);
@@ -1059,16 +1094,17 @@ select sum(a) from xc_groupby_g group by a;
2
(2 rows)
-explain verbose select sum(a) from xc_groupby_g group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.a FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select sum(b) from xc_groupby_g group by b;
sum
@@ -1077,16 +1113,17 @@ select sum(b) from xc_groupby_g group by b;
4.2
(2 rows)
-explain verbose select sum(b) from xc_groupby_g group by b;
- QUERY PLAN
-----------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.b), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select sum(c) from xc_groupby_g group by b;
sum
@@ -1095,16 +1132,17 @@ select sum(c) from xc_groupby_g group by b;
6.4
(2 rows)
-explain verbose select sum(c) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=40)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.c), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(a) from xc_groupby_g group by b;
avg
@@ -1113,16 +1151,17 @@ select avg(a) from xc_groupby_g group by b;
1.00000000000000000000
(2 rows)
-explain verbose select avg(a) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=12)
+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(xc_groupby_g.a))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=12)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(b) from xc_groupby_g group by c;
avg
@@ -1131,16 +1170,17 @@ select avg(b) from xc_groupby_g group by c;
2.1
(2 rows)
-explain verbose select avg(b) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=40)
+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(xc_groupby_g.b))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.b), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
select avg(c) from xc_groupby_g group by c;
avg
@@ -1149,16 +1189,17 @@ select avg(c) from xc_groupby_g group by c;
3.2000000000000000
(2 rows)
-explain verbose select avg(c) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=32)
+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(xc_groupby_g.c))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=32)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.c), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2
+(7 rows)
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -1178,16 +1219,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4
+(7 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;
@@ -1199,28 +1241,26 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=2.07..2.12 rows=1 width=16)
+ 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
- -> Sort (cost=2.07..2.07 rows=1 width=16)
+ -> Sort
Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
- -> Hash Full Join (cost=1.03..2.06 rows=1 width=16)
+ -> Hash Full Join
Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab1
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) on xc_groupby_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Hash (cost=1.01..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+ -> Hash
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab2
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [2]) on xc_groupby_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(18 rows)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(16 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;
@@ -1230,23 +1270,24 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
17
(2 rows)
-explain verbose 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 (cost=1.07..1.09 rows=1 width=12)
+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
- -> Sort (cost=1.07..1.07 rows=1 width=12)
+ -> Sort
Output: q1.y, q1.x
Sort Key: q1.x
- -> Subquery Scan on q1 (cost=1.02..1.06 rows=1 width=12)
+ -> Subquery Scan on q1
Output: q1.y, q1.x
- -> GroupAggregate (cost=1.02..1.05 rows=1 width=8)
+ -> GroupAggregate
Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(13 rows)
+ Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3
+(14 rows)
-- group by without aggregate
select val2 from xc_groupby_tab1 group by val2;
@@ -1257,16 +1298,17 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain verbose select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- Group (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select val + val2 from xc_groupby_tab1 group by val + val2;
?column?
@@ -1279,16 +1321,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
9
(6 rows)
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- Group (cost=1.03..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
?column? | val | val2
@@ -1303,16 +1346,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
9 | 6 | 3
(8 rows)
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- Group (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3 ORDER BY 2, 3
+(7 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
@@ -1325,16 +1369,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
6 | 4 | 2
(6 rows)
-explain verbose 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
----------------------------------------------------------------------------------------------------------------
- Group (cost=0.01..0.02 rows=1 width=0)
+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
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1 FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 2, 3 ORDER BY 2, 3
+(7 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?
@@ -1345,16 +1390,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
7
(4 rows)
-explain verbose 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 (cost=0.01..0.02 rows=1 width=0)
+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))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1) FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 1 ORDER BY 1
+(7 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -1365,16 +1411,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
17.6666666666666667 | 3
(3 rows)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+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(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4
+(7 rows)
-- group by with expressions in group by clause
select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -1385,16 +1432,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
11 | 3.6666666666666667 | 6
(3 rows)
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.03..1.05 rows=1 width=8)
+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(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3
+(7 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -1429,21 +1477,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
| 0
(11 rows)
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ GroupAggregate
Output: a, count(a)
- -> Sort (cost=1.02..1.03 rows=1 width=4)
+ -> Sort
Output: a
Sort Key: xc_groupby_def.a
- -> Result (cost=0.00..1.01 rows=1 width=4)
+ -> Result
Output: a
- -> Materialize (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on xc_groupby_def
Output: a, b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
- Output: a, b
-(11 rows)
+ Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -1477,16 +1524,17 @@ select avg(a) from xc_groupby_def group by a;
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by b;
avg
@@ -1497,16 +1545,17 @@ select avg(a) from xc_groupby_def group by b;
4.0000000000000000
(4 rows)
-explain verbose select avg(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(a) from xc_groupby_def group by b;
sum
@@ -1517,16 +1566,17 @@ select sum(a) from xc_groupby_def group by b;
8
(4 rows)
-explain verbose select sum(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select count(*) from xc_groupby_def group by b;
count
@@ -1537,16 +1587,17 @@ select count(*) from xc_groupby_def group by b;
3
(4 rows)
-explain verbose select count(*) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.count(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select count(*) from xc_groupby_def where a is not null group by a;
count
@@ -1563,16 +1614,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
1
(10 rows)
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.count(*), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT count(*), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select b from xc_groupby_def group by b;
b
@@ -1583,16 +1635,17 @@ select b from xc_groupby_def group by b;
(4 rows)
-explain verbose select b from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- Group (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select b,count(b) from xc_groupby_def group by b;
b | count
@@ -1603,16 +1656,17 @@ select b,count(b) from xc_groupby_def group by b;
| 0
(4 rows)
-explain verbose select b,count(b) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+ Remote query: SELECT group_1.b, count(group_1.b) FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -1620,16 +1674,17 @@ select count(*) from xc_groupby_def where b is null group by b;
3
(1 row)
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+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(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
create table xc_groupby_g(a int, b float, c numeric);
insert into xc_groupby_g values(1,2.1,3.2);
@@ -1642,16 +1697,17 @@ select sum(a) from xc_groupby_g group by a;
2
(2 rows)
-explain verbose select sum(a) from xc_groupby_g group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.a FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(b) from xc_groupby_g group by b;
sum
@@ -1660,16 +1716,17 @@ select sum(b) from xc_groupby_g group by b;
2.3
(2 rows)
-explain verbose select sum(b) from xc_groupby_g group by b;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.b), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(c) from xc_groupby_g group by b;
sum
@@ -1678,16 +1735,17 @@ select sum(c) from xc_groupby_g group by b;
5.2
(2 rows)
-explain verbose select sum(c) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=40)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.c), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(a) from xc_groupby_g group by b;
avg
@@ -1696,16 +1754,17 @@ select avg(a) from xc_groupby_g group by b;
2.0000000000000000
(2 rows)
-explain verbose select avg(a) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=12)
+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(xc_groupby_g.a))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=12)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(b) from xc_groupby_g group by c;
avg
@@ -1714,16 +1773,17 @@ select avg(b) from xc_groupby_g group by c;
2.3
(2 rows)
-explain verbose select avg(b) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=40)
+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(xc_groupby_g.b))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.b), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(c) from xc_groupby_g group by c;
avg
@@ -1732,16 +1792,17 @@ select avg(c) from xc_groupby_g group by c;
5.2000000000000000
(2 rows)
-explain verbose select avg(c) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=32)
+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(xc_groupby_g.c))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- -> Data Node Scan (Node Count [2]) (cost=0.00..1.01 rows=1000 width=32)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.c), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
drop table xc_groupby_def;
drop table xc_groupby_g;
@@ -1760,16 +1821,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_gro
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(3 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((pg_catalog.sum((sum(xc_groupby_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4
+(7 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;
@@ -1781,28 +1843,26 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_
3 | | | | | 4
(4 rows)
-explain verbose 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;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=2.07..2.12 rows=1 width=16)
+ 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
- -> Sort (cost=2.07..2.07 rows=1 width=16)
+ -> Sort
Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2
- -> Hash Full Join (cost=1.03..2.06 rows=1 width=16)
+ -> Hash Full Join
Output: xc_groupby_tab1.val, xc_groupby_tab2.val, xc_groupby_tab1.val2, xc_groupby_tab2.val2
Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2)
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab1
Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) on xc_groupby_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Hash (cost=1.01..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1
+ -> Hash
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_groupby_tab2
Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [1]) on xc_groupby_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_groupby_tab2.val, xc_groupby_tab2.val2
-(18 rows)
+ Remote query: SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2
+(16 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;
@@ -1812,23 +1872,24 @@ select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by va
17
(2 rows)
-explain verbose 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 (cost=1.07..1.09 rows=1 width=12)
+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
- -> Sort (cost=1.07..1.07 rows=1 width=12)
+ -> Sort
Output: q1.y, q1.x
Sort Key: q1.x
- -> Subquery Scan on q1 (cost=1.02..1.06 rows=1 width=12)
+ -> Subquery Scan on q1
Output: q1.y, q1.x
- -> GroupAggregate (cost=1.02..1.05 rows=1 width=8)
+ -> GroupAggregate
Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), (xc_groupby_tab1.val2 % 2), xc_groupby_tab1.val2
-(13 rows)
+ Remote query: SELECT sum(group_1.val), (group_1.val2 % 2), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3
+(14 rows)
-- group by without aggregate
select val2 from xc_groupby_tab1 group by val2;
@@ -1839,16 +1900,17 @@ select val2 from xc_groupby_tab1 group by val2;
3
(3 rows)
-explain verbose select val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- Group (cost=1.02..1.03 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select val + val2 from xc_groupby_tab1 group by val + val2;
?column?
@@ -1861,16 +1923,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2;
9
(6 rows)
-explain verbose select val + val2 from xc_groupby_tab1 group by val + val2;
- QUERY PLAN
-----------------------------------------------------------------------------------
- Group (cost=1.03..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
?column? | val | val2
@@ -1885,16 +1948,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
9 | 6 | 3
(8 rows)
-explain verbose select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------------
- Group (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab1.val2), xc_groupby_tab1.val, xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), group_1.val, group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 2, 3 ORDER BY 2, 3
+(7 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
@@ -1907,16 +1971,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group
6 | 4 | 2
(6 rows)
-explain verbose 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
----------------------------------------------------------------------------------------------------------------
- Group (cost=0.01..0.02 rows=1 width=0)
+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
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2), xc_groupby_tab1.val, xc_groupby_tab2.val2
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1), group_2.val_1_1_1, group_2.val2_2_2_1 FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 2, 3 ORDER BY 2, 3
+(7 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?
@@ -1927,16 +1992,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group
7
(4 rows)
-explain verbose 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 (cost=0.01..0.02 rows=1 width=0)
+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))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_groupby_tab1.val + xc_groupby_tab2.val2)
-(6 rows)
+ Remote query: SELECT (group_2.val_1_1_1 + group_2.val2_2_2_1) FROM (SELECT in_1.val AS val_1_1_1, out_1.val2 AS val2_2_2_1 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) in_1 , (SELECT val, val2 FROM public.xc_groupby_tab2 xc_groupby_tab2) out_1 WHERE (in_1.val = out_1.val)) group_2 GROUP BY 1 ORDER BY 1
+(7 rows)
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
@@ -1947,16 +2013,17 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
17.6666666666666667 | 3
(3 rows)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+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(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), xc_groupby_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 4 ORDER BY 4
+(7 rows)
-- group by with expressions in group by clause
select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
@@ -1967,16 +2034,17 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
11 | 3.6666666666666667 | 6
(3 rows)
-explain verbose select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2;
- QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.03..1.05 rows=1 width=8)
+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(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_tab1.val), avg(xc_groupby_tab1.val), (2 * xc_groupby_tab1.val2)
-(6 rows)
+ Remote query: SELECT sum(group_1.val), avg(group_1.val), (2 * group_1.val2) FROM (SELECT val, val2 FROM public.xc_groupby_tab1 xc_groupby_tab1) group_1 GROUP BY 3 ORDER BY 3
+(7 rows)
drop table xc_groupby_tab1;
drop table xc_groupby_tab2;
@@ -2011,21 +2079,20 @@ select a,count(a) from xc_groupby_def group by a order by a;
| 0
(11 rows)
-explain verbose select a,count(a) from xc_groupby_def group by a order by a;
- QUERY PLAN
-----------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select a,count(a) from xc_groupby_def group by a order by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------
+ GroupAggregate
Output: a, count(a)
- -> Sort (cost=1.02..1.03 rows=1 width=4)
+ -> Sort
Output: a
Sort Key: xc_groupby_def.a
- -> Result (cost=0.00..1.01 rows=1 width=4)
+ -> Result
Output: a
- -> Materialize (cost=0.00..1.01 rows=1 width=4)
+ -> Data Node Scan on xc_groupby_def
Output: a, b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
- Output: a, b
-(11 rows)
+ Remote query: SELECT a, b FROM public.xc_groupby_def xc_groupby_def
+(10 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -2043,16 +2110,17 @@ select avg(a) from xc_groupby_def group by a;
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by a;
avg
@@ -2070,16 +2138,17 @@ select avg(a) from xc_groupby_def group by a;
(11 rows)
-explain verbose select avg(a) from xc_groupby_def group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_def group by a;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.avg((avg(xc_groupby_def.a))), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(a) from xc_groupby_def group by b;
avg
@@ -2090,16 +2159,17 @@ select avg(a) from xc_groupby_def group by b;
4.0000000000000000
(4 rows)
-explain verbose select avg(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(a) from xc_groupby_def group by b;
sum
@@ -2110,16 +2180,17 @@ select sum(a) from xc_groupby_def group by b;
8
(4 rows)
-explain verbose select sum(a) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=72)
+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(xc_groupby_def.a))), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_def.a)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=72)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_def.a), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select count(*) from xc_groupby_def group by b;
count
@@ -2130,16 +2201,17 @@ select count(*) from xc_groupby_def group by b;
3
(4 rows)
-explain verbose select count(*) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def group by b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.count(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select count(*) from xc_groupby_def where a is not null group by a;
count
@@ -2156,16 +2228,17 @@ select count(*) from xc_groupby_def where a is not null group by a;
1
(10 rows)
-explain verbose select count(*) from xc_groupby_def where a is not null group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where a is not null group by a;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.count(*), xc_groupby_def.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.a
-(6 rows)
+ Remote query: SELECT count(*), group_1.a FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (a IS NOT NULL)) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select b from xc_groupby_def group by b;
b
@@ -2176,16 +2249,17 @@ select b from xc_groupby_def group by b;
(4 rows)
-explain verbose select b from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- Group (cost=1.02..1.03 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------
+ Group
Output: xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select b,count(b) from xc_groupby_def group by b;
b | count
@@ -2196,16 +2270,17 @@ select b,count(b) from xc_groupby_def group by b;
| 0
(4 rows)
-explain verbose select b,count(b) from xc_groupby_def group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b;
+ QUERY PLAN
+-------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: xc_groupby_def.b, count((count(xc_groupby_def.b)))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_groupby_def.b, (count(xc_groupby_def.b))
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_groupby_def.b, count(xc_groupby_def.b)
-(6 rows)
+ Remote query: SELECT group_1.b, count(group_1.b) FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def) group_1 GROUP BY 1 ORDER BY 1
+(7 rows)
select count(*) from xc_groupby_def where b is null group by b;
count
@@ -2213,16 +2288,17 @@ select count(*) from xc_groupby_def where b is null group by b;
3
(1 row)
-explain verbose select count(*) from xc_groupby_def where b is null group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=68)
+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(*), xc_groupby_def.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), xc_groupby_def.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=68)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), xc_groupby_def.b
-(6 rows)
+ Remote query: SELECT count(*), group_1.b FROM (SELECT a, b FROM public.xc_groupby_def xc_groupby_def WHERE (b IS NULL)) group_1 GROUP BY 2 ORDER BY 2
+(7 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);
@@ -2235,16 +2311,17 @@ select sum(a) from xc_groupby_g group by a;
2
(2 rows)
-explain verbose select sum(a) from xc_groupby_g group by a;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=4)
+explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: pg_catalog.sum((sum(xc_groupby_g.a))), xc_groupby_g.a
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.a)), xc_groupby_g.a
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=4)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.a), xc_groupby_g.a
-(6 rows)
+ Remote query: SELECT sum(group_1.a), group_1.a FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(b) from xc_groupby_g group by b;
sum
@@ -2253,16 +2330,17 @@ select sum(b) from xc_groupby_g group by b;
2.3
(2 rows)
-explain verbose select sum(b) from xc_groupby_g group by b;
- QUERY PLAN
-----------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: sum((sum(xc_groupby_g.b))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.b)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.b), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.b), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select sum(c) from xc_groupby_g group by b;
sum
@@ -2271,16 +2349,17 @@ select sum(c) from xc_groupby_g group by b;
5.2
(2 rows)
-explain verbose select sum(c) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.04 rows=1 width=40)
+explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b;
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: sum((sum(xc_groupby_g.c))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (sum(xc_groupby_g.c)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: sum(xc_groupby_g.c), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT sum(group_1.c), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(a) from xc_groupby_g group by b;
avg
@@ -2289,16 +2368,17 @@ select avg(a) from xc_groupby_g group by b;
2.0000000000000000
(2 rows)
-explain verbose select avg(a) from xc_groupby_g group by b;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=12)
+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(xc_groupby_g.a))), xc_groupby_g.b
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.a)), xc_groupby_g.b
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=12)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.a), xc_groupby_g.b
-(6 rows)
+ Remote query: SELECT avg(group_1.a), group_1.b FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(b) from xc_groupby_g group by c;
avg
@@ -2307,16 +2387,17 @@ select avg(b) from xc_groupby_g group by c;
2.3
(2 rows)
-explain verbose select avg(b) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=40)
+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(xc_groupby_g.b))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.b)), xc_groupby_g.c
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=40)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.b), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.b), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 rows)
select avg(c) from xc_groupby_g group by c;
avg
@@ -2325,16 +2406,17 @@ select avg(c) from xc_groupby_g group by c;
5.2000000000000000
(2 rows)
-explain verbose select avg(c) from xc_groupby_g group by c;
- QUERY PLAN
------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=32)
+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(xc_groupby_g.c))), xc_groupby_g.c
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (avg(xc_groupby_g.c)), xc_groupby_g.c
- -> Data Node Scan (Node Count [1]) (cost=0.00..1.01 rows=1000 width=32)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: avg(xc_groupby_g.c), xc_groupby_g.c
-(6 rows)
+ Remote query: SELECT avg(group_1.c), group_1.c FROM (SELECT a, b, c FROM public.xc_groupby_g xc_groupby_g) group_1 GROUP BY 2 ORDER BY 2
+(7 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 2212a79c3e..d8c619a888 100644
--- a/src/test/regress/expected/xc_having.out
+++ b/src/test/regress/expected/xc_having.out
@@ -17,16 +17,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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 (cost=1.03..1.05 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4
+(7 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;
@@ -35,17 +36,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
2 | 8 | 4.0000000000000000 | 4 | 2
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 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
@@ -54,34 +56,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain verbose 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;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 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
-------+-----+-----+----------+------
(0 rows)
-explain verbose 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;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4
+(8 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;
@@ -90,23 +94,21 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
6 | 96 | 16.0000000000000000 | 16 | 2 | 2
(1 row)
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=2.07..2.09 rows=1 width=16)
+ HashAggregate
Output: 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)))::double precision / (count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
- -> Nested Loop (cost=0.00..2.05 rows=1 width=16)
+ -> Nested Loop
Output: xc_having_tab1.val, xc_having_tab1.val2, xc_having_tab2.val, xc_having_tab2.val2
Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_having_tab1
Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on xc_having_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+ -> Data Node Scan on xc_having_tab2
Output: xc_having_tab2.val, xc_having_tab2.val2
- -> Data Node Scan (Node Count [2]) on xc_having_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab2.val, xc_having_tab2.val2
-(13 rows)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(11 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -115,17 +117,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
3
(1 row)
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_having_tab1.val2
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT group_1.val2, sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1
+(8 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -135,17 +138,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
9
(3 rows)
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1
+(8 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;
@@ -154,17 +158,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
17.6666666666666667 | 3
(1 row)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.03..1.05 rows=1 width=8)
+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(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2, min(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -182,16 +187,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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 (cost=1.03..1.05 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4
+(7 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;
@@ -200,17 +206,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
2 | 8 | 4.0000000000000000 | 4 | 2
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 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
@@ -219,34 +226,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain verbose 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;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 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
-------+-----+-----+----------+------
(0 rows)
-explain verbose 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;
+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 (cost=1.03..1.06 rows=1 width=8)
+ HashAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4
+(8 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;
@@ -255,23 +264,21 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
6 | 96 | 16.0000000000000000 | 16 | 2 | 2
(1 row)
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=2.07..2.09 rows=1 width=16)
+ HashAggregate
Output: 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)))::double precision / (count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
- -> Nested Loop (cost=0.00..2.05 rows=1 width=16)
+ -> Nested Loop
Output: xc_having_tab1.val, xc_having_tab1.val2, xc_having_tab2.val, xc_having_tab2.val2
Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_having_tab1
Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on xc_having_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+ -> Data Node Scan on xc_having_tab2
Output: xc_having_tab2.val, xc_having_tab2.val2
- -> Data Node Scan (Node Count [1]) on xc_having_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab2.val, xc_having_tab2.val2
-(13 rows)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(11 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -280,17 +287,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
3
(1 row)
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.03 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+ QUERY PLAN
+-----------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: xc_having_tab1.val2
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT group_1.val2, sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1
+(8 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -300,17 +308,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
9
(3 rows)
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.02..1.04 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ HashAggregate
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1
+(8 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;
@@ -319,17 +328,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
17.6666666666666667 | 3
(1 row)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
- HashAggregate (cost=1.03..1.05 rows=1 width=8)
+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(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2, min(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4
+(8 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -347,16 +357,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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 (cost=1.03..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4 ORDER BY 4
+(7 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;
@@ -365,17 +376,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
2 | 8 | 4.0000000000000000 | 4 | 2
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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 (cost=1.02..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 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
@@ -384,34 +396,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain verbose 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;
+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 (cost=1.02..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 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
-------+-----+-----+----------+------
(0 rows)
-explain verbose 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;
+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 (cost=1.03..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4 ORDER BY 4
+(8 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;
@@ -420,26 +434,24 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
6 | 96 | 16.0000000000000000 | 16 | 2 | 2
(1 row)
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=2.06..2.11 rows=1 width=16)
+ GroupAggregate
Output: 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)))::double precision / (count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
- -> Sort (cost=2.06..2.06 rows=1 width=16)
+ -> Sort
Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
Sort Key: xc_having_tab1.val2, xc_having_tab2.val2
- -> Nested Loop (cost=0.00..2.05 rows=1 width=16)
+ -> Nested Loop
Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_having_tab1
Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Data Node Scan (Node Count [2]) on xc_having_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+ -> Data Node Scan on xc_having_tab2
Output: xc_having_tab2.val, xc_having_tab2.val2
- -> Data Node Scan (Node Count [2]) on xc_having_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab2.val, xc_having_tab2.val2
-(16 rows)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(14 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -448,17 +460,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
3
(1 row)
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: xc_having_tab1.val2
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT group_1.val2, sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1
+(8 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -468,17 +481,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
9
(3 rows)
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.03..1.05 rows=1 width=8)
+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
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1
+(8 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;
@@ -487,17 +501,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
17.6666666666666667 | 3
(1 row)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+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(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
- -> Data Node Scan (Node Count [2]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2, min(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -515,16 +530,17 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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 (cost=1.03..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(6 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE ((val2 + 1) > 3)) group_1 GROUP BY 4 ORDER BY 4
+(7 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;
@@ -533,17 +549,18 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
2 | 8 | 4.0000000000000000 | 4 | 2
(1 row)
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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 (cost=1.02..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 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
@@ -552,34 +569,36 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav
3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3
(2 rows)
-explain verbose 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;
+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 (cost=1.02..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: ((pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75) OR (xc_having_tab1.val2 > 2))
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 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
-------+-----+-----+----------+------
(0 rows)
-explain verbose 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;
+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 (cost=1.03..1.07 rows=1 width=8)
+ GroupAggregate
Output: pg_catalog.count(*), pg_catalog.sum((sum(xc_having_tab1.val))), pg_catalog.avg((avg(xc_having_tab1.val))), ((pg_catalog.sum((sum(xc_having_tab1.val))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2
Filter: (pg_catalog.avg((avg(xc_having_tab1.val))) > 3.75)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2 FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1 WHERE (val2 > 2)) group_1 GROUP BY 4 ORDER BY 4
+(8 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;
@@ -588,26 +607,24 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab
6 | 96 | 16.0000000000000000 | 16 | 2 | 2
(1 row)
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=2.06..2.11 rows=1 width=16)
+ GroupAggregate
Output: 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)))::double precision / (count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2
- -> Sort (cost=2.06..2.06 rows=1 width=16)
+ -> Sort
Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
Sort Key: xc_having_tab1.val2, xc_having_tab2.val2
- -> Nested Loop (cost=0.00..2.05 rows=1 width=16)
+ -> Nested Loop
Output: xc_having_tab1.val, xc_having_tab2.val, xc_having_tab1.val2, xc_having_tab2.val2
Join Filter: ((xc_having_tab1.val2 = xc_having_tab2.val2) AND ((xc_having_tab1.val2 + xc_having_tab2.val2) > 2))
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ -> Data Node Scan on xc_having_tab1
Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Data Node Scan (Node Count [1]) on xc_having_tab1 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab1.val, xc_having_tab1.val2
- -> Materialize (cost=0.00..1.01 rows=1 width=8)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1
+ -> Data Node Scan on xc_having_tab2
Output: xc_having_tab2.val, xc_having_tab2.val2
- -> Data Node Scan (Node Count [1]) on xc_having_tab2 (cost=0.00..1.01 rows=1000 width=8)
- Output: xc_having_tab2.val, xc_having_tab2.val2
-(16 rows)
+ Remote query: SELECT val, val2 FROM public.xc_having_tab2 xc_having_tab2
+(14 rows)
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
@@ -616,17 +633,18 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
3
(1 row)
-explain verbose select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.05 rows=1 width=8)
+explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
+ QUERY PLAN
+---------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ GroupAggregate
Output: xc_having_tab1.val2
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: xc_having_tab1.val2, (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: xc_having_tab1.val2, sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT group_1.val2, sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1
+(8 rows)
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
?column?
@@ -636,17 +654,18 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
9
(3 rows)
-explain verbose select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
- QUERY PLAN
----------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.03..1.05 rows=1 width=8)
+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
Output: ((xc_having_tab1.val + xc_having_tab1.val2))
Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: (xc_having_tab1.val + xc_having_tab1.val2), sum(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT (group_1.val + group_1.val2), sum(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 1 ORDER BY 1
+(8 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;
@@ -655,17 +674,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha
17.6666666666666667 | 3
(1 row)
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
- QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------
- GroupAggregate (cost=1.02..1.06 rows=1 width=8)
+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(xc_having_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_having_tab1.val)))), xc_having_tab1.val2
Filter: (min((min(xc_having_tab1.val))) < xc_having_tab1.val2)
- -> Materialize (cost=0.00..0.00 rows=0 width=0)
+ -> Materialize
Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2, (min(xc_having_tab1.val))
- -> Data Node Scan (Node Count [1]) on "__FOREIGN_QUERY__" (cost=0.00..1.01 rows=1000 width=8)
+ -> Data Node Scan on "__REMOTE_GROUP_QUERY__"
Output: count(*), sum(xc_having_tab1.val), avg(xc_having_tab1.val), xc_having_tab1.val2, min(xc_having_tab1.val)
-(7 rows)
+ Remote query: SELECT count(*), sum(group_1.val), avg(group_1.val), group_1.val2, min(group_1.val) FROM (SELECT val, val2 FROM public.xc_having_tab1 xc_having_tab1) group_1 GROUP BY 4 ORDER BY 4
+(8 rows)
drop table xc_having_tab1;
drop table xc_having_tab2;
diff --git a/src/test/regress/sql/xc_distkey.sql b/src/test/regress/sql/xc_distkey.sql
index b57502d26f..e3f5849c24 100644
--- a/src/test/regress/sql/xc_distkey.sql
+++ b/src/test/regress/sql/xc_distkey.sql
@@ -18,8 +18,8 @@ select * from nu_tab order by a;
select * from nu_tab where a = 123.456;
select * from nu_tab where 789.412 = a;
-explain select * from nu_tab where a = 123.456;
-explain select * from nu_tab where 789.412 = a;
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where a = 123.456;
+explain (costs false, num_nodes true, nodes false) select * from nu_tab where 789.412 = a;
create table tx_tab(a text) distribute by modulo(a);
@@ -32,8 +32,8 @@ select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?'
select * from tx_tab where 'hello world' = a;
select * from tx_tab where 'Did the quick brown fox jump over the lazy dog?' = a;
-explain select * from tx_tab where a = 'hello world';
-explain select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'hello world';
+explain (costs false, num_nodes true, nodes false) select * from tx_tab where a = 'Did the quick brown fox jump over the lazy dog?';
@@ -47,10 +47,10 @@ select * from vc_tab where a = 'A quick brown fox';
-- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
select * from vc_tab where 'A quick brown fox' = a;
-explain select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
-explain select * from vc_tab where a = 'A quick brown fox';
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'abcdefghijklmnopqrstuvwxyz';
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where a = 'A quick brown fox';
-- This test a bug in examine_conditions_walker where a = constant is optimized but constant = a was not
-explain select * from vc_tab where 'A quick brown fox' = a;
+explain (costs false, num_nodes true, nodes false) select * from vc_tab where 'A quick brown fox' = a;
@@ -118,8 +118,8 @@ select * from i4_tab where a = 2147483647;
select * from i4_tab where 65530 = a;
select * from i4_tab where 2147483647 = a;
-explain select * from i4_tab where 65530 = a;
-explain select * from i4_tab where a = 2147483647;
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where 65530 = a;
+explain (costs false, num_nodes true, nodes false) select * from i4_tab where a = 2147483647;
create table bo_tab(a bool) distribute by modulo(a);
diff --git a/src/test/regress/sql/xc_groupby.sql b/src/test/regress/sql/xc_groupby.sql
index 896ea7fad1..d3827f1303 100644
--- a/src/test/regress/sql/xc_groupby.sql
+++ b/src/test/regress/sql/xc_groupby.sql
@@ -12,30 +12,30 @@ 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 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 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 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 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 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 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 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 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 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 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;
@@ -56,25 +56,25 @@ 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 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 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 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 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 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 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 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 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 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);
@@ -82,18 +82,18 @@ 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 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 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 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 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 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 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;
@@ -106,30 +106,30 @@ 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 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 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 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 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 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 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 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 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 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 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;
@@ -150,26 +150,26 @@ 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 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 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 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 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 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 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 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 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 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 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);
@@ -177,18 +177,18 @@ 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 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 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 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 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 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 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;
@@ -202,30 +202,30 @@ 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 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 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 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 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 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 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 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 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 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 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;
@@ -246,25 +246,25 @@ 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 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 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 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 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 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 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 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 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 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);
@@ -272,18 +272,18 @@ 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 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 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 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 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 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 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;
@@ -296,30 +296,30 @@ 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 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 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 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 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 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 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 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 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 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 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;
@@ -340,26 +340,26 @@ 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 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 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 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 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 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 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 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 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 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 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);
@@ -367,18 +367,18 @@ 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 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 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 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 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 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 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;
diff --git a/src/test/regress/sql/xc_having.sql b/src/test/regress/sql/xc_having.sql
index 97c2f9310e..c525a29b88 100644
--- a/src/test/regress/sql/xc_having.sql
+++ b/src/test/regress/sql/xc_having.sql
@@ -13,25 +13,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-- having clause not containing any aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
-- 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;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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;
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;
-explain verbose 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;
+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;
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;
-explain verbose 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;
+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;
-- 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;
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-explain verbose 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;
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose 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;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+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;
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -44,25 +44,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-- having clause not containing any aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
-- 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;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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;
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;
-explain verbose 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;
+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;
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;
-explain verbose 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;
+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;
-- 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;
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-explain verbose 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;
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose 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;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+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;
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -75,25 +75,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-- having clause not containing any aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
-- 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;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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;
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;
-explain verbose 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;
+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;
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;
-explain verbose 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;
+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;
-- 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;
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-explain verbose 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;
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose 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;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+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;
drop table xc_having_tab1;
drop table xc_having_tab2;
@@ -106,25 +106,25 @@ insert into xc_having_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3)
insert into xc_having_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2);
-- having clause not containing any aggregate
select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3;
+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;
-- 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;
-explain verbose select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75;
+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;
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;
-explain verbose 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;
+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;
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;
-explain verbose 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;
+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;
-- 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;
-explain verbose 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;
+explain (verbose true, costs false, nodes false) 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;
-- group by and having, without aggregate in the target list
select val2 from xc_having_tab1 group by val2 having sum(val) > 8;
-explain verbose 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;
select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5;
-explain verbose 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;
-- group by with aggregates in expression
select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
-explain verbose select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2;
+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;
drop table xc_having_tab1;
drop table xc_having_tab2;
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-28 20:57:44 +0000