diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 6f6ccdc..83c3dc7 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -690,7 +690,6 @@ _outAgg(StringInfo str, const Agg *node) WRITE_ENUM_FIELD(aggstrategy, AggStrategy); WRITE_INT_FIELD(numCols); - appendStringInfoString(str, " :grpColIdx"); for (i = 0; i < node->numCols; i++) appendStringInfo(str, " %d", node->grpColIdx[i]); @@ -1768,7 +1767,6 @@ _outGatherPath(StringInfo str, const GatherPath *node) _outPathInfo(str, (const Path *) node); WRITE_NODE_FIELD(subpath); - WRITE_INT_FIELD(num_workers); WRITE_BOOL_FIELD(single_copy); } diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c index 4516cd3..a3b3784 100644 --- a/src/backend/optimizer/path/allpaths.c +++ b/src/backend/optimizer/path/allpaths.c @@ -72,6 +72,7 @@ static void set_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, Index rti, RangeTblEntry *rte); static void set_plain_rel_size(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte); +static void create_parallel_paths(PlannerInfo *root, RelOptInfo *rel); static void set_rel_consider_parallel(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte); static bool function_rte_parallel_ok(RangeTblEntry *rte); @@ -612,7 +613,6 @@ static void set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) { Relids required_outer; - int parallel_threshold = 1000; /* * We don't support pushing join clauses into the quals of a seqscan, but @@ -624,39 +624,9 @@ set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) /* Consider sequential scan */ add_path(rel, create_seqscan_path(root, rel, required_outer, 0)); - /* Consider parallel sequential scan */ - if (rel->consider_parallel && rel->pages > parallel_threshold && - required_outer == NULL) - { - Path *path; - int parallel_degree = 1; - - /* - * Limit the degree of parallelism logarithmically based on the size - * of the relation. This probably needs to be a good deal more - * sophisticated, but we need something here for now. - */ - while (rel->pages > parallel_threshold * 3 && - parallel_degree < max_parallel_degree) - { - parallel_degree++; - parallel_threshold *= 3; - if (parallel_threshold >= PG_INT32_MAX / 3) - break; - } - - /* - * Ideally we should consider postponing the gather operation until - * much later, after we've pushed joins and so on atop the parallel - * sequential scan path. But we don't have the infrastructure for - * that yet, so just do this for now. - */ - path = create_seqscan_path(root, rel, required_outer, parallel_degree); - path = (Path *) - create_gather_path(root, rel, path, required_outer, - parallel_degree); - add_path(rel, path); - } + /* If appropriate, consider parallel sequential scan */ + if (rel->consider_parallel && required_outer == NULL) + create_parallel_paths(root, rel); /* Consider index scans */ create_index_paths(root, rel); @@ -666,6 +636,54 @@ set_plain_rel_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) } /* + * create_parallel_paths + * Build parallel access paths for a plain relation + */ +static void +create_parallel_paths(PlannerInfo *root, RelOptInfo *rel) +{ + int parallel_threshold = 1000; + int parallel_degree = 1; + + /* + * If this relation is too small to be worth a parallel scan, just return + * without doing anything ... unless it's an inheritance child. In that case, + * we want to generate a parallel path here anyway. It might not be worthwhile + * just for this relation, but when combined with all of its inheritance siblings + * it may well pay off. + */ + if (rel->pages < parallel_threshold && rel->reloptkind == RELOPT_BASEREL) + return; + + /* + * Limit the degree of parallelism logarithmically based on the size of the + * relation. This probably needs to be a good deal more sophisticated, but we + * need something here for now. + */ + while (rel->pages > parallel_threshold * 3 && + parallel_degree < max_parallel_degree) + { + parallel_degree++; + parallel_threshold *= 3; + if (parallel_threshold >= PG_INT32_MAX / 3) + break; + } + + /* Add an unordered partial path based on a parallel sequential scan. */ + add_partial_path(rel, create_seqscan_path(root, rel, NULL, parallel_degree)); + + /* + * If this is a baserel, consider gathering any partial paths we may have + * just created. If we gathered an inheritance child, we could end up + * with a very large number of gather nodes, each trying to grab its own + * pool of workers, so don't do this in that case. Instead, we'll + * consider gathering partial paths for the appendrel. + */ + if (rel->reloptkind == RELOPT_BASEREL) + generate_gather_paths(root, rel); +} + +/* * set_tablesample_rel_size * Set size estimates for a sampled relation */ @@ -1844,6 +1862,36 @@ set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel, RangeTblEntry *rte) } /* + * generate_gather_paths + * Generate parallel access paths for a relation by pushing a Gather on + * top of a partial path. + */ +void +generate_gather_paths(PlannerInfo *root, RelOptInfo *rel) +{ + Path *cheapest_partial_path; + Path *simple_gather_path; + + /* If there are no partial paths, there's nothing to do here. */ + if (rel->partial_pathlist == NIL) + return; + + /* + * The output of Gather is currently always unsorted, so there's only one + * partial path of interest: the cheapest one. + * + * Eventually, we should have a Gather Merge operation that can merge + * multiple tuple streams together while preserving their ordering. We + * could usefully generate such a path from each partial path that has + * non-NIL pathkeys. + */ + cheapest_partial_path = linitial(rel->partial_pathlist); + simple_gather_path = (Path *) + create_gather_path(root, rel, cheapest_partial_path, NULL); + add_path(rel, simple_gather_path); +} + +/* * make_rel_from_joinlist * Build access paths using a "joinlist" to guide the join path search. * diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c index 990486c..d519ae8 100644 --- a/src/backend/optimizer/path/costsize.c +++ b/src/backend/optimizer/path/costsize.c @@ -125,6 +125,7 @@ bool enable_material = true; bool enable_mergejoin = true; bool enable_hashjoin = true; +bool enable_parallelagg = false; typedef struct { PlannerInfo *root; @@ -186,24 +187,34 @@ clamp_row_est(double nrows) */ void cost_seqscan(Path *path, PlannerInfo *root, - RelOptInfo *baserel, ParamPathInfo *param_info, - int nworkers) + RelOptInfo *baserel, ParamPathInfo *param_info) { Cost startup_cost = 0; Cost run_cost = 0; double spc_seq_page_cost; QualCost qpqual_cost; Cost cpu_per_tuple; + double parallel_divisor = 1; /* Should only be applied to base relations */ Assert(baserel->relid > 0); Assert(baserel->rtekind == RTE_RELATION); + /* + * Primitive parallel cost model. Assume the leader will do half as much + * work as a regular worker, because it will also need to read the tuples + * returned by the workers when they percolate up to the gather ndoe. + * This is almost certainly not exactly the right way to model this, so + * this will probably need to be changed at some point... + */ + if (path->parallel_degree > 0) + parallel_divisor = path->parallel_degree + 0.5; + /* Mark the path with the correct row estimate */ if (param_info) - path->rows = param_info->ppi_rows; + path->rows = param_info->ppi_rows / parallel_divisor; else - path->rows = baserel->rows; + path->rows = baserel->rows / parallel_divisor; if (!enable_seqscan) startup_cost += disable_cost; @@ -216,24 +227,14 @@ cost_seqscan(Path *path, PlannerInfo *root, /* * disk costs */ - run_cost += spc_seq_page_cost * baserel->pages; + run_cost += spc_seq_page_cost * baserel->pages / parallel_divisor; /* CPU costs */ get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost); startup_cost += qpqual_cost.startup; cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple; - run_cost += cpu_per_tuple * baserel->tuples; - - /* - * Primitive parallel cost model. Assume the leader will do half as much - * work as a regular worker, because it will also need to read the tuples - * returned by the workers when they percolate up to the gather ndoe. - * This is almost certainly not exactly the right way to model this, so - * this will probably need to be changed at some point... - */ - if (nworkers > 0) - run_cost = run_cost / (nworkers + 0.5); + run_cost += cpu_per_tuple * baserel->tuples / parallel_divisor; path->startup_cost = startup_cost; path->total_cost = startup_cost + run_cost; diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c index b34d635..5dcbe09 100644 --- a/src/backend/optimizer/plan/createplan.c +++ b/src/backend/optimizer/plan/createplan.c @@ -1127,7 +1127,7 @@ create_gather_plan(PlannerInfo *root, GatherPath *best_path) gather_plan = make_gather(subplan->targetlist, NIL, - best_path->num_workers, + best_path->path.parallel_degree, best_path->single_copy, subplan); diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 67d630f..eea6075 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -49,6 +49,8 @@ #include "utils/rel.h" #include "utils/selfuncs.h" +#include "utils/syscache.h" +#include "catalog/pg_aggregate.h" /* GUC parameter */ double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION; @@ -77,6 +79,17 @@ typedef struct List *groupClause; /* overrides parse->groupClause */ } standard_qp_extra; +typedef struct +{ + bool agguseparallel; +} CheckParallelAggAvaiContext; + +typedef struct +{ + AttrNumber resno; + List *targetlist; +} AddQualInTListExprContext; + /* Local functions */ static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind); static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode); @@ -134,8 +147,34 @@ static Plan *build_grouping_chain(PlannerInfo *root, AttrNumber *groupColIdx, AggClauseCosts *agg_costs, long numGroups, + bool combineStates, + bool finalizeAggs, + Plan *result_plan); +static Plan *build_group_parallelagg(PlannerInfo *root, + Query *parse, + List *tlist, + bool need_sort_for_grouping, + List *rollup_groupclauses, + List *rollup_lists, + AttrNumber *groupColIdx, + AggClauseCosts *agg_costs, + long numGroups, Plan *result_plan); +static Plan *get_plan(Plan *plan, NodeTag type); +static AttrNumber*get_sortIdx_from_subPlan(PlannerInfo *root, List *tlist); +static List *make_partial_agg_tlist(List *tlist,List *groupClause); +static List* add_qual_in_tlist(List *targetlist, List *qual); +static bool add_qual_in_tlist_walker (Node *node, + AddQualInTListExprContext *context); +static Plan *build_hash_parallelagg(PlannerInfo *root, + Query *parse, + List *tlist, + AggClauseCosts *aggcosts, + int numGroupCols, + AttrNumber *grpColIdx, + long numGroups, + Plan *lefttree); /***************************************************************************** * * Query optimizer entry point @@ -1333,6 +1372,7 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) double dNumGroups = 0; bool use_hashed_distinct = false; bool tested_hashed_distinct = false; + bool parallelagg_available = false; /* Tweak caller-supplied tuple_fraction if have LIMIT/OFFSET */ if (parse->limitCount || parse->limitOffset) @@ -1433,8 +1473,8 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) List *rollup_groupclauses = NIL; standard_qp_extra qp_extra; RelOptInfo *final_rel; - Path *cheapest_path; - Path *sorted_path; + Path *cheapest_path = NULL; + Path *sorted_path = NULL; Path *best_path; MemSet(&agg_costs, 0, sizeof(AggClauseCosts)); @@ -1748,22 +1788,54 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) } /* - * Pick out the cheapest-total path as well as the cheapest presorted - * path for the requested pathkeys (if there is one). We should take - * the tuple fraction into account when selecting the cheapest - * presorted path, but not when selecting the cheapest-total path, - * since if we have to sort then we'll have to fetch all the tuples. - * (But there's a special case: if query_pathkeys is NIL, meaning - * order doesn't matter, then the "cheapest presorted" path will be - * the cheapest overall for the tuple fraction.) + * Prepare a gather path on the partial path, in case if it satisfies + * parallel aggregate plan. */ - cheapest_path = final_rel->cheapest_total_path; + if (enable_parallelagg + && final_rel->partial_pathlist + && (dNumGroups < (path_rows / 4))) + { + /* + * check for parallel aggregate eligibility by referring all aggregate + * functions in both qualification and targetlist. + */ + if (aggregates_allow_partial((Node *)tlist) + && aggregates_allow_partial(parse->havingQual)) + { + Path *cheapest_partial_path; + + cheapest_partial_path = linitial(final_rel->partial_pathlist); + cheapest_path = (Path *) + create_gather_path(root, final_rel, cheapest_partial_path, NULL); + + sorted_path = + get_cheapest_fractional_path_for_pathkeys(final_rel->partial_pathlist, + root->query_pathkeys, + NULL, + tuple_fraction); + parallelagg_available = true; + } + } + else + { + /* + * Pick out the cheapest-total path as well as the cheapest presorted + * path for the requested pathkeys (if there is one). We should take + * the tuple fraction into account when selecting the cheapest + * presorted path, but not when selecting the cheapest-total path, + * since if we have to sort then we'll have to fetch all the tuples. + * (But there's a special case: if query_pathkeys is NIL, meaning + * order doesn't matter, then the "cheapest presorted" path will be + * the cheapest overall for the tuple fraction.) + */ + cheapest_path = final_rel->cheapest_total_path; - sorted_path = - get_cheapest_fractional_path_for_pathkeys(final_rel->pathlist, - root->query_pathkeys, - NULL, - tuple_fraction); + sorted_path = + get_cheapest_fractional_path_for_pathkeys(final_rel->pathlist, + root->query_pathkeys, + NULL, + tuple_fraction); + } /* Don't consider same path in both guises; just wastes effort */ if (sorted_path == cheapest_path) @@ -1912,7 +1984,7 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) * the top plan node. However, we can skip that if we determined * that whatever create_plan chose to return will be good enough. */ - if (need_tlist_eval) + if (need_tlist_eval & !parallelagg_available) { /* * If the top-level plan node is one that cannot do expression @@ -1984,20 +2056,56 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) */ if (use_hashed_grouping) { - /* Hashed aggregate plan --- no sort needed */ - result_plan = (Plan *) make_agg(root, - tlist, - (List *) parse->havingQual, - AGG_HASHED, - &agg_costs, - numGroupCols, - groupColIdx, - extract_grouping_ops(parse->groupClause), - NIL, - numGroups, - false, - true, - result_plan); + if(parallelagg_available) + { + Plan *parallelagg_plan; + + parallelagg_plan = build_hash_parallelagg(root, + parse, + tlist, + &agg_costs, + numGroupCols, + groupColIdx, + numGroups, + result_plan); + + if(!parallelagg_plan) + { + /* Hashed aggregate plan --- no sort needed */ + result_plan = (Plan *) make_agg(root, + tlist, + (List *) parse->havingQual, + AGG_HASHED, + &agg_costs, + numGroupCols, + groupColIdx, + extract_grouping_ops(parse->groupClause), + NIL, + numGroups, + false, + true, + result_plan); + } + else + result_plan = parallelagg_plan; + } + else + { + /* Hashed aggregate plan --- no sort needed */ + result_plan = (Plan *) make_agg(root, + tlist, + (List *) parse->havingQual, + AGG_HASHED, + &agg_costs, + numGroupCols, + groupColIdx, + extract_grouping_ops(parse->groupClause), + NIL, + numGroups, + false, + true, + result_plan); + } /* Hashed aggregation produces randomly-ordered results */ current_pathkeys = NIL; } @@ -2014,7 +2122,25 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) else current_pathkeys = NIL; - result_plan = build_grouping_chain(root, + + if(parallelagg_available) + { + Plan *parallelagg_plan; + + parallelagg_plan = build_group_parallelagg(root, + parse, + tlist, + need_sort_for_grouping, + rollup_groupclauses, + rollup_lists, + groupColIdx, + &agg_costs, + numGroups, + result_plan); + + if(parallelagg_plan == NULL) + { + result_plan = build_grouping_chain(root, parse, tlist, need_sort_for_grouping, @@ -2023,7 +2149,29 @@ grouping_planner(PlannerInfo *root, double tuple_fraction) groupColIdx, &agg_costs, numGroups, + false, + true, result_plan); + } + else + result_plan = parallelagg_plan; + + } + else + { + result_plan = build_grouping_chain(root, + parse, + tlist, + need_sort_for_grouping, + rollup_groupclauses, + rollup_lists, + groupColIdx, + &agg_costs, + numGroups, + false, + true, + result_plan); + } /* * these are destroyed by build_grouping_chain, so make sure @@ -2477,10 +2625,16 @@ build_grouping_chain(PlannerInfo *root, AttrNumber *groupColIdx, AggClauseCosts *agg_costs, long numGroups, + bool combineStates, + bool finalizeAggs, Plan *result_plan) { - AttrNumber *top_grpColIdx = groupColIdx; - List *chain = NIL; + AttrNumber *top_grpColIdx = groupColIdx; + List *chain = NIL; + List *qual = NIL; + + if(finalizeAggs) + qual = (List *) parse->havingQual; /* * Prepare the grpColIdx for the real Agg node first, because we may need @@ -2535,7 +2689,7 @@ build_grouping_chain(PlannerInfo *root, agg_plan = (Plan *) make_agg(root, tlist, - (List *) parse->havingQual, + qual, AGG_SORTED, agg_costs, list_length(linitial(gsets)), @@ -2543,8 +2697,8 @@ build_grouping_chain(PlannerInfo *root, extract_grouping_ops(groupClause), gsets, numGroups, - false, - true, + combineStates, + finalizeAggs, sort_plan); sort_plan->lefttree = NULL; @@ -2573,7 +2727,7 @@ build_grouping_chain(PlannerInfo *root, result_plan = (Plan *) make_agg(root, tlist, - (List *) parse->havingQual, + qual, (numGroupCols > 0) ? AGG_SORTED : AGG_PLAIN, agg_costs, numGroupCols, @@ -2581,8 +2735,8 @@ build_grouping_chain(PlannerInfo *root, extract_grouping_ops(groupClause), gsets, numGroups, - false, - true, + combineStates, + finalizeAggs, result_plan); ((Agg *) result_plan)->chain = chain; @@ -4712,3 +4866,383 @@ plan_cluster_use_sort(Oid tableOid, Oid indexOid) return (seqScanAndSortPath.total_cost < indexScanPath->path.total_cost); } + +/* + * This function build a group parallelagg plan as result_plan as following : + * Finalize Group Aggregate + * -> Sort + * -> Gather + * -> Partial Group Aggregate + * -> Sort + * -> Any partial plan + * The input result_plan will be + * Gather + * -> Any partial plan + * So this function will do the following steps: + * 1. Move up the Gather node and change its targetlist + * 2. Change the Group Aggregate to be Partial Group Aggregate + * 3. Add Finalize Group Aggregate and Sort node + */ +static Plan * +build_group_parallelagg(PlannerInfo *root, + Query *parse, + List *tlist, + bool need_sort_for_grouping, + List *rollup_groupclauses, + List *rollup_lists, + AttrNumber *groupColIdx, + AggClauseCosts *agg_costs, + long numGroups, + Plan *result_plan) +{ + Plan *partial_agg = NULL; + Plan *gather_plan = NULL; + List *qual = (List*)parse->havingQual; + List *partial_agg_tlist = NULL; + + AttrNumber *topsortIdx = NULL; + + gather_plan = get_plan(result_plan, T_Gather); + if(gather_plan == NULL) + return NULL; + + /* + * The underlying Agg targetlist should be a flat tlist of all Vars and Aggs + * needed to evaluate the expressions and final values of aggregates present + * in the main target list. The quals also should be included. + */ + partial_agg_tlist = make_partial_agg_tlist(add_qual_in_tlist(tlist, qual), + llast(rollup_groupclauses)); + + /* Add PartialAgg and Sort node */ + partial_agg = build_grouping_chain(root, + parse, + partial_agg_tlist, + need_sort_for_grouping, + rollup_groupclauses, + rollup_lists, + groupColIdx, + agg_costs, + numGroups, + false, + false, + gather_plan->lefttree); + + + + /* Let the Gather node as upper node of partial_agg node */ + gather_plan->targetlist = partial_agg->targetlist; + gather_plan->lefttree = partial_agg; + + /* + * Get the sortIndex according the subplan + */ + topsortIdx = get_sortIdx_from_subPlan(root,partial_agg_tlist); + + /* Make the Finalize Group Aggregate node */ + result_plan = build_grouping_chain(root, + parse, + tlist, + need_sort_for_grouping, + rollup_groupclauses, + rollup_lists, + topsortIdx, + agg_costs, + numGroups, + true, + true, + gather_plan); + + return result_plan; +} + +/* + * This function try to find the type of sub plan in the plan and return it. + * + * If not found, return NULL. Otherwise return the subplan. + */ +static Plan * +get_plan(Plan *plan, NodeTag type) +{ + if(plan == NULL) + return NULL; + else if(nodeTag(plan) == type) + return plan; + else + return get_plan(plan->lefttree, type); +} + + +static AttrNumber* +get_sortIdx_from_subPlan(PlannerInfo *root, List *tlist) +{ + Query *parse = root->parse; + int numCols; + + AttrNumber *grpColIdx = NULL; + + numCols = list_length(parse->groupClause); + if (numCols > 0) + { + ListCell *tl; + + grpColIdx = (AttrNumber *) palloc0(sizeof(AttrNumber) * numCols); + + foreach(tl, tlist) + { + TargetEntry *tle = (TargetEntry *) lfirst(tl); + int colno; + + colno = get_grouping_column_index(parse, tle); + if (colno >= 0) + { + Assert(grpColIdx[colno] == 0); /* no dups expected */ + grpColIdx[colno] = tle->resno; + } + } + } + + return grpColIdx; +} + +/* + * make_partial_agg_tlist + * Generate appropriate Agg node target list for input to ParallelAgg nodes. + * + * The initial target list passed to ParallelAgg node from the parser contains + * aggregates and GROUP BY columns. For the underlying agg node, we want to + * generate a tlist containing bare aggregate references (Aggref) and GROUP BY + * expressions. So we flatten all expressions except GROUP BY items into their + * component variables. + * For example, given a query like + * SELECT a+b, 2 * SUM(c+d) , AVG(d)+SUM(c+d) FROM table GROUP BY a+b; + * we want to pass this targetlist to the Agg plan: + * a+b, SUM(c+d), AVG(d) + * where the a+b target will be used by the Sort/Group steps, and the + * other targets will be used for computing the final results. + * Note that we don't flatten Aggref's , since those are to be computed + * by the underlying Agg node, and they will be referenced like Vars above it. + * + * 'tlist' is the ParallelAgg's final target list. + * + * The result is the targetlist to be computed by the Agg node below the + * ParallelAgg node. + */ +static List * +make_partial_agg_tlist(List *tlist,List *groupClause) +{ + Bitmapset *sgrefs; + List *new_tlist; + List *flattenable_cols; + List *flattenable_vars; + ListCell *lc; + + /* + * Collect the sortgroupref numbers of GROUP BY clauses + * into a bitmapset for convenient reference below. + */ + sgrefs = NULL; + + /* Add in sortgroupref numbers of GROUP BY clauses */ + foreach(lc, groupClause) + { + SortGroupClause *grpcl = (SortGroupClause *) lfirst(lc); + + sgrefs = bms_add_member(sgrefs, grpcl->tleSortGroupRef); + } + + /* + * Construct a tlist containing all the non-flattenable tlist items, and + * save aside the others for a moment. + */ + new_tlist = NIL; + flattenable_cols = NIL; + + foreach(lc, tlist) + { + TargetEntry *tle = (TargetEntry *) lfirst(lc); + + /* Don't want to deconstruct GROUP BY items. */ + if (tle->ressortgroupref != 0 && + bms_is_member(tle->ressortgroupref, sgrefs)) + { + /* Don't want to deconstruct this value, so add to new_tlist */ + TargetEntry *newtle; + + newtle = makeTargetEntry(tle->expr, + list_length(new_tlist) + 1, + NULL, + false); + /* Preserve its sortgroupref marking, in case it's volatile */ + newtle->ressortgroupref = tle->ressortgroupref; + new_tlist = lappend(new_tlist, newtle); + } + else + { + /* + * Column is to be flattened, so just remember the expression for + * later call to pull_var_clause. There's no need for + * pull_var_clause to examine the TargetEntry node itself. + */ + flattenable_cols = lappend(flattenable_cols, tle->expr); + } + } + + /* + * Pull out all the Vars and Aggrefs mentioned in flattenable columns, and + * add them to the result tlist if not already present. (Some might be + * there already because they're used directly as group clauses.) + * + * Note: it's essential to use PVC_INCLUDE_AGGREGATES here, so that the + * Aggrefs are placed in the Agg node's tlist and not left to be computed + * at higher levels. + */ + flattenable_vars = pull_var_clause((Node *) flattenable_cols, + PVC_INCLUDE_AGGREGATES, + PVC_INCLUDE_PLACEHOLDERS); + new_tlist = add_to_flat_tlist(new_tlist, flattenable_vars); + + /* clean up cruft */ + list_free(flattenable_vars); + list_free(flattenable_cols); + + return new_tlist; +} + +/* + * add_qual_in_tlist + * Add the agg functions in qual into the target list used in agg plan + */ +static List* +add_qual_in_tlist(List *targetlist, List *qual) +{ + AddQualInTListExprContext context; + + if(qual == NULL) + return targetlist; + + context.targetlist = copyObject(targetlist); + context.resno = list_length(context.targetlist) + 1;; + + add_qual_in_tlist_walker((Node*)qual, &context); + + return context.targetlist; +} + +/* + * add_qual_in_tlist_walker + * Go through the qual list to get the aggref and add it in targetlist + */ +static bool +add_qual_in_tlist_walker (Node *node, AddQualInTListExprContext *context) +{ + if (node == NULL) + return false; + + if (IsA(node, Aggref)) + { + List *tlist = context->targetlist; +// Aggref *aggref = (Aggref *)node; + + TargetEntry *te = makeNode(TargetEntry); + +// aggref->resno = context->resno; + + te = makeTargetEntry((Expr *) node, + context->resno++, + NULL, + false); + + tlist = lappend(tlist,te); + } + else + return expression_tree_walker(node, add_qual_in_tlist_walker, context); + + return false; +} + +/* + * This function build a hash parallelagg plan as result_plan as following : + * Finalize Hash Aggregate + * -> Gather + * -> Partial Hash Aggregate + * -> Any partial plan + * The input result_plan will be + * Gather + * -> Any partial plan + * So this function will do the following steps: + * 1. Make a PartialHashAgg and set Gather node as above node + * 2. Change the targetlist of Gather node + * 3. Make a FinalizeHashAgg as top node above the Gather node + */ + +static Plan * +build_hash_parallelagg(PlannerInfo *root, + Query *parse, + List *tlist, + AggClauseCosts *aggcosts, + int numGroupCols, + AttrNumber *grpColIdx, + long numGroups, + Plan *lefttree) +{ + Plan *result_plan = NULL; + Plan *partial_agg_plan = NULL; + Plan *gather_plan = NULL; + List *partial_agg_tlist = NIL; + List *qual = (List*)parse->havingQual; + + AttrNumber *topsortIdx = NULL; + + gather_plan = get_plan(lefttree, T_Gather); + if(gather_plan == NULL) + return NULL; + + /* + * The underlying Agg targetlist should be a flat tlist of all Vars and Aggs + * needed to evaluate the expressions and final values of aggregates present + * in the main target list. The quals also should be included. + */ + partial_agg_tlist = make_partial_agg_tlist(add_qual_in_tlist(tlist, qual), + parse->groupClause); + + /* Make PartialHashAgg plan node */ + partial_agg_plan = (Plan *) make_agg(root, + partial_agg_tlist, + NULL, + AGG_HASHED, + aggcosts, + numGroupCols, + grpColIdx, + extract_grouping_ops(parse->groupClause), + NIL, + numGroups, + false, + false, + gather_plan->lefttree); + + gather_plan->lefttree = partial_agg_plan; + gather_plan->targetlist = partial_agg_plan->targetlist; + + /* + * Get the sortIndex according the subplan + */ + topsortIdx = get_sortIdx_from_subPlan(root,partial_agg_tlist); + + /* Make FinalizeHashAgg plan node */ + result_plan = (Plan *) make_agg(root, + tlist, + (List *) parse->havingQual, + AGG_HASHED, + aggcosts, + numGroupCols, + topsortIdx, + extract_grouping_ops(parse->groupClause), + NIL, + numGroups, + true, + true, + gather_plan); + + return result_plan; +} diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index 12e9290..83855ef 100644 --- a/src/backend/optimizer/plan/setrefs.c +++ b/src/backend/optimizer/plan/setrefs.c @@ -140,6 +140,14 @@ static bool fix_opfuncids_walker(Node *node, void *context); static bool extract_query_dependencies_walker(Node *node, PlannerInfo *context); +static void set_agg_references(PlannerInfo *root, Plan *plan, int rtoffset); +static Node *fix_combine_agg_expr(PlannerInfo *root, + Node *node, + indexed_tlist *subplan_itlist, + Index newvarno, + int rtoffset); +static Node * fix_combine_agg_expr_mutator(Node *node, fix_upper_expr_context *context); + /***************************************************************************** * * SUBPLAN REFERENCES @@ -668,7 +676,7 @@ set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset) } break; case T_Agg: - set_upper_references(root, plan, rtoffset); + set_agg_references(root, plan, rtoffset); break; case T_Group: set_upper_references(root, plan, rtoffset); @@ -2432,3 +2440,212 @@ extract_query_dependencies_walker(Node *node, PlannerInfo *context) return expression_tree_walker(node, extract_query_dependencies_walker, (void *) context); } + + +/* + * set_agg_references + * Update the targetlist and quals of an upper-level plan node + * to refer to the tuples returned by its lefttree subplan. + * Also perform opcode lookup for these expressions, and + * add regclass OIDs to root->glob->relationOids. + * + * This is used for single-input plan types like Agg, Group, Result. + * + * In most cases, we have to match up individual Vars in the tlist and + * qual expressions with elements of the subplan's tlist (which was + * generated by flatten_tlist() from these selfsame expressions, so it + * should have all the required variables). There is an important exception, + * however: GROUP BY and ORDER BY expressions will have been pushed into the + * subplan tlist unflattened. If these values are also needed in the output + * then we want to reference the subplan tlist element rather than recomputing + * the expression. + */ +static void +set_agg_references(PlannerInfo *root, Plan *plan, int rtoffset) +{ + Agg *agg = (Agg*)plan; + Plan *subplan = plan->lefttree; + indexed_tlist *subplan_itlist; + List *output_targetlist; + ListCell *l; + + subplan_itlist = build_tlist_index(subplan->targetlist); + + output_targetlist = NIL; + + if(agg->combineStates) + { + foreach(l, plan->targetlist) + { + TargetEntry *tle = (TargetEntry *) lfirst(l); + Node *newexpr; + + /* If it's a non-Var sort/group item, first try to match by sortref */ + if (tle->ressortgroupref != 0 && !IsA(tle->expr, Var)) + { + newexpr = (Node *) + search_indexed_tlist_for_sortgroupref((Node *) tle->expr, + tle->ressortgroupref, + subplan_itlist, + OUTER_VAR); + if (!newexpr) + newexpr = fix_combine_agg_expr(root, + (Node *) tle->expr, + subplan_itlist, + OUTER_VAR, + rtoffset); + } + else + newexpr = fix_combine_agg_expr(root, + (Node *) tle->expr, + subplan_itlist, + OUTER_VAR, + rtoffset); + tle = flatCopyTargetEntry(tle); + tle->expr = (Expr *) newexpr; + output_targetlist = lappend(output_targetlist, tle); + } + } + else + { + foreach(l, plan->targetlist) + { + TargetEntry *tle = (TargetEntry *) lfirst(l); + Node *newexpr; + + /* If it's a non-Var sort/group item, first try to match by sortref */ + if (tle->ressortgroupref != 0 && !IsA(tle->expr, Var)) + { + newexpr = (Node *) + search_indexed_tlist_for_sortgroupref((Node *) tle->expr, + tle->ressortgroupref, + subplan_itlist, + OUTER_VAR); + if (!newexpr) + newexpr = fix_upper_expr(root, + (Node *) tle->expr, + subplan_itlist, + OUTER_VAR, + rtoffset); + } + else + newexpr = fix_upper_expr(root, + (Node *) tle->expr, + subplan_itlist, + OUTER_VAR, + rtoffset); + tle = flatCopyTargetEntry(tle); + tle->expr = (Expr *) newexpr; + output_targetlist = lappend(output_targetlist, tle); + } + } + + plan->targetlist = output_targetlist; + + plan->qual = (List *) + fix_upper_expr(root, + (Node *) plan->qual, + subplan_itlist, + OUTER_VAR, + rtoffset); + + pfree(subplan_itlist); +} + + +/* + * This function is only used by combineAgg to set the Var nodes as args of + * Aggref reference output of a Gather plan. + */ +static Node * +fix_combine_agg_expr(PlannerInfo *root, + Node *node, + indexed_tlist *subplan_itlist, + Index newvarno, + int rtoffset) +{ + fix_upper_expr_context context; + + context.root = root; + context.subplan_itlist = subplan_itlist; + context.newvarno = newvarno; + context.rtoffset = rtoffset; + return fix_combine_agg_expr_mutator(node, &context); +} + +static Node * +fix_combine_agg_expr_mutator(Node *node, fix_upper_expr_context *context) +{ + Var *newvar; + + if (node == NULL) + return NULL; + if (IsA(node, Var)) + { + Var *var = (Var *) node; + + newvar = search_indexed_tlist_for_var(var, + context->subplan_itlist, + context->newvarno, + context->rtoffset); + if (!newvar) + elog(ERROR, "variable not found in subplan target list"); + return (Node *) newvar; + } + if (IsA(node, Aggref)) + { + TargetEntry *tle; + Aggref *aggref = (Aggref*)node; + List *args = NIL; + + tle = tlist_member(node, context->subplan_itlist->tlist); + if (tle) + { + /* Found a matching subplan output expression */ + Var *newvar; + TargetEntry *newtle; + + newvar = makeVarFromTargetEntry(context->newvarno, tle); + newvar->varnoold = 0; /* wasn't ever a plain Var */ + newvar->varoattno = 0; + + /* update the args in the aggref */ + + /* makeTargetEntry ,always set resno to one for finialize agg */ + newtle = makeTargetEntry((Expr*)newvar,1,NULL,false); + args = lappend(args,newtle); + + /* + * Updated the args, let the newvar refer to the right position of + * the agg function in the subplan + */ + aggref->args = args; + + return (Node *) aggref; + } + } + if (IsA(node, PlaceHolderVar)) + { + PlaceHolderVar *phv = (PlaceHolderVar *) node; + + /* See if the PlaceHolderVar has bubbled up from a lower plan node */ + if (context->subplan_itlist->has_ph_vars) + { + newvar = search_indexed_tlist_for_non_var((Node *) phv, + context->subplan_itlist, + context->newvarno); + if (newvar) + return (Node *) newvar; + } + /* If not supplied by input plan, evaluate the contained expr */ + return fix_upper_expr_mutator((Node *) phv->phexpr, context); + } + if (IsA(node, Param)) + return fix_param_node(context->root, (Param *) node); + + fix_expr_common(context->root, node); + return expression_tree_mutator(node, + fix_combine_agg_expr_mutator, + (void *) context); +} + diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 00f5ce3..ee6dfa8 100644 --- a/src/backend/optimizer/util/clauses.c +++ b/src/backend/optimizer/util/clauses.c @@ -52,6 +52,7 @@ #include "utils/syscache.h" #include "utils/typcache.h" + typedef struct { PlannerInfo *root; diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index ec0910d..4677a44 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -217,7 +217,12 @@ compare_path_costs_fuzzily(Path *path1, Path *path2, double fuzz_factor) * The cheapest_parameterized_paths list collects all parameterized paths * that have survived the add_path() tournament for this relation. (Since * add_path ignores pathkeys for a parameterized path, these will be paths - * that have best cost or best row count for their parameterization.) + * that have best cost or best row count for their parameterization. We + * may also have both a parallel-safe and a non-parallel-safe path in some + * cases for the same parameterization in some cases, but this should be + * relatively rare since, most typically, all paths for the same relation + * will be parallel-safe or none of them will.) + * * cheapest_parameterized_paths always includes the cheapest-total * unparameterized path, too, if there is one; the users of that list find * it more convenient if that's included. @@ -352,11 +357,12 @@ set_cheapest(RelOptInfo *parent_rel) * A path is worthy if it has a better sort order (better pathkeys) or * cheaper cost (on either dimension), or generates fewer rows, than any * existing path that has the same or superset parameterization rels. + * We also consider parallel-safe paths more worthy than others. * * We also remove from the rel's pathlist any old paths that are dominated * by new_path --- that is, new_path is cheaper, at least as well ordered, - * generates no more rows, and requires no outer rels not required by the - * old path. + * generates no more rows, requires no outer rels not required by the old + * path, and is no less parallel-safe. * * In most cases, a path with a superset parameterization will generate * fewer rows (since it has more join clauses to apply), so that those two @@ -470,14 +476,16 @@ add_path(RelOptInfo *parent_rel, Path *new_path) { if ((outercmp == BMS_EQUAL || outercmp == BMS_SUBSET1) && - new_path->rows <= old_path->rows) + new_path->rows <= old_path->rows && + new_path->parallel_safe >= old_path->parallel_safe) remove_old = true; /* new dominates old */ } else if (keyscmp == PATHKEYS_BETTER2) { if ((outercmp == BMS_EQUAL || outercmp == BMS_SUBSET2) && - new_path->rows >= old_path->rows) + new_path->rows >= old_path->rows && + new_path->parallel_safe <= old_path->parallel_safe) accept_new = false; /* old dominates new */ } else /* keyscmp == PATHKEYS_EQUAL */ @@ -487,19 +495,25 @@ add_path(RelOptInfo *parent_rel, Path *new_path) /* * Same pathkeys and outer rels, and fuzzily * the same cost, so keep just one; to decide - * which, first check rows and then do a fuzzy - * cost comparison with very small fuzz limit. - * (We used to do an exact cost comparison, - * but that results in annoying - * platform-specific plan variations due to - * roundoff in the cost estimates.) If things - * are still tied, arbitrarily keep only the - * old path. Notice that we will keep only - * the old path even if the less-fuzzy - * comparison decides the startup and total - * costs compare differently. + * which, first check parallel-safety, then + * rows, then do a fuzzy cost comparison with + * very small fuzz limit. (We used to do an + * exact cost comparison, but that results in + * annoying platform-specific plan variations + * due to roundoff in the cost estimates.) If + * things are still tied, arbitrarily keep + * only the old path. Notice that we will + * keep only the old path even if the + * less-fuzzy comparison decides the startup + * and total costs compare differently. */ - if (new_path->rows < old_path->rows) + if (new_path->parallel_safe > + old_path->parallel_safe) + remove_old = true; /* new dominates old */ + else if (new_path->parallel_safe < + old_path->parallel_safe) + accept_new = false; /* old dominates new */ + else if (new_path->rows < old_path->rows) remove_old = true; /* new dominates old */ else if (new_path->rows > old_path->rows) accept_new = false; /* old dominates new */ @@ -512,10 +526,12 @@ add_path(RelOptInfo *parent_rel, Path *new_path) * dominates new */ } else if (outercmp == BMS_SUBSET1 && - new_path->rows <= old_path->rows) + new_path->rows <= old_path->rows && + new_path->parallel_safe >= old_path->parallel_safe) remove_old = true; /* new dominates old */ else if (outercmp == BMS_SUBSET2 && - new_path->rows >= old_path->rows) + new_path->rows >= old_path->rows && + new_path->parallel_safe <= old_path->parallel_safe) accept_new = false; /* old dominates new */ /* else different parameterizations, keep both */ } @@ -527,7 +543,8 @@ add_path(RelOptInfo *parent_rel, Path *new_path) PATH_REQ_OUTER(old_path)); if ((outercmp == BMS_EQUAL || outercmp == BMS_SUBSET1) && - new_path->rows <= old_path->rows) + new_path->rows <= old_path->rows && + new_path->parallel_safe >= old_path->parallel_safe) remove_old = true; /* new dominates old */ } break; @@ -538,7 +555,8 @@ add_path(RelOptInfo *parent_rel, Path *new_path) PATH_REQ_OUTER(old_path)); if ((outercmp == BMS_EQUAL || outercmp == BMS_SUBSET2) && - new_path->rows >= old_path->rows) + new_path->rows >= old_path->rows && + new_path->parallel_safe <= old_path->parallel_safe) accept_new = false; /* old dominates new */ } break; @@ -685,6 +703,214 @@ add_path_precheck(RelOptInfo *parent_rel, return true; } +/* + * add_partial_path + * Like add_path, our goal here is to consider whether a path is worthy + * of being kept around, but the considerations here are a bit different. + * A partial path is one which can be executed in any number of workers in + * parallel such that each worker will generate a subset of the path's + * overall result. + * + * We don't generate parameterized partial paths for several reasons. Most + * importantly, they're not safe to execute, because there's nothing to + * make sure that a parallel scan within the parameterized portion of the + * plan is running with the same value in every worker at the same time. + * Fortunately, it seems unlikely to be worthwhile anyway, because having + * each worker scan the entire outer relation and a subset of the inner + * relation will generally be a terrible plan. The inner (parameterized) + * side of the plan will be small anyway. There could be rare cases where + * this wins big - e.g. if join order constraints put a 1-row relation on + * the outer side of the topmost join with a parameterized plan on the inner + * side - but we'll have to be content not to handle such cases until somebody + * builds an executor infrastructure that can cope with them. + * + * Because we don't consider parameterized paths here, we also don't + * need to consider the row counts as a measure of quality: every path will + * produce the same number of rows. Neither do we need to consider startup + * costs: parallelism is only used for plans that will be run to completion. + * Therefore, this routine is much simpler than add_path: it needs to + * consider only pathkeys and total cost. + */ +void +add_partial_path(RelOptInfo *parent_rel, Path *new_path) +{ + bool accept_new = true; /* unless we find a superior old path */ + ListCell *insert_after = NULL; /* where to insert new item */ + ListCell *p1; + ListCell *p1_prev; + ListCell *p1_next; + + /* Check for query cancel. */ + CHECK_FOR_INTERRUPTS(); + + /* + * As in add_path, throw out any paths which are dominated by the new + * path, but throw out the new path if some existing path dominates it. + */ + p1_prev = NULL; + for (p1 = list_head(parent_rel->partial_pathlist); p1 != NULL; + p1 = p1_next) + { + Path *old_path = (Path *) lfirst(p1); + bool remove_old = false; /* unless new proves superior */ + PathKeysComparison keyscmp; + + p1_next = lnext(p1); + + /* Compare pathkeys. */ + keyscmp = compare_pathkeys(new_path->pathkeys, old_path->pathkeys); + + /* Unless pathkeys are incompable, keep just one of the two paths. */ + if (keyscmp != PATHKEYS_DIFFERENT) + { + if (new_path->total_cost > old_path->total_cost * STD_FUZZ_FACTOR) + { + /* New path costs more; keep it only if pathkeys are better. */ + if (keyscmp != PATHKEYS_BETTER1) + accept_new = false; + } + else if (old_path->total_cost > new_path->total_cost + * STD_FUZZ_FACTOR) + { + /* Old path costs more; keep it only if pathkeys are better. */ + if (keyscmp != PATHKEYS_BETTER2) + remove_old = true; + } + else if (keyscmp == PATHKEYS_BETTER1) + { + /* Costs are about the same, new path has better pathkeys. */ + remove_old = true; + } + else if (keyscmp == PATHKEYS_BETTER2) + { + /* Costs are about the same, old path has better pathkeys. */ + accept_new = false; + } + else if (old_path->total_cost > new_path->total_cost * 1.0000000001) + { + /* Pathkeys are the same, and the old path costs more. */ + remove_old = true; + } + else + { + /* + * Pathkeys are the same, and new path isn't materially + * cheaper. + */ + accept_new = false; + } + } + + /* + * Remove current element from partial_pathlist if dominated by new. + */ + if (remove_old) + { + parent_rel->partial_pathlist = + list_delete_cell(parent_rel->partial_pathlist, p1, p1_prev); + /* add_path has a special case for IndexPath; we don't need it */ + Assert(!IsA(old_path, IndexPath)); + pfree(old_path); + /* p1_prev does not advance */ + } + else + { + /* new belongs after this old path if it has cost >= old's */ + if (new_path->total_cost >= old_path->total_cost) + insert_after = p1; + /* p1_prev advances */ + p1_prev = p1; + } + + /* + * If we found an old path that dominates new_path, we can quit + * scanning the partial_pathlist; we will not add new_path, and we + * assume new_path cannot dominate any later path. + */ + if (!accept_new) + break; + } + + if (accept_new) + { + /* Accept the new path: insert it at proper place */ + if (insert_after) + lappend_cell(parent_rel->partial_pathlist, insert_after, new_path); + else + parent_rel->partial_pathlist = + lcons(new_path, parent_rel->partial_pathlist); + } + else + { + /* add_path has a special case for IndexPath; we don't need it */ + Assert(!IsA(new_path, IndexPath)); + /* Reject and recycle the new path */ + pfree(new_path); + } +} + +/* + * add_partial_path_precheck + * Check whether a proposed new partial path could possibly get accepted. + * + * Unlike add_path_precheck, we can ignore startup cost and parameterization, + * since they don't matter for partial paths (see add_partial_path). But + * we do want to make sure we don't add a partial path if there's already + * a complete path that dominates it, since in that case the proposed path + * is surely a loser. + */ +bool +add_partial_path_precheck(RelOptInfo *parent_rel, Cost total_cost, + List *pathkeys) +{ + ListCell *p1; + + /* + * Our goal here is twofold. First, we want to find out whether this path + * is clearly inferior to some existing partial path. If so, we want to + * reject it immediately. Second, we want to find out whether this path + * is clearly superior to some existing partial path -- at least, modulo + * final cost computations. If so, we definitely want to consider it. + * + * Unlike add_path(), we always compare pathkeys here. This is because we + * expect partial_pathlist to be very short, and getting a definitive + * answer at this stage avoids the need to call add_path_precheck. + */ + foreach(p1, parent_rel->partial_pathlist) + { + Path *old_path = (Path *) lfirst(p1); + PathKeysComparison keyscmp; + + keyscmp = compare_pathkeys(pathkeys, old_path->pathkeys); + if (keyscmp != PATHKEYS_DIFFERENT) + { + if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR && + keyscmp != PATHKEYS_BETTER1) + return false; + if (old_path->total_cost > total_cost * STD_FUZZ_FACTOR && + keyscmp != PATHKEYS_BETTER2) + return true; + } + } + + /* + * This path is neither clearly inferior to an existing partial path nor + * clearly good enough that it might replace one. Compare it to + * non-parallel plans. If it loses even before accounting for the cost of + * the Gather node, we should definitely reject it. + * + * Note that we pass the total_cost to add_path_precheck twice. This is + * because it's never advantageous to consider the startup cost of a + * partial path; the resulting plans, if run in parallel, will be run to + * completion. + */ + if (!add_path_precheck(parent_rel, total_cost, total_cost, pathkeys, + NULL)) + return false; + + return true; +} + /***************************************************************************** * PATH NODE CREATION ROUTINES @@ -697,7 +923,7 @@ add_path_precheck(RelOptInfo *parent_rel, */ Path * create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, - Relids required_outer, int nworkers) + Relids required_outer, int parallel_degree) { Path *pathnode = makeNode(Path); @@ -705,10 +931,12 @@ create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, pathnode->parent = rel; pathnode->param_info = get_baserel_parampathinfo(root, rel, required_outer); - pathnode->parallel_aware = nworkers > 0 ? true : false; + pathnode->parallel_aware = parallel_degree > 0 ? true : false; + pathnode->parallel_safe = rel->consider_parallel; + pathnode->parallel_degree = parallel_degree; pathnode->pathkeys = NIL; /* seqscan has unordered result */ - cost_seqscan(pathnode, root, rel, pathnode->param_info, nworkers); + cost_seqscan(pathnode, root, rel, pathnode->param_info); return pathnode; } @@ -727,6 +955,8 @@ create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer pathnode->param_info = get_baserel_parampathinfo(root, rel, required_outer); pathnode->parallel_aware = false; + pathnode->parallel_safe = rel->consider_parallel; + pathnode->parallel_degree = 0; pathnode->pathkeys = NIL; /* samplescan has unordered result */ cost_samplescan(pathnode, root, rel, pathnode->param_info); @@ -781,6 +1011,8 @@ create_index_path(PlannerInfo *root, pathnode->path.param_info = get_baserel_parampathinfo(root, rel, required_outer); pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = rel->consider_parallel; + pathnode->path.parallel_degree = 0; pathnode->path.pathkeys = pathkeys; /* Convert clauses to indexquals the executor can handle */ @@ -827,6 +1059,8 @@ create_bitmap_heap_path(PlannerInfo *root, pathnode->path.param_info = get_baserel_parampathinfo(root, rel, required_outer); pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = bitmapqual->parallel_safe; + pathnode->path.parallel_degree = 0; pathnode->path.pathkeys = NIL; /* always unordered */ pathnode->bitmapqual = bitmapqual; @@ -852,7 +1086,17 @@ create_bitmap_and_path(PlannerInfo *root, pathnode->path.pathtype = T_BitmapAnd; pathnode->path.parent = rel; pathnode->path.param_info = NULL; /* not used in bitmap trees */ + + /* + * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be + * parallel-safe if and only if rel->consider_parallel is set. So, we can + * set the flag for this path based only on the relation-level flag, + * without actually iterating over the list of children. + */ pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = rel->consider_parallel; + pathnode->path.parallel_degree = 0; + pathnode->path.pathkeys = NIL; /* always unordered */ pathnode->bitmapquals = bitmapquals; @@ -877,7 +1121,17 @@ create_bitmap_or_path(PlannerInfo *root, pathnode->path.pathtype = T_BitmapOr; pathnode->path.parent = rel; pathnode->path.param_info = NULL; /* not used in bitmap trees */ + + /* + * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be + * parallel-safe if and only if rel->consider_parallel is set. So, we can + * set the flag for this path based only on the relation-level flag, + * without actually iterating over the list of children. + */ pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = rel->consider_parallel; + pathnode->path.parallel_degree = 0; + pathnode->path.pathkeys = NIL; /* always unordered */ pathnode->bitmapquals = bitmapquals; @@ -903,6 +1157,8 @@ create_tidscan_path(PlannerInfo *root, RelOptInfo *rel, List *tidquals, pathnode->path.param_info = get_baserel_parampathinfo(root, rel, required_outer); pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = rel->consider_parallel; + pathnode->path.parallel_degree = 0; pathnode->path.pathkeys = NIL; /* always unordered */ pathnode->tidquals = tidquals; @@ -1328,19 +1584,30 @@ create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, */ GatherPath * create_gather_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, - Relids required_outer, int nworkers) + Relids required_outer) { GatherPath *pathnode = makeNode(GatherPath); + Assert(subpath->parallel_safe); + pathnode->path.pathtype = T_Gather; pathnode->path.parent = rel; pathnode->path.param_info = get_baserel_parampathinfo(root, rel, required_outer); pathnode->path.parallel_aware = false; + pathnode->path.parallel_safe = false; + pathnode->path.parallel_degree = subpath->parallel_degree; pathnode->path.pathkeys = NIL; /* Gather has unordered result */ pathnode->subpath = subpath; - pathnode->num_workers = nworkers; + pathnode->single_copy = false; + + if (pathnode->path.parallel_degree == 0) + { + pathnode->path.parallel_degree = 1; + pathnode->path.pathkeys = subpath->pathkeys; + pathnode->single_copy = true; + } cost_gather(pathnode, root, rel, pathnode->path.param_info); diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index f2bdfcc..ba6a6f9 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -107,6 +107,7 @@ build_simple_rel(PlannerInfo *root, int relid, RelOptKind reloptkind) rel->reltargetlist = NIL; rel->pathlist = NIL; rel->ppilist = NIL; + rel->partial_pathlist = NIL; rel->cheapest_startup_path = NULL; rel->cheapest_total_path = NULL; rel->cheapest_unique_path = NULL; diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index a185749..63cde6b 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -828,6 +828,15 @@ static struct config_bool ConfigureNamesBool[] = NULL, NULL, NULL }, { + {"enable_parallelagg", PGC_USERSET, QUERY_TUNING_METHOD, + gettext_noop("Enables the planner's use of parallel agg plans."), + NULL + }, + &enable_parallelagg, + true, + NULL, NULL, NULL + }, + { {"enable_material", PGC_USERSET, QUERY_TUNING_METHOD, gettext_noop("Enables the planner's use of materialization."), NULL diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h index 5393005..f9f13b4 100644 --- a/src/include/nodes/relation.h +++ b/src/include/nodes/relation.h @@ -458,6 +458,7 @@ typedef struct RelOptInfo List *reltargetlist; /* Vars to be output by scan of relation */ List *pathlist; /* Path structures */ List *ppilist; /* ParamPathInfos used in pathlist */ + List *partial_pathlist; /* partial Paths */ struct Path *cheapest_startup_path; struct Path *cheapest_total_path; struct Path *cheapest_unique_path; @@ -759,6 +760,8 @@ typedef struct Path RelOptInfo *parent; /* the relation this path can build */ ParamPathInfo *param_info; /* parameterization info, or NULL if none */ bool parallel_aware; /* engage parallel-aware logic? */ + bool parallel_safe; /* OK to use as part of parallel plan? */ + int parallel_degree; /* desired parallel degree; 0 = not parallel */ /* estimated size/costs for path (see costsize.c for more info) */ double rows; /* estimated number of result tuples */ @@ -1062,7 +1065,6 @@ typedef struct GatherPath { Path path; Path *subpath; /* path for each worker */ - int num_workers; /* number of workers sought to help */ bool single_copy; /* path must not be executed >1x */ } GatherPath; diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h index ac21a3a..80bd068 100644 --- a/src/include/optimizer/cost.h +++ b/src/include/optimizer/cost.h @@ -62,6 +62,7 @@ extern bool enable_bitmapscan; extern bool enable_tidscan; extern bool enable_sort; extern bool enable_hashagg; +extern bool enable_parallelagg; extern bool enable_nestloop; extern bool enable_material; extern bool enable_mergejoin; @@ -72,7 +73,7 @@ extern double clamp_row_est(double nrows); extern double index_pages_fetched(double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root); extern void cost_seqscan(Path *path, PlannerInfo *root, RelOptInfo *baserel, - ParamPathInfo *param_info, int nworkers); + ParamPathInfo *param_info); extern void cost_samplescan(Path *path, PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info); extern void cost_index(IndexPath *path, PlannerInfo *root, diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h index 8fb9eda..9538f3f 100644 --- a/src/include/optimizer/pathnode.h +++ b/src/include/optimizer/pathnode.h @@ -29,9 +29,12 @@ extern void add_path(RelOptInfo *parent_rel, Path *new_path); extern bool add_path_precheck(RelOptInfo *parent_rel, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer); +extern void add_partial_path(RelOptInfo *parent_rel, Path *new_path); +extern bool add_partial_path_precheck(RelOptInfo *parent_rel, + Cost total_cost, List *pathkeys); extern Path *create_seqscan_path(PlannerInfo *root, RelOptInfo *rel, - Relids required_outer, int nworkers); + Relids required_outer, int parallel_degree); extern Path *create_samplescan_path(PlannerInfo *root, RelOptInfo *rel, Relids required_outer); extern IndexPath *create_index_path(PlannerInfo *root, @@ -70,8 +73,7 @@ extern MaterialPath *create_material_path(RelOptInfo *rel, Path *subpath); extern UniquePath *create_unique_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, SpecialJoinInfo *sjinfo); extern GatherPath *create_gather_path(PlannerInfo *root, - RelOptInfo *rel, Path *subpath, Relids required_outer, - int nworkers); + RelOptInfo *rel, Path *subpath, Relids required_outer); extern Path *create_subqueryscan_path(PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer); extern Path *create_functionscan_path(PlannerInfo *root, RelOptInfo *rel, diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h index 7757741..4b01850 100644 --- a/src/include/optimizer/paths.h +++ b/src/include/optimizer/paths.h @@ -50,6 +50,8 @@ extern RelOptInfo *make_one_rel(PlannerInfo *root, List *joinlist); extern RelOptInfo *standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels); +extern void generate_gather_paths(PlannerInfo *root, RelOptInfo *rel); + #ifdef OPTIMIZER_DEBUG extern void debug_print_rel(PlannerInfo *root, RelOptInfo *rel); #endif