Consider Parallel Append of partial paths for UNION [ALL].

Without this patch, we can implement a UNION or UNION ALL as an
Append where Gather appears beneath one or more of the Append
branches, but this lets us put the Gather node on top, with
a partial path for each relation underneath.

There is considerably more work that could be done to improve
planning in this area, but that will probably need to wait
for a future release.

Patch by me, reviewed and tested by Ashutosh Bapat and Rajkumar
Raghuwanshi.

Discussion: http://postgr.es/m/CA+TgmoaLRAOqHmMZx=ESM3VDEPceg+-XXZsRXQ8GtFJO_zbMSw@mail.gmail.com

diff --git a/src/backend/optimizer/prep/prepunion.c b/src/backend/optimizer/prep/prepunion.c
index f087369f75358421ffdb67a15bce5d92512394ec..6e510f9d94af87eeed14689f42005d744768a0fb 100644 (file)
--- a/src/backend/optimizer/prep/prepunion.c
+++ b/src/backend/optimizer/prep/prepunion.c
@@ -298,12 +298,18 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
         */
        set_subquery_size_estimates(root, rel);
 
+       /*
+        * Since we may want to add a partial path to this relation, we must
+        * set its consider_parallel flag correctly.
+        */
+       final_rel = fetch_upper_rel(subroot, UPPERREL_FINAL, NULL);
+       rel->consider_parallel = final_rel->consider_parallel;
+
        /*
         * For the moment, we consider only a single Path for the subquery.
         * This should change soon (make it look more like
         * set_subquery_pathlist).
         */
-       final_rel = fetch_upper_rel(subroot, UPPERREL_FINAL, NULL);
        subpath = get_cheapest_fractional_path(final_rel,
                                               root->tuple_fraction);
 
@@ -320,6 +326,23 @@ recurse_set_operations(Node *setOp, PlannerInfo *root,
 
        add_path(rel, path);
 
+       /*
+        * If we have a partial path for the child relation, we can use that
+        * to build a partial path for this relation.  But there's no point in
+        * considering any path but the cheapest.
+        */
+       if (final_rel->partial_pathlist != NIL)
+       {
+           Path       *partial_subpath;
+           Path       *partial_path;
+
+           partial_subpath = linitial(final_rel->partial_pathlist);
+           partial_path = (Path *)
+               create_subqueryscan_path(root, rel, partial_subpath,
+                                        NIL, NULL);
+           add_partial_path(rel, partial_path);
+       }
+
        /*
         * Estimate number of groups if caller wants it.  If the subquery used
         * grouping or aggregation, its output is probably mostly unique
@@ -552,6 +575,9 @@ generate_union_paths(SetOperationStmt *op, PlannerInfo *root,
    double      save_fraction = root->tuple_fraction;
    ListCell   *lc;
    List       *pathlist = NIL;
+   List       *partial_pathlist = NIL;
+   bool        partial_paths_valid = true;
+   bool        consider_parallel = true;
    List       *rellist;
    List       *tlist_list;
    List       *tlist;
@@ -591,18 +617,34 @@ generate_union_paths(SetOperationStmt *op, PlannerInfo *root,
 
    *pTargetList = tlist;
 
-   /* Build path list and relid set. */
+   /* Build path lists and relid set. */
    foreach(lc, rellist)
    {
        RelOptInfo *rel = lfirst(lc);
 
        pathlist = lappend(pathlist, rel->cheapest_total_path);
+
+       if (consider_parallel)
+       {
+           if (!rel->consider_parallel)
+           {
+               consider_parallel = false;
+               partial_paths_valid = false;
+           }
+           else if (rel->partial_pathlist == NIL)
+               partial_paths_valid = false;
+           else
+               partial_pathlist = lappend(partial_pathlist,
+                                          linitial(rel->partial_pathlist));
+       }
+
        relids = bms_union(relids, rel->relids);
    }
 
    /* Build result relation. */
    result_rel = fetch_upper_rel(root, UPPERREL_SETOP, relids);
    result_rel->reltarget = create_pathtarget(root, tlist);
+   result_rel->consider_parallel = consider_parallel;
 
    /*
     * Append the child results together.
@@ -626,6 +668,53 @@ generate_union_paths(SetOperationStmt *op, PlannerInfo *root,
     */
    result_rel->rows = path->rows;
 
+   /*
+    * Now consider doing the same thing using the partial paths plus Append
+    * plus Gather.
+    */
+   if (partial_paths_valid)
+   {
+       Path       *ppath;
+       ListCell   *lc;
+       int         parallel_workers = 0;
+
+       /* Find the highest number of workers requested for any subpath. */
+       foreach(lc, partial_pathlist)
+       {
+           Path       *path = lfirst(lc);
+
+           parallel_workers = Max(parallel_workers, path->parallel_workers);
+       }
+       Assert(parallel_workers > 0);
+
+       /*
+        * If the use of parallel append is permitted, always request at least
+        * log2(# of children) paths.  We assume it can be useful to have
+        * extra workers in this case because they will be spread out across
+        * the children.  The precise formula is just a guess; see
+        * add_paths_to_append_rel.
+        */
+       if (enable_parallel_append)
+       {
+           parallel_workers = Max(parallel_workers,
+                                  fls(list_length(partial_pathlist)));
+           parallel_workers = Min(parallel_workers,
+                                  max_parallel_workers_per_gather);
+       }
+       Assert(parallel_workers > 0);
+
+       ppath = (Path *)
+           create_append_path(result_rel, NIL, partial_pathlist,
+                              NULL, parallel_workers, enable_parallel_append,
+                              NIL, -1);
+       ppath = (Path *)
+           create_gather_path(root, result_rel, ppath,
+                              result_rel->reltarget, NULL, NULL);
+       if (!op->all)
+           ppath = make_union_unique(op, ppath, tlist, root);
+       add_path(result_rel, ppath);
+   }
+
    /* Undo effects of possibly forcing tuple_fraction to 0 */
    root->tuple_fraction = save_fraction;