Preparatory refactoring for parallel merge join support.

Extract the logic used by hash_inner_and_outer into a separate
function, get_cheapest_parallel_safe_total_inner, so that it can
also be used to plan parallel merge joins.

Also, add a require_parallel_safe argument to the existing function
get_cheapest_path_for_pathkeys, because parallel merge join needs
to find the cheapest path for a given set of pathkeys that is
parallel-safe, not just the cheapest one overall.

Patch by me, reviewed by Dilip Kumar.

Discussion: http://postgr.es/m/CA+TgmoYOv+dFK0MWW6366dFj_xTnohQfoBDrHyB7d1oZhrgPjA@mail.gmail.com

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 633b5c1608d0d649431d4bb18150b6a3610f9764..87a3faff09db2ff0537ed30728677fdc0338161a 100644 (file)
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1447,12 +1447,14 @@ generate_mergeappend_paths(PlannerInfo *root, RelOptInfo *rel,
                                get_cheapest_path_for_pathkeys(childrel->pathlist,
                                                                                           pathkeys,
                                                                                           NULL,
-                                                                                          STARTUP_COST);
+                                                                                          STARTUP_COST,
+                                                                                          false);
                        cheapest_total =
                                get_cheapest_path_for_pathkeys(childrel->pathlist,
                                                                                           pathkeys,
                                                                                           NULL,
-                                                                                          TOTAL_COST);
+                                                                                          TOTAL_COST,
+                                                                                          false);
 
                        /*
                         * If we can't find any paths with the right order just use the
@@ -1517,7 +1519,8 @@ get_cheapest_parameterized_child_path(PlannerInfo *root, RelOptInfo *rel,
        cheapest = get_cheapest_path_for_pathkeys(rel->pathlist,
                                                                                          NIL,
                                                                                          required_outer,
-                                                                                         TOTAL_COST);
+                                                                                         TOTAL_COST,
+                                                                                         false);
        Assert(cheapest != NULL);
        if (bms_equal(PATH_REQ_OUTER(cheapest), required_outer))
                return cheapest;

diff --git a/src/backend/optimizer/path/joinpath.c b/src/backend/optimizer/path/joinpath.c
index 99ec5834bfbf001780ad1d002d507c246a3d1cab..8bb5473330398015074714f0e84577752d51b4e5 100644 (file)
--- a/src/backend/optimizer/path/joinpath.c
+++ b/src/backend/optimizer/path/joinpath.c
@@ -936,7 +936,8 @@ generate_mergejoin_paths(PlannerInfo *root,
                innerpath = get_cheapest_path_for_pathkeys(innerrel->pathlist,
                                                                                                   trialsortkeys,
                                                                                                   NULL,
-                                                                                                  TOTAL_COST);
+                                                                                                  TOTAL_COST,
+                                                                                                  false);
                if (innerpath != NULL &&
                        (cheapest_total_inner == NULL ||
                         compare_path_costs(innerpath, cheapest_total_inner,
@@ -971,7 +972,8 @@ generate_mergejoin_paths(PlannerInfo *root,
                innerpath = get_cheapest_path_for_pathkeys(innerrel->pathlist,
                                                                                                   trialsortkeys,
                                                                                                   NULL,
-                                                                                                  STARTUP_COST);
+                                                                                                  STARTUP_COST,
+                                                                                                  false);
                if (innerpath != NULL &&
                        (cheapest_startup_inner == NULL ||
                         compare_path_costs(innerpath, cheapest_startup_inner,
@@ -1517,21 +1519,8 @@ hash_inner_and_outer(PlannerInfo *root,
                        if (cheapest_total_inner->parallel_safe)
                                cheapest_safe_inner = cheapest_total_inner;
                        else if (save_jointype != JOIN_UNIQUE_INNER)
-                       {
-                               ListCell   *lc;
-
-                               foreach(lc, innerrel->pathlist)
-                               {
-                                       Path       *innerpath = (Path *) lfirst(lc);
-
-                                       if (innerpath->parallel_safe &&
-                                               bms_is_empty(PATH_REQ_OUTER(innerpath)))
-                                       {
-                                               cheapest_safe_inner = innerpath;
-                                               break;
-                                       }
-                               }
-                       }
+                               cheapest_safe_inner =
+                                       get_cheapest_parallel_safe_total_inner(innerrel->pathlist);
 
                        if (cheapest_safe_inner != NULL)
                                try_partial_hashjoin_path(root, joinrel,

diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
index 1065b31ad107fcb431c9aec64f8ef4417e0a9d85..2c269062ecd0e8cea3d96fa0d516770a2736b19d 100644 (file)
--- a/src/backend/optimizer/path/pathkeys.c
+++ b/src/backend/optimizer/path/pathkeys.c
@@ -337,11 +337,13 @@ pathkeys_contained_in(List *keys1, List *keys2)
  * 'pathkeys' represents a required ordering (in canonical form!)
  * 'required_outer' denotes allowable outer relations for parameterized paths
  * 'cost_criterion' is STARTUP_COST or TOTAL_COST
+ * 'require_parallel_safe' causes us to consider only parallel-safe paths
  */
 Path *
 get_cheapest_path_for_pathkeys(List *paths, List *pathkeys,
                                                           Relids required_outer,
-                                                          CostSelector cost_criterion)
+                                                          CostSelector cost_criterion,
+                                                          bool require_parallel_safe)
 {
        Path       *matched_path = NULL;
        ListCell   *l;
@@ -358,6 +360,9 @@ get_cheapest_path_for_pathkeys(List *paths, List *pathkeys,
                        compare_path_costs(matched_path, path, cost_criterion) <= 0)
                        continue;
 
+               if (require_parallel_safe && !path->parallel_safe)
+                       continue;
+
                if (pathkeys_contained_in(pathkeys, path->pathkeys) &&
                        bms_is_subset(PATH_REQ_OUTER(path), required_outer))
                        matched_path = path;
@@ -407,6 +412,28 @@ get_cheapest_fractional_path_for_pathkeys(List *paths,
        return matched_path;
 }
 
+
+/*
+ * get_cheapest_parallel_safe_total_inner
+ *       Find the unparameterized parallel-safe path with the least total cost.
+ */
+Path *
+get_cheapest_parallel_safe_total_inner(List *paths)
+{
+       ListCell   *l;
+
+       foreach(l, paths)
+       {
+               Path       *innerpath = (Path *) lfirst(l);
+
+               if (innerpath->parallel_safe &&
+                       bms_is_empty(PATH_REQ_OUTER(innerpath)))
+                       return innerpath;
+       }
+
+       return NULL;
+}
+
 /****************************************************************************
  *             NEW PATHKEY FORMATION
  ****************************************************************************/

diff --git a/src/include/optimizer/paths.h b/src/include/optimizer/paths.h
index ebda308c4166da190976ed881a00676cc386279d..bc0dcf4468f2eb1d780fb35d5a826e6bbda2ecd3 100644 (file)
--- a/src/include/optimizer/paths.h
+++ b/src/include/optimizer/paths.h
@@ -182,11 +182,13 @@ extern PathKeysComparison compare_pathkeys(List *keys1, List *keys2);
 extern bool pathkeys_contained_in(List *keys1, List *keys2);
 extern Path *get_cheapest_path_for_pathkeys(List *paths, List *pathkeys,
                                                           Relids required_outer,
-                                                          CostSelector cost_criterion);
+                                                          CostSelector cost_criterion,
+                                                          bool require_parallel_safe);
 extern Path *get_cheapest_fractional_path_for_pathkeys(List *paths,
                                                                                  List *pathkeys,
                                                                                  Relids required_outer,
                                                                                  double fraction);
+extern Path *get_cheapest_parallel_safe_total_inner(List *paths);
 extern List *build_index_pathkeys(PlannerInfo *root, IndexOptInfo *index,
                                         ScanDirection scandir);
 extern List *build_expression_pathkey(PlannerInfo *root, Expr *expr,