diff options
author | Michael Paquier | 2012-10-12 00:26:50 +0000 |
---|---|---|
committer | Michael Paquier | 2012-10-12 00:33:25 +0000 |
commit | 6c6ba3c4583bd55edf5d3498d57635dec36419e0 (patch) | |
tree | fe5495c09b4b51f3a0471244623450257f795b1d | |
parent | 66c17a5a348a4ed09859be3c45c64e9a99cc2d49 (diff) |
Revert "The commit has following changes: GROUP BY optimization patch"
This reverts commit 66c17a5a348a4ed09859be3c45c64e9a99cc2d49.
This patch basically broke HEAD for aggregate pushdown, so
reverting it is the right thing to do to keep a master version
stable.
-rw-r--r-- | src/backend/nodes/copyfuncs.c | 1 | ||||
-rw-r--r-- | src/backend/nodes/outfuncs.c | 1 | ||||
-rw-r--r-- | src/backend/optimizer/plan/pgxcplan.c | 563 | ||||
-rw-r--r-- | src/backend/optimizer/plan/setrefs.c | 98 | ||||
-rw-r--r-- | src/backend/optimizer/util/pgxcship.c | 26 | ||||
-rw-r--r-- | src/include/optimizer/pgxcplan.h | 1 | ||||
-rw-r--r-- | src/include/optimizer/pgxcship.h | 1 | ||||
-rw-r--r-- | src/test/regress/expected/aggregates.out | 38 | ||||
-rw-r--r-- | src/test/regress/expected/aggregates_1.out | 36 | ||||
-rw-r--r-- | src/test/regress/expected/xc_FQS.out | 12 | ||||
-rw-r--r-- | src/test/regress/expected/xc_groupby.out | 1154 | ||||
-rw-r--r-- | src/test/regress/expected/xc_having.out | 274 | ||||
-rw-r--r-- | src/test/regress/sql/xc_FQS.sql | 2 | ||||
-rw-r--r-- | src/test/regress/sql/xc_groupby.sql | 275 | ||||
-rw-r--r-- | src/test/regress/sql/xc_having.sql | 24 |
15 files changed, 1287 insertions, 1219 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index dd4d5b288f..9db6c2b46a 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -1038,6 +1038,7 @@ _copyRemoteQuery(const RemoteQuery *from) COPY_NODE_FIELD(base_tlist); COPY_NODE_FIELD(coord_var_tlist); COPY_NODE_FIELD(query_var_tlist); + COPY_SCALAR_FIELD(is_shippable_tlist); COPY_SCALAR_FIELD(has_row_marks); COPY_SCALAR_FIELD(has_ins_child_sel_parent); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 533b88f150..8e858316fe 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -487,6 +487,7 @@ _outRemoteQuery(StringInfo str, const RemoteQuery *node) WRITE_NODE_FIELD(remote_query); WRITE_NODE_FIELD(coord_var_tlist); WRITE_NODE_FIELD(query_var_tlist); + WRITE_BOOL_FIELD(is_shippable_tlist); WRITE_BOOL_FIELD(has_ins_child_sel_parent); } diff --git a/src/backend/optimizer/plan/pgxcplan.c b/src/backend/optimizer/plan/pgxcplan.c index ec65956ebd..97ec9f183e 100644 --- a/src/backend/optimizer/plan/pgxcplan.c +++ b/src/backend/optimizer/plan/pgxcplan.c @@ -57,17 +57,17 @@ static RemoteQuery *pgxc_FQS_create_remote_plan(Query *query, ExecNodes *exec_nodes, bool is_exec_direct); static void pgxc_set_remote_parameters(PlannedStmt *plan, ParamListInfo boundParams); -static bool pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, +static void pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, AttrNumber *grpColIdx); -static List *pgxc_process_grouping_targetlist(List *local_tlist, - bool single_node_grouping); -static List *pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping, +static List *pgxc_process_grouping_targetlist(PlannerInfo *root, + List **local_tlist); +static List *pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQual, List **local_qual, - List **remote_qual); + List **remote_qual, bool *reduce_plan); static Expr *pgxc_set_en_expr(Oid tableoid, Index resultRelationIndex); static int pgxc_count_rowmarks_entries(List *rowMarks); static Oid *pgxc_build_rowmark_entries(List *rowMarks, List *rtable, Oid *types, int prepparams, int totparams); -static List *pgxc_separate_quals(List *quals, List **local_quals, bool has_aggs); +static List *pgxc_separate_quals(List *quals, List **local_quals); static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root, RemoteQueryPath *rqpath, List **unshippable_quals, @@ -75,10 +75,6 @@ static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root, static RemoteQuery *make_remotequery(List *qptlist, List *qpqual, Index scanrelid); static RangeTblEntry *make_dummy_remote_rte(char *relname, Alias *alias); -static List *pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, - bool has_aggs); -static List *pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr, - Index ressortgroupref); static void pgxc_rqplan_adjust_vars(RemoteQuery *rqplan, Node *node); /* @@ -87,23 +83,17 @@ static void pgxc_rqplan_adjust_vars(RemoteQuery *rqplan, Node *node); * quals as return value and unshippable quals as local_quals */ static List * -pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs) +pgxc_separate_quals(List *quals, List **unshippabl_quals) { ListCell *l; List *shippabl_quals = NIL; - /* - * If the caller knows that there can be aggregates in the calls, we better - * take steps for the same. See prologue of pgxc_is_expr_shippable(). - */ - bool tmp_has_aggs; - bool *tmp_bool_ptr = has_aggs ? &tmp_has_aggs : NULL; *unshippabl_quals = NIL; foreach(l, quals) { Expr *clause = lfirst(l); - if (pgxc_is_expr_shippable(clause, tmp_bool_ptr)) + if (pgxc_is_expr_shippable(clause, NULL)) shippabl_quals = lappend(shippabl_quals, clause); else *unshippabl_quals = lappend(*unshippabl_quals, clause); @@ -124,15 +114,11 @@ pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs) * those in the target list for the datanode. */ static List * -pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs) +pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals) { - ListCell *lcell; - List *remote_tlist = NIL; - PVCAggregateBehavior pvc_agg_spec = has_aggs ? PVC_INCLUDE_AGGREGATES - : PVC_REJECT_AGGREGATES; - List *unshippable_expr = list_copy(unshippabl_quals); - List *aggs_n_vars; - bool tmp_has_aggs; + ListCell *lcell; + List *remote_tlist = NIL; + List *tmp_rtlist = NIL; /* * Add all the shippable members as they are to the target list being built, @@ -140,15 +126,8 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs) */ foreach(lcell, tlist) { - TargetEntry *tle = lfirst(lcell); - Expr *expr; - bool *tmp_ptr; - - /* - * If there are aggregates in the targetlist, we should say so while - * checking the expression shippability. - */ - tmp_ptr = has_aggs ? &tmp_has_aggs : NULL; + TargetEntry *tle = lfirst(lcell); + Expr *expr; if (!IsA(tle, TargetEntry)) elog(ERROR, "Expected TargetEntry node, but got node with type %d", @@ -159,29 +138,22 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs) * pgxc_is_expr_shippable(). Helps in detecting top level RowExpr, which * are unshippable */ - if (pgxc_is_expr_shippable((Expr *)tle, tmp_ptr)) - remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, (Node *)expr, - tle->ressortgroupref); + if (pgxc_is_expr_shippable((Expr *)tle, NULL)) + tmp_rtlist = lappend(tmp_rtlist, expr); else - unshippable_expr = lappend(unshippable_expr, expr); + tmp_rtlist = list_concat(tmp_rtlist, pull_var_clause((Node *)expr, + PVC_REJECT_AGGREGATES, + PVC_RECURSE_PLACEHOLDERS)); } + remote_tlist = add_to_flat_tlist(remote_tlist, tmp_rtlist); /* - * Now collect the aggregates (if needed) and Vars from the unshippable - * expressions (from targetlist and unshippable quals and add them to - * remote targetlist. + * The passed in quals are already checked for shippability, so just add the + * vars from those clauses to the targetlist being built. */ - aggs_n_vars = pull_var_clause((Node *)unshippable_expr, pvc_agg_spec, - PVC_RECURSE_PLACEHOLDERS); - foreach(lcell, aggs_n_vars) - { - Node *agg_or_var = lfirst(lcell); - Assert(IsA(agg_or_var, Aggref) || IsA(agg_or_var, Var)); - /* If it's an aggregate expression, better it be shippable. */ - Assert(!IsA(agg_or_var, Aggref) || - pgxc_is_expr_shippable((Expr *)agg_or_var, &tmp_has_aggs)); - remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, agg_or_var, 0); - } + remote_tlist = add_to_flat_tlist(remote_tlist, pull_var_clause((Node *)unshippabl_quals, + PVC_RECURSE_AGGREGATES, + PVC_RECURSE_PLACEHOLDERS)); return remote_tlist; } @@ -228,7 +200,7 @@ pgxc_build_shippable_query_baserel(PlannerInfo *root, RemoteQueryPath *rqpath, scan_clauses = pgxc_order_qual_clauses(root, baserel->baserestrictinfo); scan_clauses = list_concat(extract_actual_clauses(scan_clauses, false), extract_actual_clauses(scan_clauses, true)); - shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals, false); + shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals); shippable_quals = copyObject(shippable_quals); /* @@ -390,13 +362,13 @@ pgxc_build_shippable_query_jointree(PlannerInfo *root, RemoteQueryPath *rqpath, */ extract_actual_join_clauses(rqpath->join_restrictlist, &join_clauses, &other_clauses); - if (!pgxc_is_expr_shippable((Expr *)join_clauses, NULL)) + if (!pgxc_is_expr_shippable((Expr *)join_clauses, false)) elog(ERROR, "join with unshippable join clauses can not be shipped"); join_clauses = copyObject(join_clauses); other_clauses = list_concat(other_clauses, extract_actual_clauses(rqpath->join_restrictlist, true)); - other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals, false); + other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals); other_clauses = copyObject(other_clauses); /* @@ -570,10 +542,12 @@ pgxc_rqplan_adjust_tlist(RemoteQuery *rqplan) List *query_tlist; /* * Build the target list to be shipped to the datanode from the targetlist - * expected from the plan. + * expected from the plan, if the targetlist is not shippable as is. */ - base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual, - rqplan->remote_query->hasAggs); + if (!rqplan->is_shippable_tlist) + base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual); + else + base_tlist = copyObject(plan->targetlist); query_tlist = copyObject(base_tlist); /* Replace the targetlist of remote_query with the new base_tlist */ @@ -1309,24 +1283,20 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) RangeTblEntry *dummy_rte; int numGroupCols; AttrNumber *grpColIdx; + bool reduce_plan; List *remote_qual; List *local_qual; - bool single_node_grouping;/* Can grouping be entirely performed - * on a given datanode? - */ - List *remote_scan_tlist; /* Remote grouping is not enabled, don't do anything */ if (!enable_remotegroup) return local_plan; - /* - * PGXCTODO: These optimizations do not work in presence of the window functions, - * because of the target list adjustments. The targetlist set for the passed - * in Group/Agg plan nodes contains window functions if any, but gets - * changed while planning for windowing. So, for now stay away :) + * We don't push aggregation and grouping to Datanodes, in case there are + * windowing aggregates, distinct, having clause or sort clauses. */ - if (query->hasWindowFuncs) + if (query->hasWindowFuncs || + query->distinctClause || + query->sortClause) return local_plan; /* for now only Agg/Group plans */ @@ -1357,7 +1327,10 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) sort_plan = (Sort *)temp_plan; temp_plan = temp_plan->lefttree; } - + if (temp_plan && IsA(temp_plan, Result)) + temp_plan = temp_plan->lefttree; + if (temp_plan && IsA(temp_plan, Material)) + temp_plan = temp_plan->lefttree; if (temp_plan && IsA(temp_plan, RemoteQuery)) remote_scan = (RemoteQuery *)temp_plan; @@ -1399,74 +1372,44 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) } } - if (pgxc_query_has_distcolgrouping(query) || - list_length(remote_scan->exec_nodes->nodeList) == 1) - single_node_grouping = true; - /* - * If we are able to completely evaluate the aggregates on datanodes, we - * need to ask datanode/s to finalise the aggregates - */ - remote_scan->remote_query->qry_finalise_aggs = single_node_grouping; - /* - * Build the targetlist of the query plan. + * process the targetlist of the grouping plan, also construct the + * targetlist of the query to be shipped to the remote side */ - remote_scan_tlist = pgxc_process_grouping_targetlist(local_plan->targetlist, - single_node_grouping); - remote_scan_tlist = pgxc_process_having_clause(remote_scan_tlist, single_node_grouping, - query->havingQual, &local_qual, - &remote_qual); + base_tlist = pgxc_process_grouping_targetlist(root, &(local_plan->targetlist)); /* * If can not construct a targetlist shippable to the Datanode. Resort to * the plan created by grouping_planner() */ - if (!remote_scan_tlist) + if (!base_tlist) return local_plan; - /* - * Copy the quals to be included in the Query to be sent to the datanodes, - * so that the nodes (e.g. Vars) can be changed. - */ - remote_qual = copyObject(remote_qual); - /* Modify the targetlist of the JOIN plan with the new targetlist */ - remote_scan->scan.plan.targetlist = remote_scan_tlist; - /* we need to adjust the Vars in HAVING clause to be shipped */ - pgxc_rqplan_adjust_vars(remote_scan, (Node *)remote_qual); - /* Attach the local quals at appropriate plan */ - if (single_node_grouping) - remote_scan->scan.plan.qual = local_qual; - else - local_plan->qual = local_qual; - remote_scan->remote_query->havingQual = (Node *)remote_qual; + base_tlist = pgxc_process_having_clause(root, base_tlist, query->havingQual, + &local_qual, &remote_qual, &reduce_plan); + remote_qual = copyObject(remote_qual); /* - * Generate the targetlist to be shipped to the datanode, so that we can - * check whether we are able to ship the grouping clauses to the datanode/s. - * If the original query has aggregates, set the same in Query to be sent to - * the datanodes, so that we have right expectations about the aggregates - * while generating the targetlist. + * Because of HAVING clause, we can not push the aggregates and GROUP BY + * clause to the Datanode. Resort to the plan created by grouping planner. */ - remote_scan->remote_query->hasAggs = query->hasAggs; - pgxc_rqplan_adjust_tlist(remote_scan); - base_tlist = remote_scan->base_tlist; - + if (!reduce_plan) + return local_plan; + Assert(base_tlist); + /* Modify the targetlist of the JOIN plan with the new targetlist */ + remote_scan->scan.plan.targetlist = base_tlist; /* * recompute the column ids of the grouping columns, * the group column indexes computed earlier point in the - * targetlists of the scan plans under Agg/Group node. But now the grouping + * targetlists of the scan plans under this node. But now the grouping * column indexes will be pointing in the targetlist of the new * RemoteQuery, hence those need to be recomputed - * If we couldn't locate a particular GROUP BY */ - if (!pgxc_locate_grouping_columns(root, base_tlist, grpColIdx)) - return local_plan; + pgxc_locate_grouping_columns(root, base_tlist, grpColIdx); /* Add the GROUP BY clause to the JOIN query */ remote_scan->remote_query->groupClause = query->groupClause; - /* - * Add the ORDER BY clause if necessary, this ordering important, because - * rest of the plan depends upon it. - */ + remote_scan->remote_query->hasAggs = query->hasAggs; + /* Add the ORDER BY clause if necessary */ if (sort_plan) { List *sortClause = NIL; @@ -1507,31 +1450,29 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) remote_scan->remote_query->sortClause = sortClause; } + /* we need to adjust the Vars in HAVING clause to be shipped */ + pgxc_rqplan_adjust_vars(remote_scan, (Node *)remote_qual); + remote_scan->remote_query->havingQual = (Node *)remote_qual; /* - * We have added new clauses to the query being shipped to the datanode/s, - * re-build the quals. + * Ultimately modify the targetlist of the remote_query according to the new + * base_tlist and generate the SQL statement. We don't want to check again + * for shippability while adjusting the Vars. */ - pgxc_rqplan_build_statement(remote_scan); + remote_scan->is_shippable_tlist = true; + pgxc_rqplan_adjust_tlist(remote_scan); + + local_plan->lefttree = (Plan *)remote_scan; + local_plan->qual = local_qual; /* Change the dummy RTE added to show the new place of reduction */ dummy_rte = rt_fetch(remote_scan->scan.scanrelid, query->rtable); dummy_rte->relname = "__REMOTE_GROUP_QUERY__"; dummy_rte->eref = makeAlias("__REMOTE_GROUP_QUERY__", NIL); + /* indicate that we should apply collection function directly */ + if (IsA(local_plan, Agg)) + ((Agg *)local_plan)->skip_trans = true; - /* - * If we can finalise the aggregates on the datanode/s, we don't need the - * covering Agg/Group plan. - */ - if (single_node_grouping) - return (Plan *)remote_scan; - else - { - local_plan->lefttree = (Plan *)remote_scan; - /* indicate that we should apply collection function directly */ - if (IsA(local_plan, Agg)) - ((Agg *)local_plan)->skip_trans = true; - return local_plan; - } + return local_plan; } /* @@ -1542,53 +1483,70 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) * PGXCTODO: Can we reuse locate_grouping_columns() instead of writing this * function? But this function is optimized to search in the same target list. */ -static bool +static void pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, AttrNumber *groupColIdx) { int keyno = 0; ListCell *gl; - Assert(!root->parse->groupClause || groupColIdx != NULL); + /* + * No work unless grouping. + */ + if (!root->parse->groupClause) + { + Assert(groupColIdx == NULL); + return; + } + Assert(groupColIdx != NULL); foreach(gl, root->parse->groupClause) { SortGroupClause *grpcl = (SortGroupClause *) lfirst(gl); TargetEntry *te = get_sortgroupclause_tle(grpcl, tlist); if (!te) - return false; + elog(ERROR, "failed to locate grouping columns"); groupColIdx[keyno++] = te->resno; } - return true; } /* - * pgxc_add_to_flat_tlist - * Add the given node to the target list to be sent to the Datanode. This is - * similar to add_to_flat_tlist, except that it preserves the ressortgroupref - * member in TargetEntry. - * - * Note about ressortgroupref - * While constructing targetlist to be shipped to the datanode/s we try to - * accomodate the GROUP BY or ORDER BY clauses if possible. So, we need to have - * the ressortgroupref set in the query targetlist. Hence this function. We - * consider following cases to set the given ressortgroupref. - * 1. If the expression does not already exist, it is added to the list and - * given ressortgroupref is set. - * 2. If the expression already exists, and does not have ressortgroupref in the - * target entry, the given one is set. - * 3. PGXCTODO: If the expression already exists but has a different ressortgroupref set - * in the target entry, we set that in target entry to 0 to avoid conflicts. - * This would disable further optimizations but for the time being it's safe for - * correctness. + * pgxc_add_node_to_grouping_tlist + * Add the given node to the target list to be sent to the Datanode. If it's + * Aggref node, also change the passed in node to point to the Aggref node in + * the Datanode's target list */ static List * -pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr, Index ressortgroupref) +pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgroupref) { TargetEntry *remote_tle; + Oid saved_aggtype; + /* + * When we add an aggregate to the remote targetlist the aggtype of such + * Aggref node is changed to aggtrantype. Hence while searching a given + * Aggref in remote targetlist, we need to change the aggtype accordingly + * and then switch it back. + */ + if (IsA(expr, Aggref)) + { + Aggref *aggref = (Aggref *)expr; + saved_aggtype = aggref->aggtype; + aggref->aggtype = aggref->aggtrantype; + } + else + { + /* + * When we use saved_aggtype later, compiler complains that this + * variable can be used without assigning a value to it, which can not + * be a case. Still keep compiler silent + */ + saved_aggtype = InvalidOid; + } remote_tle = tlist_member(expr, remote_tlist); + if (IsA(expr, Aggref)) + ((Aggref *)expr)->aggtype = saved_aggtype; if (!remote_tle) { @@ -1612,130 +1570,164 @@ pgxc_add_to_flat_tlist(List *remote_tlist, Node *expr, Index ressortgroupref) { /* * if the expression's TLE already has a Sorting/Grouping reference, - * and caller has passed a non-zero one as well, the same expression - * is being used twice in the targetlist with different aliases. Do - * not set ressortgroupref for either of them. The callers need to - * set the ressortgroupref because they want to find the sort or - * group column references in the targetlists. If we don't set - * ressortgroupref, the optimizations will fail, which at least - * doesn't have any correctness issue. + * and caller has passed a non-zero one as well, better both of them + * be same */ - if (remote_tle->ressortgroupref != ressortgroupref); - remote_tle->ressortgroupref = 0; + Assert(remote_tle->ressortgroupref == ressortgroupref); } } + /* + * Replace the args of the local Aggref with Aggref node to be + * included in RemoteQuery node, so that set_plan_refs can convert + * the args into VAR pointing to the appropriate result in the tuple + * coming from RemoteQuery node + * PGXCTODO: should we push this change in targetlists of plans + * above? + */ + if (IsA(expr, Aggref)) + { + Aggref *local_aggref = (Aggref *)expr; + Aggref *remote_aggref = (Aggref *)remote_tle->expr; + Assert(IsA(remote_tle->expr, Aggref)); + remote_aggref->aggtype = remote_aggref->aggtrantype; + /* Is copyObject() needed here? probably yes */ + local_aggref->args = list_make1(makeTargetEntry(copyObject(remote_tle->expr), + 1, NULL, + false)); + } return remote_tlist; } /* * pgxc_process_grouping_targetlist - * The function scans the targetlist to build the targetlist of RemoteQuery - * plan. While doing so, it checks for possibility of shipping the aggregates to - * the datanodes. Either we push none or all of the aggregates and the aggregate - * expressions need to shippable. - * If aggregates can be completely evaluated on datanode/s, we don't need covering - * Agg/Group plan. RemoteQuery node replaces the covering Agg/Group node. In - * such case the targetlist passed in becomes targetlist of the RemoteQuery - * node. + * The function scans the targetlist to check if the we can push anything + * from the targetlist to the Datanode. Following rules govern the choice + * 1. Either all of the aggregates are pushed to the Datanode or none is pushed + * 2. If there are no aggregates, the targetlist is good to be shipped as is + * 3. If aggregates are involved in expressions, we push the aggregates to the + * Datanodes but not the involving expressions. + * + * The function constructs the targetlist for the query to be pushed to the + * Datanode. It modifies the local targetlist to point to the expressions in + * remote targetlist wherever necessary (e.g. aggregates) + * + * PGXCTODO: we should be careful while pushing the function expressions, it's + * better to push functions like strlen() which can be evaluated at the + * Datanode, but we should avoid pushing functions which can only be evaluated + * at Coordinator. */ static List * -pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping) +pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist) { - List *remote_tlist = NIL; + bool shippable_remote_tlist = true; + List *remote_tlist = NIL; + List *orig_local_tlist = NIL;/* Copy original local_tlist, in case it changes */ ListCell *temp; - if (single_node_grouping) + /* + * Walk through the target list and find out whether we can push the + * aggregates and grouping to Datanodes. Also while doing so, create the + * targetlist for the query to be shipped to the Datanode. Adjust the local + * targetlist accordingly. + */ + foreach(temp, *local_tlist) { - /* Check that all the aggregates in the targetlist are shippable */ - List *aggs_n_vars = pull_var_clause((Node *)local_tlist, PVC_INCLUDE_AGGREGATES, - PVC_RECURSE_PLACEHOLDERS); - ListCell *lcell; - bool tmp_has_aggs; + TargetEntry *local_tle = lfirst(temp); + Node *expr = (Node *)local_tle->expr; + bool has_aggs; - foreach (lcell, aggs_n_vars) + /* + * If the expression is not Aggref but involves aggregates (has Aggref + * nodes in the expression tree, we can not push the entire expression + * to the Datanode, but push those aggregates to the Datanode, if those + * aggregates can be evaluated at the Datanodes (if is_foreign_expr + * returns true for entire expression). To evaluate the rest of the + * expression, we need to fetch the values of VARs participating in the + * expression. But, if we include the VARs under the aggregate nodes, + * they may not be part of GROUP BY clause, thus generating an invalid + * query. Hence, is_foreign_expr() wouldn't collect VARs under the + * expression tree rooted under Aggref node. + * For example, the original query is + * SELECT sum(val) * val2 FROM tab1 GROUP BY val2; + * the query pushed to the Datanode is + * SELECT sum(val), val2 FROM tab1 GROUP BY val2; + * Notice that, if we include val in the query, it will become invalid. + * + * It's crucial that we pass TargetEntry here to detect top-level + * RowExpr which are unshippable. + */ + if (!pgxc_is_expr_shippable((Expr *)local_tle, &has_aggs)) { - Expr *av_expr = (Expr *)lfirst(lcell); - Assert(IsA(av_expr, Aggref) || IsA(av_expr, Var)); - - /* - * If the tree routed under the aggregate expression is not - * shippable, we can not ship the entire targetlist. - */ - if (IsA(av_expr, Aggref) && - !pgxc_is_expr_shippable(av_expr, &tmp_has_aggs)) - return NULL; + shippable_remote_tlist = false; + break; } - remote_tlist = copyObject(local_tlist); - } - else - { + + /* + * We are about to change the local_tlist, check if we have already + * copied original local_tlist, if not take a copy + */ + if (!orig_local_tlist && has_aggs) + orig_local_tlist = copyObject(*local_tlist); + /* - * For every expression check if it has aggregates in it, if it has - * check whether those aggregates are shippable and include the - * aggregates and Vars outside the aggregates in the RemoteQuery plan's - * targetlist. - * We can push all aggregates or none. Hence even if there is a single - * non-shippable aggregate, we can not ship any other aggregates, and - * resort to the complete aggregation and grouping on the datanode. - * If the expression does not have any aggregates, add it as it is to - * the RemoteQuery plan's targetlist + * If there are aggregates involved in the expression, whole expression + * can not be pushed to the Datanode. Pick up the aggregates and the + * VAR nodes not covered by aggregates. */ - foreach(temp, local_tlist) + if (has_aggs) { - TargetEntry *local_tle = lfirst(temp); - Node *expr = (Node *)local_tle->expr; - bool has_agg = false; - bool tmp_has_aggs; ListCell *lcell; List *aggs_n_vars; - - aggs_n_vars = pull_var_clause(expr, PVC_INCLUDE_AGGREGATES, - PVC_RECURSE_PLACEHOLDERS); - /* - * See if there are any aggregates in the current target entry and - * whether those aggregates are shippable. + * This expression is not going to be pushed as whole, thus other + * clauses won't be able to find out this TLE in the results + * obtained from Datanode. Hence can't optimize this query. + * PGXCTODO: with projection support in RemoteQuery node, this + * condition can be worked around, please check. */ - foreach (lcell, aggs_n_vars) + if (local_tle->ressortgroupref > 0) { - Expr *av_expr = (Expr *)lfirst(lcell); - Assert(IsA(av_expr, Aggref) || IsA(av_expr, Var)); - - /* - * If the tree rooted under the aggregate expression is not - * shippable, we can not ship the entire targetlist. - */ - if (IsA(av_expr, Aggref)) - { - has_agg = true; - if (!pgxc_is_expr_shippable(av_expr, &tmp_has_aggs)) - return NULL; - } + shippable_remote_tlist = false; + break; } - /* - * If there are aggregates in the target list or if the expression - * is not shippable in itself, we should just project the aggregates - * and Vars outside the aggregates to upper nodes, since rest of - * the expression needs to be evaluated after we have finalised the - * aggregates. - */ - if (has_agg || !pgxc_is_expr_shippable((Expr *)local_tle, NULL)) - { - /* - * It's fine to use add_to_flat_tlist here, since broken down - * targetlist entry can not have ressortgroupref set. - */ - remote_tlist = add_to_flat_tlist(remote_tlist, aggs_n_vars); - } - else + aggs_n_vars = pull_var_clause(expr, PVC_INCLUDE_AGGREGATES, + PVC_RECURSE_PLACEHOLDERS); + /* copy the aggregates into the remote target list */ + foreach (lcell, aggs_n_vars) { - TargetEntry *remote_tle = copyObject(local_tle); - remote_tle->resno = list_length(remote_tlist) + 1; - remote_tlist = lappend(remote_tlist, remote_tle); + Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var)); + remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell), + 0); } } + /* Expression doesn't contain any aggregate */ + else + remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, expr, + local_tle->ressortgroupref); } + + if (!shippable_remote_tlist) + { + /* + * If local_tlist has changed but we didn't find anything shippable to + * Datanode, we need to restore the local_tlist to original state, + */ + if (orig_local_tlist) + *local_tlist = orig_local_tlist; + if (remote_tlist) + list_free_deep(remote_tlist); + remote_tlist = NIL; + } + else if (orig_local_tlist) + { + /* + * If we have changed the targetlist passed, we need to pass back the + * changed targetlist. Free the copy that has been created. + */ + list_free_deep(orig_local_tlist); + } + return remote_tlist; } @@ -1749,17 +1741,18 @@ pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping) * 2. If the expression does not have aggregates and the whole expression can be * evaluated at the Datanode, add the expression to the remote qual to be * evaluated at the Datanode. - * 3. If qual contains an aggregate which can not be evaluated at the data + * 3. If qual contains an expression which can not be evaluated at the data * node, the parent group plan can not be reduced to a remote_query. */ static List * -pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping, - Node *havingQual, List **local_qual, - List **remote_qual) +pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQual, + List **local_qual, List **remote_qual, + bool *reduce_plan) { + List *qual; ListCell *temp; - List *quals; + *reduce_plan = true; *remote_qual = NIL; *local_qual = NIL; @@ -1770,29 +1763,28 @@ pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping, * possibility that the quals will be another form? */ if (!IsA(havingQual, List)) - return NULL; - - quals = (List *)havingQual; - foreach(temp, quals) + { + *reduce_plan = false; + return remote_tlist; + } + /* + * Copy the havingQual so that the copy can be modified later. In case we + * back out in between, the original expression remains intact. + */ + qual = copyObject(havingQual); + foreach(temp, qual) { Node *expr = lfirst(temp); bool has_aggs; List *vars_n_aggs; - bool shippable_qual; - shippable_qual = pgxc_is_expr_shippable((Expr *)expr, &has_aggs); + if (!pgxc_is_expr_shippable((Expr *)expr, &has_aggs)) + { + *reduce_plan = false; + break; + } - /* - * If the expression is not shippable OR - * if there are aggregates involved in the expression, whole expression - * can not be pushed to the Datanode if grouping involves more than one - * datanode. Pick up the aggregates and the VAR nodes not covered by - * aggreagetes. - * We can push all aggregates or none. Hence even if there is a single - * non-shippable aggregate, we can not ship any other aggregates, and - * resort to the complete aggregation and grouping on the datanode. - */ - if (!shippable_qual || (!single_node_grouping && has_aggs)) + if (has_aggs) { ListCell *lcell; @@ -1802,30 +1794,19 @@ pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping, /* copy the aggregates into the remote target list */ foreach (lcell, vars_n_aggs) { - Node *agg_or_var = lfirst(lcell); - bool tmp_has_agg; - - Assert(IsA(agg_or_var, Aggref) || IsA(agg_or_var, Var)); - if (IsA(agg_or_var, Aggref) && - !pgxc_is_expr_shippable((Expr *)agg_or_var, &tmp_has_agg)) - return NULL; - - /* - * If the aggregation can not be evaluated on a single, we will - * need a covering Agg/Group plan, where the aggregates will be - * finalised and quals will be applied. In that case, the - * targetlist of the RemoteQuery plan needs to have the - * transitioned aggregates to be projected to Agg/Group plan. - */ - if (!single_node_grouping) - remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, - agg_or_var, 0); + Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var)); + remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell), + 0); } *local_qual = lappend(*local_qual, expr); } else *remote_qual = lappend(*remote_qual, expr); } + + if (!(*reduce_plan)) + list_free_deep(qual); + return remote_tlist; } diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index d20364e37f..81243dbc50 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -26,7 +26,6 @@ #include "utils/lsyscache.h" #include "utils/syscache.h" #ifdef PGXC -#include "pgxc/pgxc.h" #include "optimizer/pgxcplan.h" #endif @@ -152,7 +151,6 @@ static List * fix_remote_expr(PlannerInfo *root, static Node *fix_remote_expr_mutator(Node *node, fix_remote_expr_context *context); static void set_remote_references(PlannerInfo *root, RemoteQuery *rscan, int rtoffset); -static void pgxc_set_agg_references(PlannerInfo *root, Agg *aggplan); #endif @@ -552,11 +550,6 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset) } break; case T_Agg: -#ifdef PGXC - /* If the lower plan is RemoteQuery plan, adjust the aggregates */ - pgxc_set_agg_references(root, (Agg *)plan); - /* Fall through */ -#endif /* PGXC */ case T_Group: set_upper_references(root, plan, rtoffset); break; @@ -2116,94 +2109,3 @@ set_remote_references(PlannerInfo *root, RemoteQuery *rscan, int rtoffset) pfree(base_itlist); } - -#ifdef PGXC -/* - * For Agg plans, if the lower scan plan is a RemoteQuery node, adjust the - * Aggref nodes to pull the transition results from the datanodes. We do while - * setting planner references so that the upper nodes will find the nodes that - * they expect in Agg plans. - */ -void -pgxc_set_agg_references(PlannerInfo *root, Agg *aggplan) -{ - RemoteQuery *rqplan = (RemoteQuery *)aggplan->plan.lefttree; - List *aggs_n_vars; - ListCell *lcell; - List *nodes_to_modify; - List *rq_nodes_to_modify; - - - /* Nothing to do if the lower plan is not RemoteQuery */ - if (!IsA(rqplan, RemoteQuery)) - return; - - Assert(IS_PGXC_COORDINATOR && !IsConnFromCoord()); - /* - * If there are not transition results expected from lower plans, nothing to - * be done here. - */ - if (!aggplan->skip_trans) - return; - - /* Gather all the aggregates that need fixing */ - nodes_to_modify = list_copy(aggplan->plan.targetlist); - nodes_to_modify = list_concat(nodes_to_modify, aggplan->plan.qual); - aggs_n_vars = pull_var_clause((Node *)nodes_to_modify, PVC_INCLUDE_AGGREGATES, - PVC_RECURSE_PLACEHOLDERS); - rq_nodes_to_modify = NIL; - /* - * For every aggregate, find corresponding aggregate in the lower plan and - * modify it correctly. - */ - foreach (lcell, aggs_n_vars) - { - Aggref *aggref = lfirst(lcell); - TargetEntry *tle; - Aggref *rq_aggref; - - if (!IsA(aggref, Aggref)) - { - Assert(IsA(aggref, Var)); - continue; - } - - tle = tlist_member((Node *)aggref, rqplan->scan.plan.targetlist); - - if (!tle) - elog(ERROR, "Could not find the Aggref node"); - - rq_aggref = (Aggref *)tle->expr; - Assert(equal(rq_aggref, aggref)); - - /* - * Remember the Aggref nodes of which we need to modify. This is done so - * that, if there multiple copies of same aggregate, we will match all - * of them - */ - rq_nodes_to_modify = list_append_unique(rq_nodes_to_modify, rq_aggref); - /* - * The transition result from the datanodes acts as an input to the - * Aggref node on coordinator. - */ - aggref->args = list_make1(makeTargetEntry((Expr *)rq_aggref, 1, NULL, - false)); - } - - /* Modify the transition types now */ - foreach (lcell, rq_nodes_to_modify) - { - Aggref *rq_aggref = lfirst(lcell); - Assert(IsA(rq_aggref, Aggref)); - rq_aggref->aggtype = rq_aggref->aggtrantype; - } - - /* - * We have modified the targetlist of the RemoteQuery plan below the Agg - * plan. Adjust its targetlist as well. - */ - pgxc_rqplan_adjust_tlist(rqplan); - - return; -} -#endif /* PGXC */ diff --git a/src/backend/optimizer/util/pgxcship.c b/src/backend/optimizer/util/pgxcship.c index 4f8fc65c81..44937bafaf 100644 --- a/src/backend/optimizer/util/pgxcship.c +++ b/src/backend/optimizer/util/pgxcship.c @@ -113,8 +113,10 @@ static void pgxc_FQS_find_datanodes(Shippability_context *sc_context); static bool pgxc_query_needs_coord(Query *query); static bool pgxc_query_contains_only_pg_catalog(List *rtable); static bool pgxc_is_var_distrib_column(Var *var, List *rtable); +static bool pgxc_query_has_distcolgrouping(Query *query); static bool pgxc_distinct_has_distcol(Query *query); + /* * Set the given reason in Shippability_context indicating why the query can not be * shipped directly to remote nodes. @@ -478,7 +480,7 @@ pgxc_FQS_get_relation_nodes(RangeTblEntry *rte, Index varno, Query *query) return rel_exec_nodes; } -bool +static bool pgxc_query_has_distcolgrouping(Query *query) { ListCell *lcell; @@ -737,14 +739,6 @@ pgxc_shippability_walker(Node *node, Shippability_context *sc_context) if (!pgxc_is_func_shippable(funcexpr->funcid)) pgxc_set_shippability_reason(sc_context, SS_UNSHIPPABLE_EXPR); - /* - * If this is a stand alone expression and the function returns a - * set of rows, we need to handle it along with the final result of - * other expressions. So, it can not be shippable. - */ - if (funcexpr->funcretset && sc_context->sc_for_expr) - pgxc_set_shippability_reason(sc_context, SS_UNSHIPPABLE_EXPR); - pgxc_set_exprtype_shippability(exprType(node), sc_context); } break; @@ -1222,17 +1216,9 @@ pgxc_is_query_shippable(Query *query, int query_level) /* * pgxc_is_expr_shippable - * Check whether the given expression can be shipped to datanodes. - * - * Note on has_aggs - * The aggregate expressions are not shippable if they can not be completely - * evaluated on a single datanode. But this function does not have enough - * context to determine the set of datanodes where the expression will be - * evaluated. Hence, the caller of this function can handle aggregate - * expressions, it passes a non-NULL value for has_aggs. This function returns - * whether the expression has any aggregates or not through this argument. If a - * caller passes NULL value for has_aggs, this function assumes that the caller - * can not handle the aggregates and deems the expression has unshippable. + * Check whether the given expression can be shipped to remote nodes. + * This can be used as an entry point to check the shippability of + * an expression. */ bool pgxc_is_expr_shippable(Expr *node, bool *has_aggs) diff --git a/src/include/optimizer/pgxcplan.h b/src/include/optimizer/pgxcplan.h index 5abb40ec96..2d9620630c 100644 --- a/src/include/optimizer/pgxcplan.h +++ b/src/include/optimizer/pgxcplan.h @@ -112,6 +112,7 @@ typedef struct */ List *coord_var_tlist; List *query_var_tlist; + bool is_shippable_tlist; bool has_row_marks; /* Did SELECT had FOR UPDATE/SHARE? */ bool has_ins_child_sel_parent; /* This node is part of an INSERT SELECT that * inserts into child by selecting from its parent */ diff --git a/src/include/optimizer/pgxcship.h b/src/include/optimizer/pgxcship.h index a14a08d74e..0f960e1a5a 100644 --- a/src/include/optimizer/pgxcship.h +++ b/src/include/optimizer/pgxcship.h @@ -33,6 +33,5 @@ extern bool pgxc_qual_has_dist_equijoin(Relids varnos_1, /* Merge given execution nodes based on join shippability conditions */ extern ExecNodes *pgxc_merge_exec_nodes(ExecNodes *en1, ExecNodes *en2, bool merge_dist_equijoin, bool merge_replicated_only); -extern bool pgxc_query_has_distcolgrouping(Query *query); #endif diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out index 8f9e32c948..b35a78e55c 100644 --- a/src/test/regress/expected/aggregates.out +++ b/src/test/regress/expected/aggregates.out @@ -309,8 +309,6 @@ from tenk1 o; -- -- test for bitwise integer aggregates -- --- Enforce use of COMMIT instead of 2PC for temporary objects -SET enforce_two_phase_commit TO off; CREATE TEMPORARY TABLE bitwise_test( i2 INT2, i4 INT4, @@ -579,11 +577,11 @@ order by f1; -- check some cases that were handled incorrectly in 8.3.0 explain (costs off, nodes off) select distinct max(unique2) from tenk1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ HashAggregate -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (3 rows) select distinct max(unique2) from tenk1; @@ -594,12 +592,12 @@ select distinct max(unique2) from tenk1; explain (costs off, nodes off) select max(unique2) from tenk1 order by 1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: (max((max(tenk1.unique2)))) + Sort Key: (max(tenk1.unique2)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by 1; @@ -610,12 +608,12 @@ select max(unique2) from tenk1 order by 1; explain (costs off, nodes off) select max(unique2) from tenk1 order by max(unique2); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: (max((max(tenk1.unique2)))) + Sort Key: (max(tenk1.unique2)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by max(unique2); @@ -626,12 +624,12 @@ select max(unique2) from tenk1 order by max(unique2); explain (costs off, nodes off) select max(unique2) from tenk1 order by max(unique2)+1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: ((max((max(tenk1.unique2))) + 1)) + Sort Key: ((max(tenk1.unique2) + 1)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by max(unique2)+1; @@ -642,12 +640,12 @@ select max(unique2) from tenk1 order by max(unique2)+1; explain (costs off, nodes off) select max(unique2), generate_series(1,3) as g from tenk1 order by g desc; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort Sort Key: (generate_series(1, 3)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2), generate_series(1,3) as g from tenk1 order by g desc; diff --git a/src/test/regress/expected/aggregates_1.out b/src/test/regress/expected/aggregates_1.out index d8c6e862b6..db22e478e9 100644 --- a/src/test/regress/expected/aggregates_1.out +++ b/src/test/regress/expected/aggregates_1.out @@ -579,11 +579,11 @@ order by f1; -- check some cases that were handled incorrectly in 8.3.0 explain (costs off, nodes off) select distinct max(unique2) from tenk1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ HashAggregate -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (3 rows) select distinct max(unique2) from tenk1; @@ -594,12 +594,12 @@ select distinct max(unique2) from tenk1; explain (costs off, nodes off) select max(unique2) from tenk1 order by 1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: (max((max(tenk1.unique2)))) + Sort Key: (max(tenk1.unique2)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by 1; @@ -610,12 +610,12 @@ select max(unique2) from tenk1 order by 1; explain (costs off, nodes off) select max(unique2) from tenk1 order by max(unique2); - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: (max((max(tenk1.unique2)))) + Sort Key: (max(tenk1.unique2)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by max(unique2); @@ -626,12 +626,12 @@ select max(unique2) from tenk1 order by max(unique2); explain (costs off, nodes off) select max(unique2) from tenk1 order by max(unique2)+1; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort - Sort Key: ((max((max(tenk1.unique2))) + 1)) + Sort Key: ((max(tenk1.unique2) + 1)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2) from tenk1 order by max(unique2)+1; @@ -642,12 +642,12 @@ select max(unique2) from tenk1 order by max(unique2)+1; explain (costs off, nodes off) select max(unique2), generate_series(1,3) as g from tenk1 order by g desc; - QUERY PLAN --------------------------------------------------------- + QUERY PLAN +------------------------------------------------------------ Sort Sort Key: (generate_series(1, 3)) -> Aggregate - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" (4 rows) select max(unique2), generate_series(1,3) as g from tenk1 order by g desc; diff --git a/src/test/regress/expected/xc_FQS.out b/src/test/regress/expected/xc_FQS.out index a988866e31..a90ba10273 100644 --- a/src/test/regress/expected/xc_FQS.out +++ b/src/test/regress/expected/xc_FQS.out @@ -516,14 +516,14 @@ select distinct on (val2) val, val2 from tab1_hash where val2 = 8; 7 | 8 (1 row) -explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8; - QUERY PLAN ------------------------------------------------------------------------------ +explain (costs off, verbose on, nodes off) select distinct (val2) val, val2 from tab1_hash where val2 = 8; + QUERY PLAN +------------------------------------------------------------------------ Unique - Output: tab1_hash.val, tab1_hash.val2 + Output: tab1_hash.val2, tab1_hash.val2 -> Data Node Scan on tab1_hash "_REMOTE_TABLE_QUERY_" - Output: tab1_hash.val, tab1_hash.val2 - Remote query: SELECT val, val2 FROM ONLY tab1_hash WHERE (val2 = 8) + Output: tab1_hash.val2, tab1_hash.val2 + Remote query: SELECT val2 FROM ONLY tab1_hash WHERE (val2 = 8) (5 rows) -- should not get FQSed because of presence of aggregates and HAVING clause diff --git a/src/test/regress/expected/xc_groupby.out b/src/test/regress/expected/xc_groupby.out index 36127d1e0e..f2122c1cea 100644 --- a/src/test/regress/expected/xc_groupby.out +++ b/src/test/regress/expected/xc_groupby.out @@ -13,7 +13,7 @@ create table xc_groupby_tab1 (val int, val2 int); create table xc_groupby_tab2 (val int, val2 int); insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; +select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -21,18 +21,21 @@ 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 true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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 - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 - Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(5 rows) +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort + 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 + Sort Key: xc_groupby_tab1.val2 + -> 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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(8 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 gt1_val2, xc_groupby_tab2.val2 gt2_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 order by gt1_val2, gt2_val2; +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_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) q order by q.gt1_val2, q.gt2_val2; count | sum | avg | ?column? | gt1_val2 | gt2_val2 -------+-----+---------------------+------------------+----------+---------- 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -41,16 +44,16 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_ 3 | | | | | 4 (4 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_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 order by gt1_val2, gt2_val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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 - Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val - Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_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) q order by q.gt1_val2, q.gt2_val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort + 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 Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> 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 - Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val + Output: xc_groupby_tab1.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2, xc_groupby_tab2.val Hash Cond: (xc_groupby_tab1.val2 = xc_groupby_tab2.val2) -> Data Node Scan on xc_groupby_tab1 "_REMOTE_TABLE_QUERY_" Output: xc_groupby_tab1.val2, xc_groupby_tab1.val @@ -88,7 +91,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( (12 rows) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; +select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2; val2 ------ 1 @@ -96,17 +99,20 @@ select val2 from xc_groupby_tab1 group by val2 order by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------- - Group +explain (verbose true, costs false, nodes false) select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2; + QUERY PLAN +-------------------------------------------------------------------------------------------- + Sort Output: xc_groupby_tab1.val2 - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Sort Key: xc_groupby_tab1.val2 + -> HashAggregate Output: xc_groupby_tab1.val2 - Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(5 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_tab1.val2 + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(8 rows) -select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; +select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1; ?column? ---------- 2 @@ -117,17 +123,20 @@ select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; 9 (6 rows) -explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------- - Group +explain (verbose true, costs false, nodes false) select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1; + QUERY PLAN +------------------------------------------------------------------------------------------------------------ + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> HashAggregate Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) -(5 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) +(8 rows) -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -140,15 +149,20 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 -(3 rows) + Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 +(8 rows) -select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_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 order by gt1_val, gt2_val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2; ?column? | gt1_val | gt2_val2 ----------+---------+---------- 2 | 1 | 1 @@ -159,15 +173,20 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, 6 | 4 | 2 (6 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_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 order by gt1_val, gt2_val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) + Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 +(8 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 order by 1; +select * from (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) q order by 1; ?column? ---------- 2 @@ -176,18 +195,21 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group 7 (4 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by 1; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Group +explain (verbose true, costs false, nodes false) select * from (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) q order by 1; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> HashAggregate Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1) -(5 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) +(8 rows) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -195,18 +217,21 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order 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 - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 - Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(5 rows) +explain (verbose true, costs false, nodes false) select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort + 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 + Sort Key: xc_groupby_tab1.val2 + -> 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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(8 rows) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr; +select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr; sum | avg | expr -----+--------------------+------ 6 | 2.0000000000000000 | 2 @@ -214,15 +239,18 @@ select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 11 | 3.6666666666666667 | 6 (3 rows) -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr; - 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)) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) - Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2) -(5 rows) +explain (verbose true, costs false, nodes false) select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------- + Sort + Output: (pg_catalog.sum((sum(xc_groupby_tab1.val)))), (pg_catalog.avg((avg(xc_groupby_tab1.val)))), ((2 * xc_groupby_tab1.val2)) + Sort Key: ((2 * xc_groupby_tab1.val2)) + -> HashAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) + Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) +(8 rows) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -241,7 +269,7 @@ insert into xc_groupby_def VALUES (7, NULL); insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -250,17 +278,20 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; 4.0000000000000000 | 8 | 3 | (4 rows) -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------ - GroupAggregate - Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b - Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(5 rows) +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------- + Sort + Output: (pg_catalog.avg((avg(xc_groupby_def.a)))), (pg_catalog.sum((sum(xc_groupby_def.a)))), (pg_catalog.count(*)), xc_groupby_def.b + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b + Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) -select b from xc_groupby_def group by b order by b; +select * from (select b from xc_groupby_def group by b) q order by q.b; b ------- One @@ -269,17 +300,20 @@ select b from xc_groupby_def group by b order by b; (4 rows) -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Group +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +------------------------------------------------------------------------------------- + Sort Output: xc_groupby_def.b - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Sort Key: xc_groupby_def.b + -> HashAggregate Output: xc_groupby_def.b - Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(5 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) -select b,count(b) from xc_groupby_def group by b order by b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; b | count -------+------- One | 1 @@ -288,15 +322,18 @@ select b,count(b) from xc_groupby_def group by b order by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; - QUERY PLAN ----------------------------------------------------------------------------------------------------- - GroupAggregate - Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: xc_groupby_def.b, (count(xc_groupby_def.b)) - Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(5 rows) +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------------------------------------- + Sort + Output: xc_groupby_def.b, (count((count(xc_groupby_def.b)))) + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b, (count(xc_groupby_def.b)) + Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -318,104 +355,106 @@ create table xc_groupby_g(a int, b float, c numeric); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; +select sum(a) from xc_groupby_g group by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.a)), xc_groupby_g.a - Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.a)), xc_groupby_g.a + Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a +(5 rows) -select sum(b) from xc_groupby_g group by b order by b; +select sum(b) from xc_groupby_g group by b; sum ----- - 4.2 2.3 + 4.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (sum(xc_groupby_g.b)), xc_groupby_g.b - Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b + Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b (5 rows) -select sum(c) from xc_groupby_g group by b order by b; +select sum(c) from xc_groupby_g group by b; sum ----- - 6.4 5.2 + 6.4 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (sum(xc_groupby_g.c)), xc_groupby_g.b - Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b + Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b (5 rows) -select avg(a) from xc_groupby_g group by b order by b; +select avg(a) from xc_groupby_g group by b; avg ------------------------ - 1.00000000000000000000 2.0000000000000000 + 1.00000000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (avg(xc_groupby_g.a)), xc_groupby_g.b - Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b + Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b (5 rows) -select avg(b) from xc_groupby_g group by c order by c; +select avg(b) from xc_groupby_g group by c; avg ----- - 2.1 2.3 + 2.1 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (avg(xc_groupby_g.b)), xc_groupby_g.c - Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c + Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c (5 rows) -select avg(c) from xc_groupby_g group by c order by c; +select avg(c) from xc_groupby_g group by c; avg -------------------- - 3.2000000000000000 5.2000000000000000 + 3.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (avg(xc_groupby_g.c)), xc_groupby_g.c - Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c + Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c (5 rows) drop table xc_groupby_def; @@ -427,7 +466,7 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication; create table xc_groupby_tab2 (val int, val2 int) distribute by replication; insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -435,16 +474,18 @@ 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 true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), (((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(5 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 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2; +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; count | sum | avg | ?column? | c1 | c2 -------+-----+---------------------+------------------+----+---- 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -453,37 +494,46 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_ 3 | | | | | 4 (4 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), (((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 - Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort + Output: (pg_catalog.count(*)), (pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val))))), (pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val))))), (((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Sort Key: xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> HashAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 +(8 rows) -- aggregates over aggregates -select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum; +select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; sum ----- 8 17 (2 rows) -explain (verbose true, costs false, nodes false) select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------- +explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------ Sort - Output: (sum((sum(xc_groupby_tab1.val)))), ((xc_groupby_tab1.val2 % 2)) - Sort Key: (sum((sum(xc_groupby_tab1.val)))) - -> HashAggregate - Output: sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 - Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 -(8 rows) + Output: q.sum + Sort Key: q.sum + -> Subquery Scan on q + Output: q.sum + -> HashAggregate + Output: sum((pg_catalog.sum((sum(xc_groupby_tab1.val))))), ((xc_groupby_tab1.val2 % 2)) + -> HashAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 + Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(12 rows) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; +select val2 from xc_groupby_tab1 group by val2; val2 ------ 1 @@ -491,15 +541,17 @@ select val2 from xc_groupby_tab1 group by val2 order by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +-------------------------------------------------------------------------------------- + HashAggregate Output: xc_groupby_tab1.val2 - Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_tab1.val2 + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(5 rows) -select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; +select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; sum ----- 2 @@ -510,15 +562,20 @@ select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; 9 (6 rows) -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; + QUERY PLAN +------------------------------------------------------------------------------------------------------------ + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) -(3 rows) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) +(8 rows) -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -531,15 +588,20 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 -(3 rows) + Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 +(8 rows) -select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -550,15 +612,20 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group 6 | 4 | 2 (6 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) + Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 +(8 rows) -select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; sum ----- 2 @@ -567,16 +634,21 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_g 7 (4 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Sort Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1) -(3 rows) + Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> HashAggregate + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) +(8 rows) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -584,33 +656,34 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------------- - Sort - Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2 - Sort Key: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))) +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 -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2 - Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 -(6 rows) + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 +(5 rows) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; sum | avg | ?column? -----+--------------------+---------- + 11 | 3.6666666666666667 | 6 6 | 2.0000000000000000 | 2 8 | 4.0000000000000000 | 4 - 11 | 3.6666666666666667 | 6 (3 rows) -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) - Remote query: SELECT sum(val), pg_catalog.int8_avg(avg(val)), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2) -(3 rows) +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) + Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) +(5 rows) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -629,7 +702,7 @@ insert into xc_groupby_def VALUES (7, NULL); insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -638,15 +711,20 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; 4.0000000000000000 | 8 | 3 | (4 rows) -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b - Remote query: SELECT pg_catalog.int8_avg(avg(a)), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------- + Sort + Output: (pg_catalog.avg((avg(xc_groupby_def.a)))), (pg_catalog.sum((sum(xc_groupby_def.a)))), (pg_catalog.count(*)), xc_groupby_def.b + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b + Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) -select b from xc_groupby_def group by b order by b; +select * from (select b from xc_groupby_def group by b) q order by q.b; b ------- One @@ -655,15 +733,20 @@ select b from xc_groupby_def group by b order by b; (4 rows) -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +------------------------------------------------------------------------------------- + Sort Output: xc_groupby_def.b - Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) -select b,count(b) from xc_groupby_def group by b order by b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; b | count -------+------- One | 1 @@ -672,13 +755,18 @@ select b,count(b) from xc_groupby_def group by b order by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; - QUERY PLAN ----------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: xc_groupby_def.b, (count(xc_groupby_def.b)) - Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; + QUERY PLAN +----------------------------------------------------------------------------------------------- + Sort + Output: xc_groupby_def.b, (count((count(xc_groupby_def.b)))) + Sort Key: xc_groupby_def.b + -> HashAggregate + Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b, (count(xc_groupby_def.b)) + Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b +(8 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -687,106 +775,120 @@ select count(*) from xc_groupby_def where b is null group by b; (1 row) explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), xc_groupby_def.b - Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b -(3 rows) + QUERY PLAN +------------------------------------------------------------------------------------------------ + HashAggregate + Output: pg_catalog.count(*), xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), xc_groupby_def.b + Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b +(5 rows) create table xc_groupby_g(a int, b float, c numeric) distribute by replication; insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; +select sum(a) from xc_groupby_g group by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.a)), xc_groupby_g.a - Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.a)), xc_groupby_g.a + Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a +(5 rows) -select sum(b) from xc_groupby_g group by b order by b; +select sum(b) from xc_groupby_g group by b; sum ----- - 4.2 2.3 + 4.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.b)), xc_groupby_g.b - Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.b)), xc_groupby_g.b + Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b +(5 rows) -select sum(c) from xc_groupby_g group by b order by b; +select sum(c) from xc_groupby_g group by b; sum ----- - 6.4 5.2 + 6.4 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.c)), xc_groupby_g.b - Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.c)), xc_groupby_g.b + Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b +(5 rows) -select avg(a) from xc_groupby_g group by b order by b; +select avg(a) from xc_groupby_g group by b; avg ------------------------ - 1.00000000000000000000 2.0000000000000000 + 1.00000000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.a)), xc_groupby_g.b - Remote query: SELECT pg_catalog.int8_avg(avg(a)), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.a))), xc_groupby_g.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.a)), xc_groupby_g.b + Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b +(5 rows) -select avg(b) from xc_groupby_g group by c order by c; +select avg(b) from xc_groupby_g group by c; avg ----- - 2.1 2.3 + 2.1 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.b)), xc_groupby_g.c - Remote query: SELECT pg_catalog.float8_avg(avg(b)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c -(3 rows) +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.b))), xc_groupby_g.c + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.b)), xc_groupby_g.c + Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c +(5 rows) -select avg(c) from xc_groupby_g group by c order by c; +select avg(c) from xc_groupby_g group by c; avg -------------------- - 3.2000000000000000 5.2000000000000000 + 3.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.c)), xc_groupby_g.c - Remote query: SELECT pg_catalog.numeric_avg(avg(c)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c -(3 rows) +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.c))), xc_groupby_g.c + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.c)), xc_groupby_g.c + Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c +(5 rows) drop table xc_groupby_def; drop table xc_groupby_g; @@ -873,7 +975,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( (12 rows) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; +select val2 from xc_groupby_tab1 group by val2; val2 ------ 1 @@ -881,7 +983,7 @@ select val2 from xc_groupby_tab1 group by val2 order by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; QUERY PLAN ---------------------------------------------------------------------------------------------------- Group @@ -926,12 +1028,14 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; (8 rows) explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------- + Group Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(5 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 @@ -945,12 +1049,14 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group (6 rows) explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Group Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 +(5 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? @@ -972,7 +1078,7 @@ explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc (5 rows) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -980,7 +1086,7 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------- GroupAggregate @@ -991,7 +1097,7 @@ explain (verbose true, costs false, nodes false) select count(*) + sum(val) + av (5 rows) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; sum | avg | ?column? -----+--------------------+---------- 6 | 2.0000000000000000 | 2 @@ -999,7 +1105,7 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order 11 | 3.6666666666666667 | 6 (3 rows) -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order 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; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------ GroupAggregate @@ -1026,7 +1132,7 @@ insert into xc_groupby_def VALUES (7, NULL); insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -1035,7 +1141,7 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; 4.0000000000000000 | 8 | 3 | (4 rows) -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------- GroupAggregate @@ -1045,7 +1151,7 @@ explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*) Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b (5 rows) -select b from xc_groupby_def group by b order by b; +select b from xc_groupby_def group by b; b ------- One @@ -1054,7 +1160,7 @@ select b from xc_groupby_def group by b order by b; (4 rows) -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; QUERY PLAN ------------------------------------------------------------------------------------------ Group @@ -1064,7 +1170,7 @@ explain (verbose true, costs false, nodes false) select b from xc_groupby_def gr Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b (5 rows) -select b,count(b) from xc_groupby_def group by b order by b; +select b,count(b) from xc_groupby_def group by b; b | count -------+------- One | 1 @@ -1073,7 +1179,7 @@ select b,count(b) from xc_groupby_def group by b order by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; QUERY PLAN ---------------------------------------------------------------------------------------------------- GroupAggregate @@ -1103,29 +1209,31 @@ create table xc_groupby_g(a int, b float, c numeric); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; +select sum(a) from xc_groupby_g group by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.a)), xc_groupby_g.a - Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.a)), xc_groupby_g.a + Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a +(5 rows) -select sum(b) from xc_groupby_g group by b order by b; +select sum(b) from xc_groupby_g group by b; sum ----- 4.2 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1135,14 +1243,14 @@ explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b (5 rows) -select sum(c) from xc_groupby_g group by b order by b; +select sum(c) from xc_groupby_g group by b; sum ----- 6.4 5.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1152,14 +1260,14 @@ explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b (5 rows) -select avg(a) from xc_groupby_g group by b order by b; +select avg(a) from xc_groupby_g group by b; avg ------------------------ 1.00000000000000000000 2.0000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1169,14 +1277,14 @@ explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b (5 rows) -select avg(b) from xc_groupby_g group by c order by c; +select avg(b) from xc_groupby_g group by c; avg ----- 2.1 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1186,14 +1294,14 @@ explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c (5 rows) -select avg(c) from xc_groupby_g group by c order by c; +select avg(c) from xc_groupby_g group by c; avg -------------------- 3.2000000000000000 5.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1212,7 +1320,7 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication; create table xc_groupby_tab2 (val int, val2 int) distribute by replication; insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -1220,16 +1328,18 @@ 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 true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), (((sum(xc_groupby_tab1.val))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(5 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 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; count | sum | avg | ?column? | val2 | val2 -------+-----+---------------------+------------------+------+------ 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -1238,25 +1348,27 @@ select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_ 3 | | | | | 4 (4 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), (((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))::double precision / (count(*))::double precision)), xc_groupby_tab1.val2, xc_groupby_tab2.val2 - Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))), pg_catalog.avg((avg((xc_groupby_tab1.val * xc_groupby_tab2.val)))), ((pg_catalog.sum((sum((xc_groupby_tab1.val * xc_groupby_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum((xc_groupby_tab1.val * xc_groupby_tab2.val))), (avg((xc_groupby_tab1.val * xc_groupby_tab2.val))), xc_groupby_tab1.val2, xc_groupby_tab2.val2 + Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val2, xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1, a_2) FULL JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON ((l.a_1 = r.a_1))) WHERE true GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 +(5 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 order by x; +select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; sum ----- 8 17 (2 rows) -explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by x; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------------- +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 @@ -1264,13 +1376,15 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( Sort Key: q1.x -> Subquery Scan on q1 Output: q1.x, q1.y - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 - Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(10 rows) + -> GroupAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_tab1.val)), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 + Remote query: SELECT sum(val), (val2 % 2), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(12 rows) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; +select val2 from xc_groupby_tab1 group by val2; val2 ------ 1 @@ -1278,15 +1392,17 @@ select val2 from xc_groupby_tab1 group by val2 order by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +---------------------------------------------------------------------------------------------------- + Group Output: xc_groupby_tab1.val2 - Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_tab1.val2 + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(5 rows) -select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; +select val + val2 from xc_groupby_tab1 group by val + val2; ?column? ---------- 2 @@ -1297,15 +1413,17 @@ select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; 9 (6 rows) -explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +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)) - Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) +(5 rows) -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -1318,15 +1436,17 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by va 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +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 - Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(5 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 order by xc_groupby_tab1.val, xc_groupby_tab2.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; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -1337,15 +1457,17 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_group 6 | 4 | 2 (6 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2 order by xc_groupby_tab1.val, xc_groupby_tab2.val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +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 - Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 + Remote query: SELECT (l.a_1 + r.a_1), l.a_1, r.a_1 FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 +(5 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 order 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; ?column? ---------- 2 @@ -1354,16 +1476,18 @@ select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_group 7 (4 rows) -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by xc_groupby_tab1.val + xc_groupby_tab2.val2; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +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)) - Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1) -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) + Remote query: SELECT (l.a_1 + r.a_1) FROM ((SELECT xc_groupby_tab1.val FROM ONLY xc_groupby_tab1 WHERE true) l(a_1) JOIN (SELECT xc_groupby_tab2.val2, xc_groupby_tab2.val FROM ONLY xc_groupby_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (l.a_1 = r.a_2) GROUP BY (l.a_1 + r.a_1) ORDER BY (l.a_1 + r.a_1) +(5 rows) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -1371,16 +1495,18 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 o 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: ((((count(*) + sum(xc_groupby_tab1.val)))::numeric + avg(xc_groupby_tab1.val))), xc_groupby_tab1.val2 - Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(xc_groupby_tab1.val)))))::numeric + pg_catalog.avg((avg(xc_groupby_tab1.val)))), xc_groupby_tab1.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), xc_groupby_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(5 rows) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; sum | avg | ?column? -----+--------------------+---------- 6 | 2.0000000000000000 | 2 @@ -1388,13 +1514,15 @@ select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order 11 | 3.6666666666666667 | 6 (3 rows) -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) - Remote query: SELECT sum(val), pg_catalog.int8_avg(avg(val)), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2) -(3 rows) +explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------ + GroupAggregate + Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), pg_catalog.avg((avg(xc_groupby_tab1.val))), ((2 * xc_groupby_tab1.val2)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_tab1.val)), (avg(xc_groupby_tab1.val)), ((2 * xc_groupby_tab1.val2)) + Remote query: SELECT sum(val), avg(val), (2 * val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (2 * val2) ORDER BY (2 * val2) +(5 rows) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -1413,7 +1541,7 @@ insert into xc_groupby_def VALUES (7, NULL); insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -1422,15 +1550,17 @@ select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; 4.0000000000000000 | 8 | 3 | (4 rows) -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b - Remote query: SELECT pg_catalog.int8_avg(avg(a)), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) + GroupAggregate + Output: pg_catalog.avg((avg(xc_groupby_def.a))), pg_catalog.sum((sum(xc_groupby_def.a))), pg_catalog.count(*), xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_def.a)), (sum(xc_groupby_def.a)), (count(*)), xc_groupby_def.b + Remote query: SELECT avg(a), sum(a), count(*), b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(5 rows) -select b from xc_groupby_def group by b order by b; +select b from xc_groupby_def group by b; b ------- One @@ -1439,15 +1569,17 @@ select b from xc_groupby_def group by b order by b; (4 rows) -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; + QUERY PLAN +------------------------------------------------------------------------------------------ + Group Output: xc_groupby_def.b - Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(5 rows) -select b,count(b) from xc_groupby_def group by b order by b; +select b,count(b) from xc_groupby_def group by b; b | count -------+------- One | 1 @@ -1456,13 +1588,15 @@ select b,count(b) from xc_groupby_def group by b order by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; - QUERY PLAN ----------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: xc_groupby_def.b, (count(xc_groupby_def.b)) - Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b -(3 rows) +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))) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_groupby_def.b, (count(xc_groupby_def.b)) + Remote query: SELECT b, count(b) FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(5 rows) select count(*) from xc_groupby_def where b is null group by b; count @@ -1471,106 +1605,120 @@ select count(*) from xc_groupby_def where b is null group by b; (1 row) explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; - QUERY PLAN ------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), xc_groupby_def.b - Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b ORDER BY b -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), xc_groupby_def.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), xc_groupby_def.b + Remote query: SELECT count(*), b FROM ONLY xc_groupby_def WHERE (b IS NULL) GROUP BY b ORDER BY b +(5 rows) create table xc_groupby_g(a int, b float, c numeric) distribute by replication; insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; +select sum(a) from xc_groupby_g group by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.a)), xc_groupby_g.a - Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.a)), xc_groupby_g.a + Remote query: SELECT sum(a), a FROM ONLY xc_groupby_g WHERE true GROUP BY a ORDER BY a +(5 rows) -select sum(b) from xc_groupby_g group by b order by b; +select sum(b) from xc_groupby_g group by b; sum ----- 4.2 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.b)), xc_groupby_g.b - Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.b)), xc_groupby_g.b + Remote query: SELECT sum(b), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b +(5 rows) -select sum(c) from xc_groupby_g group by b order by b; +select sum(c) from xc_groupby_g group by b; sum ----- 6.4 5.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (sum(xc_groupby_g.c)), xc_groupby_g.b - Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (sum(xc_groupby_g.c)), xc_groupby_g.b + Remote query: SELECT sum(c), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b +(5 rows) -select avg(a) from xc_groupby_g group by b order by b; +select avg(a) from xc_groupby_g group by b; avg ------------------------ 1.00000000000000000000 2.0000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.a)), xc_groupby_g.b - Remote query: SELECT pg_catalog.int8_avg(avg(a)), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b -(3 rows) +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; + QUERY PLAN +------------------------------------------------------------------------------------------------ + GroupAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.a))), xc_groupby_g.b + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.a)), xc_groupby_g.b + Remote query: SELECT avg(a), b FROM ONLY xc_groupby_g WHERE true GROUP BY b ORDER BY b +(5 rows) -select avg(b) from xc_groupby_g group by c order by c; +select avg(b) from xc_groupby_g group by c; avg ----- 2.1 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.b)), xc_groupby_g.c - Remote query: SELECT pg_catalog.float8_avg(avg(b)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c -(3 rows) +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------------------------------------ + GroupAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.b))), xc_groupby_g.c + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.b)), xc_groupby_g.c + Remote query: SELECT avg(b), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c +(5 rows) -select avg(c) from xc_groupby_g group by c order by c; +select avg(c) from xc_groupby_g group by c; avg -------------------- 3.2000000000000000 5.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (avg(xc_groupby_g.c)), xc_groupby_g.c - Remote query: SELECT pg_catalog.numeric_avg(avg(c)), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c -(3 rows) +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; + QUERY PLAN +------------------------------------------------------------------------------------------------ + GroupAggregate + Output: pg_catalog.avg((avg(xc_groupby_g.c))), xc_groupby_g.c + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (avg(xc_groupby_g.c)), xc_groupby_g.c + Remote query: SELECT avg(c), c FROM ONLY xc_groupby_g WHERE true GROUP BY c ORDER BY c +(5 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 d5bbdaafa1..8ff190a121 100644 --- a/src/test/regress/expected/xc_having.out +++ b/src/test/regress/expected/xc_having.out @@ -48,22 +48,22 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 (6 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 order by val2; +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 -------+-----+--------------------+------------------+------ 2 | 8 | 4.0000000000000000 | 4 | 2 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 (2 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2; +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 + 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)) -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 (6 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; @@ -126,7 +126,7 @@ explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 (6 rows) -select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; +select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; sum ----- 4 @@ -134,16 +134,19 @@ select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 9 (3 rows) -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------- - GroupAggregate +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) - -> Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val)) - Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) -(6 rows) + Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) + -> HashAggregate + Output: ((xc_having_tab1.val + xc_having_tab1.val2)) + Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val)) + Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) +(9 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; @@ -180,12 +183,14 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 +(5 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; @@ -195,27 +200,33 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 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) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 +(6 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 order by val2; +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 -------+-----+--------------------+------------------+------ 2 | 8 | 4.0000000000000000 | 4 | 2 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 (2 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING ((pg_catalog.int8_avg(avg(val)) > 3.75) OR (val2 > 2)) ORDER BY val2 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(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)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 +(6 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 @@ -225,10 +236,13 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav 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 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) -(3 rows) + 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) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 +(6 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; @@ -238,12 +252,14 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab (1 row) 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 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - 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 - Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 -(3 rows) + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + HashAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), xc_having_tab1.val2, xc_having_tab2.val2 + Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 +(5 rows) -- group by and having, without aggregate in the target list select val2 from xc_having_tab1 group by val2 having sum(val) > 8; @@ -253,14 +269,17 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8; (1 row) explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; - QUERY PLAN ------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" + QUERY PLAN +----------------------------------------------------------------------------------------------- + HashAggregate Output: xc_having_tab1.val2 - Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) -(3 rows) + Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_having_tab1.val2, (sum(xc_having_tab1.val)) + Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 +(6 rows) -select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; +select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; sum ----- 4 @@ -268,13 +287,19 @@ select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 9 (3 rows) -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------- + Sort Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Remote query: SELECT (val + val2) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) HAVING (sum(val) > 5) ORDER BY (val + val2) -(3 rows) + Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) + -> HashAggregate + Output: ((xc_having_tab1.val + xc_having_tab1.val2)) + Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val)) + Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) +(9 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; @@ -284,12 +309,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: ((((count(*) + sum(xc_having_tab1.val)))::numeric + avg(xc_having_tab1.val))), xc_having_tab1.val2 - Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (min(val) < val2) -(3 rows) + 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) + -> 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)) + Remote query: SELECT count(*), sum(val), avg(val), val2, min(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 +(6 rows) drop table xc_having_tab1; drop table xc_having_tab2; @@ -335,14 +363,14 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 (6 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 order by val2; +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 -------+-----+--------------------+------------------+------ 2 | 8 | 4.0000000000000000 | 4 | 2 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 (2 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2; +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 @@ -470,12 +498,14 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 ORDER BY val2 -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 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 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE ((val2 + 1) > 3) GROUP BY val2 ORDER BY val2 +(5 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; @@ -485,27 +515,33 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) ORDER BY val2 -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 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) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(6 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 order by val2; +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 -------+-----+--------------------+------------------+------ 2 | 8 | 4.0000000000000000 | 4 | 2 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 (2 rows) -explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2 order by val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING ((pg_catalog.int8_avg(avg(val)) > 3.75) OR (val2 > 2)) ORDER BY val2 -(3 rows) +explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 or val2 > 2; + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum(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)) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(6 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 @@ -513,12 +549,15 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (0 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), (((sum(xc_having_tab1.val))::double precision / (count(*))::double precision)), xc_having_tab1.val2 - Remote query: SELECT count(*), sum(val), pg_catalog.int8_avg(avg(val)), ((sum(val))::double precision / (count(*))::double precision), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 HAVING (pg_catalog.int8_avg(avg(val)) > 3.75) ORDER BY val2 -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + 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) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum(xc_having_tab1.val)), (avg(xc_having_tab1.val)), xc_having_tab1.val2 + Remote query: SELECT count(*), sum(val), avg(val), val2 FROM ONLY xc_having_tab1 WHERE (val2 > 2) GROUP BY val2 ORDER BY val2 +(6 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; @@ -528,12 +567,14 @@ select count(*), sum(xc_having_tab1.val * xc_having_tab2.val), avg(xc_having_tab (1 row) 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 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - Data Node Scan on "__REMOTE_GROUP_QUERY__" - 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 - Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), pg_catalog.int8_avg(avg((l.a_2 * r.a_2))), ((sum((l.a_2 * r.a_2)))::double precision / (count(*))::double precision), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 -(3 rows) + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate + Output: pg_catalog.count(*), pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))), pg_catalog.avg((avg((xc_having_tab1.val * xc_having_tab2.val)))), ((pg_catalog.sum((sum((xc_having_tab1.val * xc_having_tab2.val)))))::double precision / (pg_catalog.count(*))::double precision), xc_having_tab1.val2, xc_having_tab2.val2 + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: (count(*)), (sum((xc_having_tab1.val * xc_having_tab2.val))), (avg((xc_having_tab1.val * xc_having_tab2.val))), xc_having_tab1.val2, xc_having_tab2.val2 + Remote query: SELECT count(*), sum((l.a_2 * r.a_2)), avg((l.a_2 * r.a_2)), l.a_1, r.a_1 FROM ((SELECT xc_having_tab1.val2, xc_having_tab1.val FROM ONLY xc_having_tab1 WHERE true) l(a_1, a_2) JOIN (SELECT xc_having_tab2.val2, xc_having_tab2.val FROM ONLY xc_having_tab2 WHERE true) r(a_1, a_2) ON (true)) WHERE (((l.a_1 + r.a_1) > 2) AND (l.a_1 = r.a_1)) GROUP BY l.a_1, r.a_1 ORDER BY l.a_1, r.a_1 +(5 rows) -- group by and having, without aggregate in the target list select val2 from xc_having_tab1 group by val2 having sum(val) > 8; @@ -543,12 +584,15 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8; (1 row) explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" + QUERY PLAN +------------------------------------------------------------------------------------------------------------- + GroupAggregate Output: xc_having_tab1.val2 - Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) ORDER BY val2 -(3 rows) + Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 8) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: xc_having_tab1.val2, (sum(xc_having_tab1.val)) + Remote query: SELECT val2, sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(6 rows) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; ?column? @@ -559,12 +603,15 @@ select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; (3 rows) explain (verbose true, costs false, nodes false) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------- + GroupAggregate Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Remote query: SELECT (val + val2) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) HAVING (sum(val) > 5) ORDER BY (val + val2) -(3 rows) + Filter: (pg_catalog.sum((sum(xc_having_tab1.val))) > 5) + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" + Output: ((xc_having_tab1.val + xc_having_tab1.val2)), (sum(xc_having_tab1.val)) + Remote query: SELECT (val + val2), sum(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) +(6 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; @@ -574,12 +621,15 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Data Node Scan on "__REMOTE_GROUP_QUERY__" - Output: ((((count(*) + sum(xc_having_tab1.val)))::numeric + avg(xc_having_tab1.val))), xc_having_tab1.val2 - Remote query: SELECT (((count(*) + sum(val)))::numeric + pg_catalog.int8_avg(avg(val))), val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (min(val) < val2) ORDER BY val2 -(3 rows) + 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) + -> 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)) + Remote query: SELECT count(*), sum(val), avg(val), val2, min(val) FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(6 rows) drop table xc_having_tab1; drop table xc_having_tab2; diff --git a/src/test/regress/sql/xc_FQS.sql b/src/test/regress/sql/xc_FQS.sql index c348cabda1..ee879d93f9 100644 --- a/src/test/regress/sql/xc_FQS.sql +++ b/src/test/regress/sql/xc_FQS.sql @@ -106,7 +106,7 @@ select val, val2 from tab1_hash where val2 = 8 group by val, val2; explain (costs off, verbose on, nodes off) select val, val2 from tab1_hash where val2 = 8 group by val, val2; -- should not get FQSed because of DISTINCT clause select distinct on (val2) val, val2 from tab1_hash where val2 = 8; -explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8; +explain (costs off, verbose on, nodes off) select distinct (val2) val, val2 from tab1_hash where val2 = 8; -- should not get FQSed because of presence of aggregates and HAVING clause -- withour distribution column in GROUP BY clause select sum(val) from tab1_hash where val2 = 2 group by val2 having sum(val) > 1; diff --git a/src/test/regress/sql/xc_groupby.sql b/src/test/regress/sql/xc_groupby.sql index 8ef010dfc5..602c643258 100644 --- a/src/test/regress/sql/xc_groupby.sql +++ b/src/test/regress/sql/xc_groupby.sql @@ -15,31 +15,31 @@ create table xc_groupby_tab1 (val int, val2 int); create table xc_groupby_tab2 (val int, val2 int); insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order 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 order by val2; +select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2; +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.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 gt1_val2, xc_groupby_tab2.val2 gt2_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 order by gt1_val2, gt2_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 gt1_val2, xc_groupby_tab2.val2 gt2_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 order by gt1_val2, gt2_val2; +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_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) q order by q.gt1_val2, q.gt2_val2; +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 gt1_val2, xc_groupby_tab2.val2 gt2_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) q order by q.gt1_val2, q.gt2_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 order 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 order by x; -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; -select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; -explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; -select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_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 order by gt1_val, gt2_val2; -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_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 order by gt1_val, gt2_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 order by 1; -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 order by 1; +select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2; +explain (verbose true, costs false, nodes false) select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2; +select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1; +explain (verbose true, costs false, nodes false) select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1; +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2; +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val gt1_val, xc_groupby_tab2.val2 gt2_val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.gt1_val, q.gt2_val2; +select * from (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) q order by 1; +explain (verbose true, costs false, nodes false) select * from (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) q order by 1; -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2; +explain (verbose true, costs false, nodes false) select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2; -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr; -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr; +select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr; +explain (verbose true, costs false, nodes false) select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr; drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -59,12 +59,13 @@ insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; -select b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; -select b,count(b) from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; + +select * from (select b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; select count(*) from xc_groupby_def where b is null group by b; explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; @@ -73,19 +74,19 @@ insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; -select sum(b) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; -select sum(c) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; -select avg(a) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; -select avg(b) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; -select avg(c) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; drop table xc_groupby_def; drop table xc_groupby_g; @@ -97,31 +98,31 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication; create table xc_groupby_tab2 (val int, val2 int) distribute by replication; insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order 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 order by val2; +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 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2; -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 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2 order by c1, c2; +select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; +explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; -- aggregates over aggregates -select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum; -explain (verbose true, costs false, nodes false) select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x order by sum; +select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2 order by val2; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; -select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order 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 order by val, 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 order by val, val2; -select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum; -explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2 order by sum; +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; +select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; +select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1; +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 order 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 order by 2 * val2; +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; @@ -141,13 +142,13 @@ insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; -select b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; -select b,count(b) from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; +select * from (select b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; +select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; select count(*) from xc_groupby_def where b is null group by b; explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; @@ -156,19 +157,19 @@ insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; -select sum(b) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; -select sum(c) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; -select avg(a) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; -select avg(b) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; -select avg(c) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; drop table xc_groupby_def; drop table xc_groupby_g; @@ -190,8 +191,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby 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 order by val2; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; select val + val2 from xc_groupby_tab1 group by val + val2; explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; @@ -201,11 +202,11 @@ explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc 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 order by val2; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +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 order 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 order by 2 * val2; +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; @@ -225,13 +226,13 @@ insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; -select b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; -select b,count(b) from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; +select b from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; +select b,count(b) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; select count(*) from xc_groupby_def where b is null group by b; explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; @@ -240,19 +241,19 @@ insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; -select sum(b) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; -select sum(c) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; -select avg(a) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; -select avg(b) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; -select avg(c) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; drop table xc_groupby_def; drop table xc_groupby_g; @@ -264,31 +265,31 @@ create table xc_groupby_tab1 (val int, val2 int) distribute by replication; create table xc_groupby_tab2 (val int, val2 int) distribute by replication; insert into xc_groupby_tab1 values (1, 1), (2, 1), (3, 1), (2, 2), (6, 2), (4, 3), (1, 3), (6, 3); insert into xc_groupby_tab2 values (1, 1), (4, 1), (8, 1), (2, 4), (9, 4), (3, 4), (4, 2), (5, 2), (3, 2); -select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order 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 order by val2; +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 order 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 order by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +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 order 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 order by x; +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 order by val2; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; -select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; -explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order 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 order 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 order 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 order 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 order by xc_groupby_tab1.val + xc_groupby_tab2.val2; +select val2 from xc_groupby_tab1 group by val2; +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +select val + val2 from xc_groupby_tab1 group by val + val2; +explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2; +select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; +explain (verbose true, costs false, nodes false) select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2; -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; +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 order 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 order by 2 * val2; +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; @@ -308,13 +309,13 @@ insert into xc_groupby_def VALUES (8, 'Two'); insert into xc_groupby_def VALUES (9, 'Three'); insert into xc_groupby_def VALUES (10, 'Three'); -select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; +select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +explain (verbose true, costs false, nodes false) select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; -select b from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; -select b,count(b) from xc_groupby_def group by b order by b; -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b order by b; +select b from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; +select b,count(b) from xc_groupby_def group by b; +explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; select count(*) from xc_groupby_def where b is null group by b; explain (verbose true, costs false, nodes false) select count(*) from xc_groupby_def where b is null group by b; @@ -323,19 +324,19 @@ insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(1,2.1,3.2); insert into xc_groupby_g values(2,2.3,5.2); -select sum(a) from xc_groupby_g group by a order by a; -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a order by a; -select sum(b) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; -select sum(c) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; - -select avg(a) from xc_groupby_g group by b order by b; -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; -select avg(b) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; -select avg(c) from xc_groupby_g group by c order by c; -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; +select sum(a) from xc_groupby_g group by a; +explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; +select sum(b) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; + +select avg(a) from xc_groupby_g group by b; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; +select avg(b) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; drop table xc_groupby_def; drop table xc_groupby_g; diff --git a/src/test/regress/sql/xc_having.sql b/src/test/regress/sql/xc_having.sql index 41dc79b2da..061ca3ae1c 100644 --- a/src/test/regress/sql/xc_having.sql +++ b/src/test/regress/sql/xc_having.sql @@ -21,8 +21,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -- 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 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 order by val2; -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 order by val2; +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 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 @@ -31,8 +31,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_ -- 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 true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; -select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; +select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; -- 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 true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -52,8 +52,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -- 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 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 order by val2; -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 order by val2; +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 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 @@ -62,8 +62,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(xc_having_ -- 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 true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; -select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; -explain (verbose true, costs false, nodes false) select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; +select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; +explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; -- 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 true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -83,8 +83,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -- 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 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 order by val2; -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 order by val2; +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 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 @@ -114,8 +114,8 @@ explain (verbose true, costs false, nodes false) select count(*), sum(val), avg( -- 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 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 order by val2; -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 order by val2; +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 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 |