diff options
author | Michael Paquier | 2012-10-16 08:21:57 +0000 |
---|---|---|
committer | Michael Paquier | 2012-10-16 08:21:57 +0000 |
commit | 9ce38d3bf64c17155a0ca283c56987b7ecd9e218 (patch) | |
tree | 4344b21b1f54eb86b22710283ce86adc427ba5d2 | |
parent | 945f83fc5d5b2ef1d51438a7dd48dd9532c9d936 (diff) |
GROUP BY clause pushdown optimization with distribution data and aggregates
This patch is a lightly modified version of 66c17a5 reverted by 6c6ba3c once
some errors have been noticed regarding aggregate pushdown, like:
SELECT count(*) FROM tab;
where the query was completely pushed down and returned multiple row results
to client (1 per Datanode).
Patch and subsequent fix from Ashutosh Bapat, I just did some testing.
-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 | 570 | ||||
-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 | 2 | ||||
-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, 1227 insertions, 1287 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index 9db6c2b46a..dd4d5b288f 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -1038,7 +1038,6 @@ _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 8e858316fe..533b88f150 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -487,7 +487,6 @@ _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 fa70a7a02e..db4fce53e4 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 void pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, +static bool pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, AttrNumber *grpColIdx); -static List *pgxc_process_grouping_targetlist(PlannerInfo *root, - List **local_tlist); -static List *pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, +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, Node *havingQual, List **local_qual, - List **remote_qual, bool *reduce_plan); + List **remote_qual); 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); +static List *pgxc_separate_quals(List *quals, List **local_quals, bool has_aggs); static Query *pgxc_build_shippable_query_recurse(PlannerInfo *root, RemoteQueryPath *rqpath, List **unshippable_quals, @@ -75,6 +75,10 @@ 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); /* @@ -83,17 +87,23 @@ 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) +pgxc_separate_quals(List *quals, List **unshippabl_quals, bool has_aggs) { 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, NULL)) + if (pgxc_is_expr_shippable(clause, tmp_bool_ptr)) shippabl_quals = lappend(shippabl_quals, clause); else *unshippabl_quals = lappend(*unshippabl_quals, clause); @@ -114,11 +124,15 @@ pgxc_separate_quals(List *quals, List **unshippabl_quals) * those in the target list for the datanode. */ static List * -pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals) +pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals, bool has_aggs) { - ListCell *lcell; - List *remote_tlist = NIL; - List *tmp_rtlist = NIL; + 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; /* * Add all the shippable members as they are to the target list being built, @@ -126,8 +140,15 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals) */ foreach(lcell, tlist) { - TargetEntry *tle = lfirst(lcell); - Expr *expr; + 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; if (!IsA(tle, TargetEntry)) elog(ERROR, "Expected TargetEntry node, but got node with type %d", @@ -138,22 +159,29 @@ pgxc_build_shippable_tlist(List *tlist, List *unshippabl_quals) * pgxc_is_expr_shippable(). Helps in detecting top level RowExpr, which * are unshippable */ - if (pgxc_is_expr_shippable((Expr *)tle, NULL)) - tmp_rtlist = lappend(tmp_rtlist, expr); + if (pgxc_is_expr_shippable((Expr *)tle, tmp_ptr)) + remote_tlist = pgxc_add_to_flat_tlist(remote_tlist, (Node *)expr, + tle->ressortgroupref); else - tmp_rtlist = list_concat(tmp_rtlist, pull_var_clause((Node *)expr, - PVC_REJECT_AGGREGATES, - PVC_RECURSE_PLACEHOLDERS)); + unshippable_expr = lappend(unshippable_expr, expr); } - remote_tlist = add_to_flat_tlist(remote_tlist, tmp_rtlist); /* - * The passed in quals are already checked for shippability, so just add the - * vars from those clauses to the targetlist being built. + * Now collect the aggregates (if needed) and Vars from the unshippable + * expressions (from targetlist and unshippable quals and add them to + * remote targetlist. */ - remote_tlist = add_to_flat_tlist(remote_tlist, pull_var_clause((Node *)unshippabl_quals, - PVC_RECURSE_AGGREGATES, - PVC_RECURSE_PLACEHOLDERS)); + 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); + } return remote_tlist; } @@ -200,7 +228,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); + shippable_quals = pgxc_separate_quals(scan_clauses, unshippable_quals, false); shippable_quals = copyObject(shippable_quals); /* @@ -362,13 +390,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, false)) + if (!pgxc_is_expr_shippable((Expr *)join_clauses, NULL)) 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); + other_clauses = pgxc_separate_quals(other_clauses, unshippable_quals, false); other_clauses = copyObject(other_clauses); /* @@ -542,12 +570,10 @@ 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, if the targetlist is not shippable as is. + * expected from the plan. */ - if (!rqplan->is_shippable_tlist) - base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual); - else - base_tlist = copyObject(plan->targetlist); + base_tlist = pgxc_build_shippable_tlist(plan->targetlist, plan->qual, + rqplan->remote_query->hasAggs); query_tlist = copyObject(base_tlist); /* Replace the targetlist of remote_query with the new base_tlist */ @@ -1283,20 +1309,24 @@ 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; + /* - * We don't push aggregation and grouping to Datanodes, in case there are - * windowing aggregates, distinct, having clause or sort clauses. + * 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 :) */ - if (query->hasWindowFuncs || - query->distinctClause || - query->sortClause) + if (query->hasWindowFuncs) return local_plan; /* for now only Agg/Group plans */ @@ -1327,10 +1357,7 @@ 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; @@ -1373,43 +1400,80 @@ create_remotegrouping_plan(PlannerInfo *root, Plan *local_plan) } /* - * process the targetlist of the grouping plan, also construct the - * targetlist of the query to be shipped to the remote side + * If group by clause has distribution column in it or if there is only one + * datanode involved, the evaluation of aggregates and grouping involves + * only a single datanode. */ - base_tlist = pgxc_process_grouping_targetlist(root, &(local_plan->targetlist)); + if (pgxc_query_has_distcolgrouping(query) || + list_length(remote_scan->exec_nodes->nodeList) == 1) + single_node_grouping = true; + else + single_node_grouping = false; + /* + * 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. + */ + 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); /* * If can not construct a targetlist shippable to the Datanode. Resort to * the plan created by grouping_planner() */ - if (!base_tlist) + if (!remote_scan_tlist) return local_plan; - - base_tlist = pgxc_process_having_clause(root, base_tlist, query->havingQual, - &local_qual, &remote_qual, &reduce_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; /* - * 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. + * 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. */ - if (!reduce_plan) - return local_plan; - Assert(base_tlist); + remote_scan->remote_query->hasAggs = query->hasAggs; + pgxc_rqplan_adjust_tlist(remote_scan); + base_tlist = remote_scan->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 this node. But now the grouping + * targetlists of the scan plans under Agg/Group 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 */ - pgxc_locate_grouping_columns(root, base_tlist, grpColIdx); + if (!pgxc_locate_grouping_columns(root, base_tlist, grpColIdx)) + return local_plan; /* Add the GROUP BY clause to the JOIN query */ remote_scan->remote_query->groupClause = query->groupClause; - remote_scan->remote_query->hasAggs = query->hasAggs; - /* Add the ORDER BY clause if necessary */ + /* + * Add the ORDER BY clause if necessary, this ordering important, because + * rest of the plan depends upon it. + */ if (sort_plan) { List *sortClause = NIL; @@ -1450,29 +1514,31 @@ 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; /* - * 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. + * We have added new clauses to the query being shipped to the datanode/s, + * re-build the quals. */ - remote_scan->is_shippable_tlist = true; - pgxc_rqplan_adjust_tlist(remote_scan); - - local_plan->lefttree = (Plan *)remote_scan; - local_plan->qual = local_qual; + pgxc_rqplan_build_statement(remote_scan); /* 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; - return local_plan; + /* + * 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; + } } /* @@ -1483,70 +1549,53 @@ 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 void +static bool pgxc_locate_grouping_columns(PlannerInfo *root, List *tlist, AttrNumber *groupColIdx) { int keyno = 0; ListCell *gl; - /* - * No work unless grouping. - */ - if (!root->parse->groupClause) - { - Assert(groupColIdx == NULL); - return; - } - Assert(groupColIdx != NULL); + Assert(!root->parse->groupClause || groupColIdx != NULL); foreach(gl, root->parse->groupClause) { SortGroupClause *grpcl = (SortGroupClause *) lfirst(gl); TargetEntry *te = get_sortgroupclause_tle(grpcl, tlist); if (!te) - elog(ERROR, "failed to locate grouping columns"); + return false; groupColIdx[keyno++] = te->resno; } + return true; } /* - * 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 + * 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. */ static List * -pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgroupref) +pgxc_add_to_flat_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) { @@ -1570,164 +1619,130 @@ pgxc_add_node_to_grouping_tlist(List *remote_tlist, Node *expr, Index ressortgro { /* * if the expression's TLE already has a Sorting/Grouping reference, - * and caller has passed a non-zero one as well, better both of them - * be same + * 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. */ - Assert(remote_tle->ressortgroupref == ressortgroupref); + if (remote_tle->ressortgroupref != ressortgroupref); + remote_tle->ressortgroupref = 0; } } - /* - * 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 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. + * 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. */ static List * -pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist) +pgxc_process_grouping_targetlist(List *local_tlist, bool single_node_grouping) { - bool shippable_remote_tlist = true; - List *remote_tlist = NIL; - List *orig_local_tlist = NIL;/* Copy original local_tlist, in case it changes */ + List *remote_tlist = NIL; ListCell *temp; - /* - * 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) + if (single_node_grouping) { - TargetEntry *local_tle = lfirst(temp); - Node *expr = (Node *)local_tle->expr; - bool has_aggs; + /* 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; - /* - * 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)) + foreach (lcell, aggs_n_vars) { - shippable_remote_tlist = false; - break; - } - - /* - * 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); + 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; + } + remote_tlist = copyObject(local_tlist); + } + else + { /* - * 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. + * 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 (has_aggs) + foreach(temp, local_tlist) { + 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); + /* - * 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. + * See if there are any aggregates in the current target entry and + * whether those aggregates are shippable. */ - if (local_tle->ressortgroupref > 0) + foreach (lcell, aggs_n_vars) { - shippable_remote_tlist = false; - break; + 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; + } } - 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) + /* + * 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)) { - Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var)); - remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell), - 0); + /* + * 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 + { + TargetEntry *remote_tle = copyObject(local_tle); + remote_tle->resno = list_length(remote_tlist) + 1; + remote_tlist = lappend(remote_tlist, remote_tle); } } - /* 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; } @@ -1741,18 +1756,17 @@ pgxc_process_grouping_targetlist(PlannerInfo *root, List **local_tlist) * 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 expression which can not be evaluated at the data + * 3. If qual contains an aggregate 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(PlannerInfo *root, List *remote_tlist, Node *havingQual, - List **local_qual, List **remote_qual, - bool *reduce_plan) +pgxc_process_having_clause(List *remote_tlist, bool single_node_grouping, + Node *havingQual, List **local_qual, + List **remote_qual) { - List *qual; ListCell *temp; + List *quals; - *reduce_plan = true; *remote_qual = NIL; *local_qual = NIL; @@ -1763,28 +1777,29 @@ pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQu * possibility that the quals will be another form? */ if (!IsA(havingQual, List)) - { - *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) + return NULL; + + quals = (List *)havingQual; + foreach(temp, quals) { Node *expr = lfirst(temp); bool has_aggs; List *vars_n_aggs; + bool shippable_qual; - if (!pgxc_is_expr_shippable((Expr *)expr, &has_aggs)) - { - *reduce_plan = false; - break; - } + shippable_qual = pgxc_is_expr_shippable((Expr *)expr, &has_aggs); - if (has_aggs) + /* + * 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)) { ListCell *lcell; @@ -1794,19 +1809,30 @@ pgxc_process_having_clause(PlannerInfo *root, List *remote_tlist, Node *havingQu /* copy the aggregates into the remote target list */ foreach (lcell, vars_n_aggs) { - Assert(IsA(lfirst(lcell), Aggref) || IsA(lfirst(lcell), Var)); - remote_tlist = pgxc_add_node_to_grouping_tlist(remote_tlist, lfirst(lcell), - 0); + 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); } *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 81243dbc50..d20364e37f 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -26,6 +26,7 @@ #include "utils/lsyscache.h" #include "utils/syscache.h" #ifdef PGXC +#include "pgxc/pgxc.h" #include "optimizer/pgxcplan.h" #endif @@ -151,6 +152,7 @@ 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 @@ -550,6 +552,11 @@ 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; @@ -2109,3 +2116,94 @@ 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 e76124c3ae..2b5b6966c6 100644 --- a/src/backend/optimizer/util/pgxcship.c +++ b/src/backend/optimizer/util/pgxcship.c @@ -114,10 +114,8 @@ 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. @@ -481,7 +479,7 @@ pgxc_FQS_get_relation_nodes(RangeTblEntry *rte, Index varno, Query *query) return rel_exec_nodes; } -static bool +bool pgxc_query_has_distcolgrouping(Query *query) { ListCell *lcell; @@ -740,6 +738,14 @@ 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; @@ -1224,9 +1230,17 @@ pgxc_is_query_shippable(Query *query, int query_level) /* * pgxc_is_expr_shippable - * 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. + * 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. */ 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 2d9620630c..5abb40ec96 100644 --- a/src/include/optimizer/pgxcplan.h +++ b/src/include/optimizer/pgxcplan.h @@ -112,7 +112,6 @@ 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 e9e0ccbd42..7317617751 100644 --- a/src/include/optimizer/pgxcship.h +++ b/src/include/optimizer/pgxcship.h @@ -33,6 +33,8 @@ 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); +/* Check if given Query includes distribution column */ +extern bool pgxc_query_has_distcolgrouping(Query *query); /* Check the shippability of an index */ extern bool pgxc_check_index_shippability(RelationLocInfo *relLocInfo, bool is_primary, diff --git a/src/test/regress/expected/aggregates.out b/src/test/regress/expected/aggregates.out index b35a78e55c..8f9e32c948 100644 --- a/src/test/regress/expected/aggregates.out +++ b/src/test/regress/expected/aggregates.out @@ -309,6 +309,8 @@ 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, @@ -577,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 tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (3 rows) select distinct max(unique2) from tenk1; @@ -592,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(tenk1.unique2)) + Sort Key: (max((max(tenk1.unique2)))) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (4 rows) select max(unique2) from tenk1 order by 1; @@ -608,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(tenk1.unique2)) + Sort Key: (max((max(tenk1.unique2)))) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (4 rows) select max(unique2) from tenk1 order by max(unique2); @@ -624,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(tenk1.unique2) + 1)) + Sort Key: ((max((max(tenk1.unique2))) + 1)) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" (4 rows) select max(unique2) from tenk1 order by max(unique2)+1; @@ -640,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 tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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 db22e478e9..d8c6e862b6 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 tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2)) + Sort Key: (max((max(tenk1.unique2)))) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2)) + Sort Key: (max((max(tenk1.unique2)))) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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(tenk1.unique2) + 1)) + Sort Key: ((max((max(tenk1.unique2))) + 1)) -> Aggregate - -> Data Node Scan on tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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 tenk1 "_REMOTE_TABLE_QUERY_" + -> Data Node Scan on "__REMOTE_GROUP_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 a90ba10273..a988866e31 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 (val2) val, val2 from tab1_hash where val2 = 8; - QUERY PLAN ------------------------------------------------------------------------- +explain (costs off, verbose on, nodes off) select distinct on (val2) val, val2 from tab1_hash where val2 = 8; + QUERY PLAN +----------------------------------------------------------------------------- Unique - Output: tab1_hash.val2, tab1_hash.val2 + Output: tab1_hash.val, tab1_hash.val2 -> Data Node Scan on tab1_hash "_REMOTE_TABLE_QUERY_" - Output: tab1_hash.val2, tab1_hash.val2 - Remote query: SELECT val2 FROM ONLY tab1_hash WHERE (val2 = 8) + Output: tab1_hash.val, tab1_hash.val2 + Remote query: SELECT val, 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 f2122c1cea..36127d1e0e 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 * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2) q order by q.val2; +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -21,21 +21,18 @@ select * from (select count(*), sum(val), avg(val), sum(val)::float8/count(*), v 3 | 11 | 3.6666666666666667 | 3.66666666666667 | 3 (3 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) +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) -- joins and group by -select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 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; +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; count | sum | avg | ?column? | gt1_val2 | gt2_val2 -------+-----+---------------------+------------------+----------+---------- 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -44,16 +41,16 @@ select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), 3 | | | | | 4 (4 rows) -explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 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 +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 -> Hash Full Join - Output: xc_groupby_tab1.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2, xc_groupby_tab2.val + Output: xc_groupby_tab1.val2, xc_groupby_tab2.val2, xc_groupby_tab1.val, 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 @@ -91,7 +88,7 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( (12 rows) -- group by without aggregate -select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2; +select val2 from xc_groupby_tab1 group by val2 order by val2; val2 ------ 1 @@ -99,20 +96,17 @@ select * from (select val2 from xc_groupby_tab1 group by val2) q order by q.val2 3 (3 rows) -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 +explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2 order by val2; + QUERY PLAN +---------------------------------------------------------------------------------------------------- + Group Output: xc_groupby_tab1.val2 - Sort Key: xc_groupby_tab1.val2 - -> HashAggregate + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: xc_groupby_tab1.val2 - -> 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) + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(5 rows) -select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q order by 1; +select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; ?column? ---------- 2 @@ -123,20 +117,17 @@ select * from (select val + val2 from xc_groupby_tab1 group by val + val2) q ord 9 (6 rows) -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 +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 Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - -> HashAggregate + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" 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) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) +(5 rows) -select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -149,20 +140,15 @@ select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, v 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------- - Sort +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - -> 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) + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(3 rows) -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 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; ?column? | gt1_val | gt2_val2 ----------+---------+---------- 2 | 1 | 1 @@ -173,20 +159,15 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab 6 | 4 | 2 (6 rows) -explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val 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 +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - -> 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) + 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) -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; +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; ?column? ---------- 2 @@ -195,21 +176,18 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 from xc_groupby 7 (4 rows) -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 +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 Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - -> HashAggregate + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" 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) + 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 * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2) q order by q.val2; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -217,21 +195,18 @@ select * from (select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 17.6666666666666667 | 3 (3 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) +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) -- group by with expressions in group by clause -select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2) q order by q.expr; +select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 group by 2 * val2 order by expr; sum | avg | expr -----+--------------------+------ 6 | 2.0000000000000000 | 2 @@ -239,18 +214,15 @@ select * from (select sum(val), avg(val), 2 * val2 expr from xc_groupby_tab1 gro 11 | 3.6666666666666667 | 6 (3 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) +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) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -269,7 +241,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -278,20 +250,17 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b 4.0000000000000000 | 8 | 3 | (4 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) +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) -select * from (select 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; b ------- One @@ -300,20 +269,17 @@ select * from (select b from xc_groupby_def group by b) q order by q.b; (4 rows) -explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; - QUERY PLAN -------------------------------------------------------------------------------------- - Sort +explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b order by b; + QUERY PLAN +------------------------------------------------------------------------------------------ + Group Output: xc_groupby_def.b - Sort Key: xc_groupby_def.b - -> HashAggregate + -> Data Node Scan on "__REMOTE_GROUP_QUERY__" 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) + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(5 rows) -select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +select b,count(b) from xc_groupby_def group by b order by b; b | count -------+------- One | 1 @@ -322,18 +288,15 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; - QUERY PLAN ------------------------------------------------------------------------------------------------ - Sort - Output: xc_groupby_def.b, (count((count(xc_groupby_def.b)))) - Sort Key: xc_groupby_def.b - -> HashAggregate - Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) - -> 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) +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) select count(*) from xc_groupby_def where b is null group by b; count @@ -355,106 +318,104 @@ 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; +select sum(a) from xc_groupby_g group by a order by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; - QUERY PLAN -------------------------------------------------------------------------------------- - 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) +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) -select sum(b) from xc_groupby_g group by b; +select sum(b) from xc_groupby_g group by b order by b; sum ----- - 2.3 4.2 + 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order 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 + 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; +select sum(c) from xc_groupby_g group by b order by b; sum ----- - 5.2 6.4 + 5.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order 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 + 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; +select avg(a) from xc_groupby_g group by b order by b; avg ------------------------ - 2.0000000000000000 1.00000000000000000000 + 2.0000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order 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 + 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; +select avg(b) from xc_groupby_g group by c order by c; avg ----- - 2.3 2.1 + 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order 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 + 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; +select avg(c) from xc_groupby_g group by c order by c; avg -------------------- - 5.2000000000000000 3.2000000000000000 + 5.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order 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 + 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; @@ -466,7 +427,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; +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -474,18 +435,16 @@ 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; - 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) +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) -- joins and group by -select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; +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; count | sum | avg | ?column? | c1 | c2 -------+-----+---------------------+------------------+----+---- 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -494,46 +453,37 @@ select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), 3 | | | | | 4 (4 rows) -explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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) +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) -- aggregates over aggregates -select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; +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; sum ----- 8 17 (2 rows) -explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------- +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 +------------------------------------------------------------------------------------------------------------------ Sort - 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) + 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) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2; +select val2 from xc_groupby_tab1 group by val2 order by val2; val2 ------ 1 @@ -541,17 +491,15 @@ select val2 from xc_groupby_tab1 group by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; - QUERY PLAN --------------------------------------------------------------------------------------- - HashAggregate +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__" Output: xc_groupby_tab1.val2 - -> 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) + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(3 rows) -select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; +select val + val2 sum from xc_groupby_tab1 group by val + val2 order by sum; sum ----- 2 @@ -562,20 +510,15 @@ select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q 9 (6 rows) -explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; - QUERY PLAN ------------------------------------------------------------------------------------------------------------- - Sort +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)) - -> 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) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) +(3 rows) -select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -588,20 +531,15 @@ select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, v 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------- - Sort +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - Sort Key: xc_groupby_tab1.val, xc_groupby_tab1.val2 - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab1.val2)), xc_groupby_tab1.val, xc_groupby_tab1.val2 - -> 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) + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(3 rows) -select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; +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; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -612,20 +550,15 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab 6 | 4 | 2 (6 rows) -explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - Sort +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - Sort Key: xc_groupby_tab1.val, xc_groupby_tab2.val2 - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)), xc_groupby_tab1.val, xc_groupby_tab2.val2 - -> 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) + 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) -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; +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; sum ----- 2 @@ -634,21 +567,16 @@ select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_gro 7 (4 rows) -explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Sort +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__" Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - Sort Key: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - -> HashAggregate - Output: ((xc_groupby_tab1.val + xc_groupby_tab2.val2)) - -> 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) + 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) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by 1; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -656,34 +584,33 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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 +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))) -> 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) + 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) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order 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; - 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) +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) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -702,7 +629,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -711,20 +638,15 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b 4.0000000000000000 | 8 | 3 | (4 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) +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) -select * from (select 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; b ------- One @@ -733,20 +655,15 @@ select * from (select b from xc_groupby_def group by b) q order by q.b; (4 rows) -explain (verbose true, costs false, nodes false) select * from (select b from xc_groupby_def group by b) q order by q.b; - QUERY PLAN -------------------------------------------------------------------------------------- - Sort +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__" Output: xc_groupby_def.b - 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) + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(3 rows) -select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; +select b,count(b) from xc_groupby_def group by b order by b; b | count -------+------- One | 1 @@ -755,18 +672,13 @@ select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select * from (select b,count(b) from xc_groupby_def group by b) q order by q.b; - QUERY PLAN ------------------------------------------------------------------------------------------------ - Sort - Output: xc_groupby_def.b, (count((count(xc_groupby_def.b)))) - Sort Key: xc_groupby_def.b - -> HashAggregate - Output: xc_groupby_def.b, count((count(xc_groupby_def.b))) - -> 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) +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) select count(*) from xc_groupby_def where b is null group by b; count @@ -775,120 +687,106 @@ 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 ------------------------------------------------------------------------------------------------- - 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) + 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) 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; +select sum(a) from xc_groupby_g group by a order by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; - QUERY PLAN -------------------------------------------------------------------------------------- - 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) +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) -select sum(b) from xc_groupby_g group by b; +select sum(b) from xc_groupby_g group by b order by b; sum ----- - 2.3 4.2 + 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate - Output: sum((sum(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) +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) -select sum(c) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b order by b; sum ----- - 5.2 6.4 + 5.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate - Output: 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) +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) -select avg(a) from xc_groupby_g group by b; +select avg(a) from xc_groupby_g group by b order by b; avg ------------------------ - 2.0000000000000000 1.00000000000000000000 + 2.0000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; - QUERY PLAN -------------------------------------------------------------------------------------- - HashAggregate - Output: pg_catalog.avg((avg(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) +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) -select avg(b) from xc_groupby_g group by c; +select avg(b) from xc_groupby_g group by c order by c; avg ----- - 2.3 2.1 + 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; - QUERY PLAN -------------------------------------------------------------------------------------- - 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) +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) -select avg(c) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c order by c; avg -------------------- - 5.2000000000000000 3.2000000000000000 + 5.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; - QUERY PLAN -------------------------------------------------------------------------------------- - 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) +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) drop table xc_groupby_def; drop table xc_groupby_g; @@ -975,7 +873,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; +select val2 from xc_groupby_tab1 group by val2 order by val2; val2 ------ 1 @@ -983,7 +881,7 @@ select val2 from xc_groupby_tab1 group by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) 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 order by val2; QUERY PLAN ---------------------------------------------------------------------------------------------------- Group @@ -1028,14 +926,12 @@ 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 ---------------------------------------------------------------------------------------------------------------------------------- - Group + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------- + Data Node Scan on "__REMOTE_GROUP_QUERY__" 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 ORDER BY val, val2 -(5 rows) + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(3 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 @@ -1049,14 +945,12 @@ 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 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Group + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Data Node Scan on "__REMOTE_GROUP_QUERY__" 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 ORDER BY l.a_1, r.a_1 -(5 rows) + 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) 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? @@ -1078,7 +972,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; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -1086,7 +980,7 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; 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; +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 @@ -1097,7 +991,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; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; sum | avg | ?column? -----+--------------------+---------- 6 | 2.0000000000000000 | 2 @@ -1105,7 +999,7 @@ select sum(val), avg(val), 2 * val2 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 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 order by 2 * val2; QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------ GroupAggregate @@ -1132,7 +1026,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -1141,7 +1035,7 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b 4.0000000000000000 | 8 | 3 | (4 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; +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 @@ -1151,7 +1045,7 @@ explain (verbose true, costs false, nodes false) select * from (select avg(a), s 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; +select b from xc_groupby_def group by b order by b; b ------- One @@ -1160,7 +1054,7 @@ select b from xc_groupby_def group by b; (4 rows) -explain (verbose true, costs false, nodes false) 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 order by b; QUERY PLAN ------------------------------------------------------------------------------------------ Group @@ -1170,7 +1064,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; +select b,count(b) from xc_groupby_def group by b order by b; b | count -------+------- One | 1 @@ -1179,7 +1073,7 @@ select b,count(b) from xc_groupby_def group by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) 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 order by b; QUERY PLAN ---------------------------------------------------------------------------------------------------- GroupAggregate @@ -1209,31 +1103,29 @@ 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; +select sum(a) from xc_groupby_g group by a order by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; - QUERY PLAN ------------------------------------------------------------------------------------------------- - 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) +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) -select sum(b) from xc_groupby_g group by b; +select sum(b) from xc_groupby_g group by b order 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; +explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b order by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1243,14 +1135,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; +select sum(c) from xc_groupby_g group by b order 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; +explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b order by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1260,14 +1152,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; +select avg(a) from xc_groupby_g group by b order 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; +explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b order by b; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1277,14 +1169,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; +select avg(b) from xc_groupby_g group by c order 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; +explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c order by c; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1294,14 +1186,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; +select avg(c) from xc_groupby_g group by c order 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; +explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c order by c; QUERY PLAN ------------------------------------------------------------------------------------------------ GroupAggregate @@ -1320,7 +1212,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; +select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_groupby_tab1 group by val2 order by val2; count | sum | avg | ?column? | val2 -------+-----+--------------------+------------------+------ 3 | 6 | 2.0000000000000000 | 2 | 1 @@ -1328,18 +1220,16 @@ 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; - 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 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) -- 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; +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; count | sum | avg | ?column? | val2 | val2 -------+-----+---------------------+------------------+------+------ 9 | 78 | 8.6666666666666667 | 8.66666666666667 | 1 | 1 @@ -1348,27 +1238,25 @@ 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; - 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) +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) -- 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; +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; sum ----- 8 17 (2 rows) -explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------------------- +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 +-------------------------------------------------------------------------------------------------------------------------------------- GroupAggregate Output: sum(q1.y), q1.x -> Sort @@ -1376,15 +1264,13 @@ explain (verbose true, costs false, nodes false) select sum(y) from (select sum( Sort Key: q1.x -> Subquery Scan on q1 Output: q1.x, q1.y - -> GroupAggregate - Output: pg_catalog.sum((sum(xc_groupby_tab1.val))), ((xc_groupby_tab1.val2 % 2)), xc_groupby_tab1.val2 - -> 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) + -> 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) -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2; +select val2 from xc_groupby_tab1 group by val2 order by val2; val2 ------ 1 @@ -1392,17 +1278,15 @@ select val2 from xc_groupby_tab1 group by val2; 3 (3 rows) -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------- - Group +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__" Output: xc_groupby_tab1.val2 - -> 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) + Remote query: SELECT val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val2 ORDER BY val2 +(3 rows) -select val + val2 from xc_groupby_tab1 group by val + val2; +select val + val2 from xc_groupby_tab1 group by val + val2 order by val + val2; ?column? ---------- 2 @@ -1413,17 +1297,15 @@ select val + val2 from xc_groupby_tab1 group by val + val2; 9 (6 rows) -explain (verbose true, costs false, nodes false) select val + val2 from xc_groupby_tab1 group by val + val2; - QUERY PLAN ----------------------------------------------------------------------------------------------------------------------------- - Group +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__" 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) ORDER BY (val + val2) -(5 rows) + Remote query: SELECT (val + val2) FROM ONLY xc_groupby_tab1 WHERE true GROUP BY (val + val2) ORDER BY (val + val2) +(3 rows) -select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; +select val + val2, val, val2 from xc_groupby_tab1 group by val, val2 order by val, val2; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -1436,17 +1318,15 @@ select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; 9 | 6 | 3 (8 rows) -explain (verbose true, costs false, nodes false) select val + val2, val, val2 from xc_groupby_tab1 group by val, val2; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------- - Group +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__" 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 ORDER BY val, val2 -(5 rows) + Remote query: SELECT (val + val2), val, val2 FROM ONLY xc_groupby_tab1 WHERE true GROUP BY val, val2 ORDER BY val, val2 +(3 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; +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; ?column? | val | val2 ----------+-----+------ 2 | 1 | 1 @@ -1457,17 +1337,15 @@ 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; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Group +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__" 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 ORDER BY l.a_1, r.a_1 -(5 rows) + 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) -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; +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; ?column? ---------- 2 @@ -1476,18 +1354,16 @@ 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; - QUERY PLAN -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Group +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__" 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) ORDER BY (l.a_1 + r.a_1) -(5 rows) + 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) -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2 order by val2; ?column? | val2 ---------------------+------ 11.0000000000000000 | 1 @@ -1495,18 +1371,16 @@ select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; 17.6666666666666667 | 3 (3 rows) -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; - QUERY PLAN --------------------------------------------------------------------------------------------------------------------------------------------------------------- - GroupAggregate - Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(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 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) -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2 order by 2 * val2; sum | avg | ?column? -----+--------------------+---------- 6 | 2.0000000000000000 | 2 @@ -1514,15 +1388,13 @@ select sum(val), avg(val), 2 * val2 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 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) +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) drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -1541,7 +1413,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 * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b) q order by q.b; +select avg(a), sum(a), count(*), b from xc_groupby_def group by b order by b; avg | sum | count | b --------------------+-----+-------+------- | | 1 | One @@ -1550,17 +1422,15 @@ select * from (select avg(a), sum(a), count(*), b from xc_groupby_def group by b 4.0000000000000000 | 8 | 3 | (4 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; +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) + 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) -select b from xc_groupby_def group by b; +select b from xc_groupby_def group by b order by b; b ------- One @@ -1569,17 +1439,15 @@ select b from xc_groupby_def group by b; (4 rows) -explain (verbose true, costs false, nodes false) select b from xc_groupby_def group by b; - QUERY PLAN ------------------------------------------------------------------------------------------- - Group +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__" 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 ORDER BY b -(5 rows) + Remote query: SELECT b FROM ONLY xc_groupby_def WHERE true GROUP BY b ORDER BY b +(3 rows) -select b,count(b) from xc_groupby_def group by b; +select b,count(b) from xc_groupby_def group by b order by b; b | count -------+------- One | 1 @@ -1588,15 +1456,13 @@ select b,count(b) from xc_groupby_def group by b; | 0 (4 rows) -explain (verbose true, costs false, nodes false) select b,count(b) from xc_groupby_def group by b; - QUERY PLAN ----------------------------------------------------------------------------------------------------- - GroupAggregate - Output: 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 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) select count(*) from xc_groupby_def where b is null group by b; count @@ -1605,120 +1471,106 @@ 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 ------------------------------------------------------------------------------------------------------------ - 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) + 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) 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; +select sum(a) from xc_groupby_g group by a order by a; sum ----- 2 2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(a) from xc_groupby_g group by a; - QUERY PLAN ------------------------------------------------------------------------------------------------- - 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) +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) -select sum(b) from xc_groupby_g group by b; +select sum(b) from xc_groupby_g group by b order by b; sum ----- 4.2 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select sum(b) from xc_groupby_g group by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate - Output: sum((sum(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) +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) -select sum(c) from xc_groupby_g group by b; +select sum(c) from xc_groupby_g group by b order by b; sum ----- 6.4 5.2 (2 rows) -explain (verbose true, costs false, nodes false) select sum(c) from xc_groupby_g group by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate - Output: 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) +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) -select avg(a) from xc_groupby_g group by b; +select avg(a) from xc_groupby_g group by b order by b; avg ------------------------ 1.00000000000000000000 2.0000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(a) from xc_groupby_g group by b; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(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) +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) -select avg(b) from xc_groupby_g group by c; +select avg(b) from xc_groupby_g group by c order by c; avg ----- 2.1 2.3 (2 rows) -explain (verbose true, costs false, nodes false) select avg(b) from xc_groupby_g group by c; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(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) +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) -select avg(c) from xc_groupby_g group by c; +select avg(c) from xc_groupby_g group by c order by c; avg -------------------- 3.2000000000000000 5.2000000000000000 (2 rows) -explain (verbose true, costs false, nodes false) select avg(c) from xc_groupby_g group by c; - QUERY PLAN ------------------------------------------------------------------------------------------------- - GroupAggregate - Output: pg_catalog.avg((avg(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) +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) 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 8ff190a121..d5bbdaafa1 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; +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; 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; +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 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - HashAggregate + 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 + 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; @@ -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 * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; +select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; sum ----- 4 @@ -134,19 +134,16 @@ select * from (select val + val2 sum from xc_having_tab1 group by val + val2 hav 9 (3 rows) -explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------- - Sort +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 Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) - -> HashAggregate - Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - 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) + 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; @@ -183,14 +180,12 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - HashAggregate - Output: pg_catalog.count(*), pg_catalog.sum((sum(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) + 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) -- having clause containing aggregate select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; @@ -200,33 +195,27 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - HashAggregate - Output: pg_catalog.count(*), pg_catalog.sum((sum(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) + 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) -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 or val2 > 2 order by val2; 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; - 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) +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) 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 @@ -236,13 +225,10 @@ 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 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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) + 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) -- 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; @@ -252,14 +238,12 @@ 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 -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 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) + 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) -- group by and having, without aggregate in the target list select val2 from xc_having_tab1 group by val2 having sum(val) > 8; @@ -269,17 +253,14 @@ select val2 from xc_having_tab1 group by val2 having sum(val) > 8; (1 row) explain (verbose true, costs false, nodes false) select val2 from xc_having_tab1 group by val2 having sum(val) > 8; - QUERY PLAN ------------------------------------------------------------------------------------------------ - HashAggregate + QUERY PLAN +----------------------------------------------------------------------------------------------------- + Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: xc_having_tab1.val2 - 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) + Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) +(3 rows) -select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; +select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5 order by sum; sum ----- 4 @@ -287,19 +268,13 @@ select * from (select val + val2 sum from xc_having_tab1 group by val + val2 hav 9 (3 rows) -explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_having_tab1 group by val + val2 having sum(val) > 5) q order by q.sum; - QUERY PLAN ---------------------------------------------------------------------------------------------------------------------- - Sort +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__" Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - Sort Key: ((xc_having_tab1.val + xc_having_tab1.val2)) - -> HashAggregate - Output: ((xc_having_tab1.val + xc_having_tab1.val2)) - 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) + 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) -- group by with aggregates in expression select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -309,15 +284,12 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------ - HashAggregate - Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(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) + 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) drop table xc_having_tab1; drop table xc_having_tab2; @@ -363,14 +335,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; +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; 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; +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 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- GroupAggregate @@ -498,14 +470,12 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having val2 + 1 > 3; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - GroupAggregate - Output: pg_catalog.count(*), pg_catalog.sum((sum(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) + 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) -- 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; @@ -515,33 +485,27 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (1 row) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - GroupAggregate - Output: pg_catalog.count(*), pg_catalog.sum((sum(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) + 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) -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 or val2 > 2 order by val2; 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; - 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) +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) 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 @@ -549,15 +513,12 @@ select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_hav (0 rows) explain (verbose true, costs false, nodes false) select count(*), sum(val), avg(val), sum(val)::float8/count(*), val2 from xc_having_tab1 group by val2 having avg(val) > 3.75 and val2 > 2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - GroupAggregate - Output: pg_catalog.count(*), pg_catalog.sum((sum(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) + 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) -- 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; @@ -567,14 +528,12 @@ 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 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ - 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) + 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) -- group by and having, without aggregate in the target list select val2 from xc_having_tab1 group by val2 having sum(val) > 8; @@ -584,15 +543,12 @@ 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 -------------------------------------------------------------------------------------------------------------- - GroupAggregate + QUERY PLAN +------------------------------------------------------------------------------------------------------------------- + Data Node Scan on "__REMOTE_GROUP_QUERY__" Output: xc_having_tab1.val2 - 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) + Remote query: SELECT val2 FROM ONLY xc_having_tab1 WHERE true GROUP BY val2 HAVING (sum(val) > 8) ORDER BY val2 +(3 rows) select val + val2 from xc_having_tab1 group by val + val2 having sum(val) > 5; ?column? @@ -603,15 +559,12 @@ 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 -------------------------------------------------------------------------------------------------------------------------------------- - GroupAggregate + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------- + Data Node Scan on "__REMOTE_GROUP_QUERY__" 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) + 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) -- group by with aggregates in expression select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; @@ -621,15 +574,12 @@ select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 ha (1 row) explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_having_tab1 group by val2 having min(val) < val2; - QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------ - GroupAggregate - Output: (((pg_catalog.count(*) + pg_catalog.sum((sum(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) + 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) 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 ee879d93f9..c348cabda1 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 (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; -- 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 602c643258..8ef010dfc5 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 * 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; +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; -- joins and group by -select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 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; +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; -- 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 * 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; +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; -- group by with aggregates in expression -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; +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; -- group by with expressions in group by clause -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; +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; drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -59,13 +59,12 @@ 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 * 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 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 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; @@ -74,19 +73,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; -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 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; -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; +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; drop table xc_groupby_def; drop table xc_groupby_g; @@ -98,31 +97,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; -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; +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; -- joins and group by -select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; -explain (verbose true, costs false, nodes false) select * from (select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2 c1, xc_groupby_tab2.val2 c2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2) q order by q.c1, q.c2; +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; -- aggregates over aggregates -select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; -explain (verbose true, costs false, nodes false) select * from (select sum(y) sum from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x) q order by q.sum; +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; -- group by without aggregate -select val2 from xc_groupby_tab1 group by val2; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; -select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; -explain (verbose true, costs false, nodes false) select * from (select val + val2 sum from xc_groupby_tab1 group by val + val2) q order by q.sum; -select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; -explain (verbose true, costs false, nodes false) select * from (select val + val2, val, val2 from xc_groupby_tab1 group by val, val2) q order by q.val, q.val2; -select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; -explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2, xc_groupby_tab1.val, xc_groupby_tab2.val2 from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val, xc_groupby_tab2.val2) q order by q.val, q.val2; -select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; -explain (verbose true, costs false, nodes false) select * from (select xc_groupby_tab1.val + xc_groupby_tab2.val2 sum from xc_groupby_tab1, xc_groupby_tab2 where xc_groupby_tab1.val = xc_groupby_tab2.val group by xc_groupby_tab1.val + xc_groupby_tab2.val2) q order by q.sum; +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; -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +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; -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +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; drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -142,13 +141,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 * 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 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 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 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 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; @@ -157,19 +156,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; -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 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; -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; +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; drop table xc_groupby_def; drop table xc_groupby_g; @@ -191,8 +190,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; -explain (verbose true, costs false, nodes false) select val2 from xc_groupby_tab1 group by val2; +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; 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; @@ -202,11 +201,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; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +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; -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +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; drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -226,13 +225,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 * 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 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; -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 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 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; @@ -241,19 +240,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; -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 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; -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; +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; drop table xc_groupby_def; drop table xc_groupby_g; @@ -265,31 +264,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; -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; +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; -- joins and group by -select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; -explain (verbose true, costs false, nodes false) select count(*), sum(xc_groupby_tab1.val * xc_groupby_tab2.val), avg(xc_groupby_tab1.val*xc_groupby_tab2.val), sum(xc_groupby_tab1.val*xc_groupby_tab2.val)::float8/count(*), xc_groupby_tab1.val2, xc_groupby_tab2.val2 from xc_groupby_tab1 full outer join xc_groupby_tab2 on xc_groupby_tab1.val2 = xc_groupby_tab2.val2 group by xc_groupby_tab1.val2, xc_groupby_tab2.val2; +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; -- aggregates over aggregates -select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; -explain (verbose true, costs false, nodes false) select sum(y) from (select sum(val) y, val2%2 x from xc_groupby_tab1 group by val2) q1 group by x; +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; -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; +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; -- group by with aggregates in expression -select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; -explain (verbose true, costs false, nodes false) select count(*) + sum(val) + avg(val), val2 from xc_groupby_tab1 group by val2; +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; -- group by with expressions in group by clause -select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; -explain (verbose true, costs false, nodes false) select sum(val), avg(val), 2 * val2 from xc_groupby_tab1 group by 2 * val2; +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; drop table xc_groupby_tab1; drop table xc_groupby_tab2; @@ -309,13 +308,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 * 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 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; -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 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 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; @@ -324,19 +323,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; -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; +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; 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 061ca3ae1c..41dc79b2da 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; -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 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 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 * 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; +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; -- 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; -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 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 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 * 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; +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; -- 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; -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 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 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; -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 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 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 |