Avoid creating duplicate ordered append paths

In generate_orderedappend_paths(), the function does not handle the
case where the paths in total_subpaths and fractional_subpaths are
identical.  This situation is not uncommon, and as a result, it may
generate two exactly identical ordered append paths.

Fix by checking whether total_subpaths and fractional_subpaths contain
the same paths, and skipping creation of the ordered append path for
the fractional case when they are identical.

Given the lack of field complaints about this, I'm a bit hesitant to
back-patch, but let's clean it up in HEAD.

Author: Richard Guo <guofenglinux@gmail.com>
Reviewed-by: Andrei Lepikhov <lepihov@gmail.com>
Reviewed-by: Alexander Korotkov <aekorotkov@gmail.com>
Discussion: https://postgr.es/m/CAMbWs4-OYsgA75tGGiBARt87G0y_z_GBTSLrzudcJxAzndYkYw@mail.gmail.com

diff --git a/src/backend/optimizer/path/allpaths.c b/src/backend/optimizer/path/allpaths.c
index 41233b983737c09cbcca78cefb7a4dc2749338fc..4c43fd0b19b2343a40c264c381ac591704a3878b 100644 (file)
--- a/src/backend/optimizer/path/allpaths.c
+++ b/src/backend/optimizer/path/allpaths.c
@@ -1877,6 +1877,7 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
                List       *total_subpaths = NIL;
                List       *fractional_subpaths = NIL;
                bool            startup_neq_total = false;
+               bool            fraction_neq_total = false;
                bool            match_partition_order;
                bool            match_partition_order_desc;
                int                     end_index;
@@ -2005,15 +2006,21 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
                                 * XXX We might consider partially sorted paths too (with an
                                 * incremental sort on top). But we'd have to build all the
                                 * incremental paths, do the costing etc.
+                                *
+                                * Also, notice whether we actually have different paths for
+                                * the "fractional" and "total" cases.  This helps avoid
+                                * generating two identical ordered append paths.
                                 */
-                               if (!cheapest_fractional)
+                               if (cheapest_fractional == NULL)
                                        cheapest_fractional = cheapest_total;
+                               else if (cheapest_fractional != cheapest_total)
+                                       fraction_neq_total = true;
                        }
 
                        /*
                         * Notice whether we actually have different paths for the
-                        * "cheapest" and "total" cases; frequently there will be no point
-                        * in two create_merge_append_path() calls.
+                        * "cheapest" and "total" cases.  This helps avoid generating two
+                        * identical ordered append paths.
                         */
                        if (cheapest_startup != cheapest_total)
                                startup_neq_total = true;
@@ -2084,7 +2091,7 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
                                                                                                                  false,
                                                                                                                  -1));
 
-                       if (fractional_subpaths)
+                       if (fractional_subpaths && fraction_neq_total)
                                add_path(rel, (Path *) create_append_path(root,
                                                                                                                  rel,
                                                                                                                  fractional_subpaths,
@@ -2110,7 +2117,7 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
                                                                                                                                pathkeys,
                                                                                                                                NULL));
 
-                       if (fractional_subpaths)
+                       if (fractional_subpaths && fraction_neq_total)
                                add_path(rel, (Path *) create_merge_append_path(root,
                                                                                                                                rel,
                                                                                                                                fractional_subpaths,