diff --git a/src/backend/optimizer/plan/planagg.c b/src/backend/optimizer/plan/planagg.c index cefec7b..0434a5a 100644 --- a/src/backend/optimizer/plan/planagg.c +++ b/src/backend/optimizer/plan/planagg.c @@ -465,7 +465,8 @@ build_minmax_path(PlannerInfo *root, MinMaxAggInfo *mminfo, * cheapest path.) */ sorted_path = apply_projection_to_path(subroot, final_rel, sorted_path, - create_pathtarget(subroot, tlist)); + create_pathtarget(subroot, tlist), + false); /* * Determine cost to get just the first row of the presorted path. diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index 07b925e..b04e729 100644 --- a/src/backend/optimizer/plan/planner.c +++ b/src/backend/optimizer/plan/planner.c @@ -1500,6 +1500,7 @@ grouping_planner(PlannerInfo *root, bool inheritance_update, PathTarget *grouping_target; PathTarget *scanjoin_target; bool have_grouping; + bool scanjoin_target_parallel_safe = false; WindowFuncLists *wflists = NULL; List *activeWindows = NIL; List *rollup_lists = NIL; @@ -1729,6 +1730,11 @@ grouping_planner(PlannerInfo *root, bool inheritance_update, else scanjoin_target = grouping_target; + /* check if scanjoin target is parallel safe */ + if (current_rel->partial_pathlist && + !has_parallel_hazard((Node *) scanjoin_target->exprs, false)) + scanjoin_target_parallel_safe = true; + /* * Forcibly apply that target to all the Paths for the scan/join rel. * @@ -1746,7 +1752,8 @@ grouping_planner(PlannerInfo *root, bool inheritance_update, Assert(subpath->param_info == NULL); path = apply_projection_to_path(root, current_rel, - subpath, scanjoin_target); + subpath, scanjoin_target, + scanjoin_target_parallel_safe); /* If we had to add a Result, path is different from subpath */ if (path != subpath) { @@ -1759,6 +1766,27 @@ grouping_planner(PlannerInfo *root, bool inheritance_update, } /* + * Likewise for any partial paths if the target is parallel safe, + * although this case is simpler, since we don't track the cheapest + * path. If the scanjoin target is not safe, then we can't even + * generate parallel paths for upper rels. + */ + if (scanjoin_target_parallel_safe) + { + foreach(lc, current_rel->partial_pathlist) + { + Path *subpath = (Path *) lfirst(lc); + + Assert(subpath->param_info == NULL); + lfirst(lc) = apply_projection_to_path(root, current_rel, + subpath, scanjoin_target, + scanjoin_target_parallel_safe); + } + } + else + current_rel->partial_pathlist = NIL; + + /* * Save the various upper-rel PathTargets we just computed into * root->upper_targets[]. The core code doesn't use this, but it * provides a convenient place for extensions to get at the info. For @@ -4153,7 +4181,7 @@ create_ordered_paths(PlannerInfo *root, /* Add projection step if needed */ if (path->pathtarget != target) path = apply_projection_to_path(root, ordered_rel, - path, target); + path, target, false); add_path(ordered_rel, path); } diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c index 552b756..30975e0 100644 --- a/src/backend/optimizer/prep/prepunion.c +++ b/src/backend/optimizer/prep/prepunion.c @@ -325,7 +325,8 @@ recurse_set_operations(Node *setOp, PlannerInfo *root, refnames_tlist); path = apply_projection_to_path(root, rel, path, - create_pathtarget(root, tlist)); + create_pathtarget(root, tlist), + false); /* Return the fully-fledged tlist to caller, too */ *pTargetList = tlist; @@ -394,7 +395,8 @@ recurse_set_operations(Node *setOp, PlannerInfo *root, path->parent, path, create_pathtarget(root, - *pTargetList)); + *pTargetList), + false); } return path; } diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c index 6b57de3..6d4901e 100644 --- a/src/backend/optimizer/util/pathnode.c +++ b/src/backend/optimizer/util/pathnode.c @@ -2217,12 +2217,14 @@ create_projection_path(PlannerInfo *root, * 'rel' is the parent relation associated with the result * 'path' is the path representing the source of data * 'target' is the PathTarget to be computed + * 'target_parallel' indicates that target is parallel safe */ Path * apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, - PathTarget *target) + PathTarget *target, + bool target_parallel) { QualCost oldcost; @@ -2248,8 +2250,7 @@ apply_projection_to_path(PlannerInfo *root, * project. But if there is something that is not parallel-safe in the * target expressions, then we can't. */ - if (IsA(path, GatherPath) && - !has_parallel_hazard((Node *) target->exprs, false)) + if (IsA(path, GatherPath) && target_parallel) { GatherPath *gpath = (GatherPath *) path; diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h index 5de4c34..586ecdd 100644 --- a/src/include/optimizer/pathnode.h +++ b/src/include/optimizer/pathnode.h @@ -143,7 +143,8 @@ extern ProjectionPath *create_projection_path(PlannerInfo *root, extern Path *apply_projection_to_path(PlannerInfo *root, RelOptInfo *rel, Path *path, - PathTarget *target); + PathTarget *target, + bool target_parallel); extern SortPath *create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath,