Generalize the common code of adding sort before processing of grouping

Extract the repetitive code pattern into a new function make_ordered_path().

Discussion: https://postgr.es/m/CAPpHfdtzaVa7S4onKy3YvttF2rrH5hQNHx9HtcSTLbpjx%2BMJ%2Bw%40mail.gmail.com
Author: Andrei Lepikhov

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index 667723b6753cb8cb5fc0e922e8fcdd6f2a9d473f..014b179c3f0c0f66cbeb6bb20258aacea29544f5 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6809,6 +6809,58 @@ done:
        return parallel_workers;
 }
 
+/*
+ * make_ordered_path
+ *             Return a path ordered by 'pathkeys' based on the given 'path'.  May
+ *             return NULL if it doesn't make sense to generate an ordered path in
+ *             this case.
+ */
+static Path *
+make_ordered_path(PlannerInfo *root, RelOptInfo *rel, Path *path,
+                                 Path *cheapest_path, List *pathkeys)
+{
+       bool            is_sorted;
+       int                     presorted_keys;
+
+       is_sorted = pathkeys_count_contained_in(pathkeys,
+                                                                                       path->pathkeys,
+                                                                                       &presorted_keys);
+
+       if (!is_sorted)
+       {
+               /*
+                * Try at least sorting the cheapest path and also try incrementally
+                * sorting any path which is partially sorted already (no need to deal
+                * with paths which have presorted keys when incremental sort is
+                * disabled unless it's the cheapest input path).
+                */
+               if (path != cheapest_path &&
+                       (presorted_keys == 0 || !enable_incremental_sort))
+                       return NULL;
+
+               /*
+                * We've no need to consider both a sort and incremental sort. We'll
+                * just do a sort if there are no presorted keys and an incremental
+                * sort when there are presorted keys.
+                */
+               if (presorted_keys == 0 || !enable_incremental_sort)
+                       path = (Path *) create_sort_path(root,
+                                                                                        rel,
+                                                                                        path,
+                                                                                        pathkeys,
+                                                                                        -1.0);
+               else
+                       path = (Path *) create_incremental_sort_path(root,
+                                                                                                                rel,
+                                                                                                                path,
+                                                                                                                pathkeys,
+                                                                                                                presorted_keys,
+                                                                                                                -1.0);
+       }
+
+       return path;
+}
+
 /*
  * add_paths_to_grouping_rel
  *
@@ -6840,45 +6892,15 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
                foreach(lc, input_rel->pathlist)
                {
                        Path       *path = (Path *) lfirst(lc);
-                       bool            is_sorted;
-                       int                     presorted_keys;
 
-                       is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
-                                                                                                       path->pathkeys,
-                                                                                                       &presorted_keys);
-
-                       if (!is_sorted)
-                       {
-                               /*
-                                * Try at least sorting the cheapest path and also try
-                                * incrementally sorting any path which is partially sorted
-                                * already (no need to deal with paths which have presorted
-                                * keys when incremental sort is disabled unless it's the
-                                * cheapest input path).
-                                */
-                               if (path != cheapest_path &&
-                                       (presorted_keys == 0 || !enable_incremental_sort))
-                                       continue;
+                       path = make_ordered_path(root,
+                                                                        grouped_rel,
+                                                                        path,
+                                                                        cheapest_path,
+                                                                        root->group_pathkeys);
 
-                               /*
-                                * We've no need to consider both a sort and incremental sort.
-                                * We'll just do a sort if there are no presorted keys and an
-                                * incremental sort when there are presorted keys.
-                                */
-                               if (presorted_keys == 0 || !enable_incremental_sort)
-                                       path = (Path *) create_sort_path(root,
-                                                                                                        grouped_rel,
-                                                                                                        path,
-                                                                                                        root->group_pathkeys,
-                                                                                                        -1.0);
-                               else
-                                       path = (Path *) create_incremental_sort_path(root,
-                                                                                                                                grouped_rel,
-                                                                                                                                path,
-                                                                                                                                root->group_pathkeys,
-                                                                                                                                presorted_keys,
-                                                                                                                                -1.0);
-                       }
+                       if (path == NULL)
+                               continue;
 
                        /* Now decide what to stick atop it */
                        if (parse->groupingSets)
@@ -6935,46 +6957,15 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
                        foreach(lc, partially_grouped_rel->pathlist)
                        {
                                Path       *path = (Path *) lfirst(lc);
-                               bool            is_sorted;
-                               int                     presorted_keys;
 
-                               is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
-                                                                                                               path->pathkeys,
-                                                                                                               &presorted_keys);
-
-                               if (!is_sorted)
-                               {
-                                       /*
-                                        * Try at least sorting the cheapest path and also try
-                                        * incrementally sorting any path which is partially
-                                        * sorted already (no need to deal with paths which have
-                                        * presorted keys when incremental sort is disabled unless
-                                        * it's the cheapest input path).
-                                        */
-                                       if (path != partially_grouped_rel->cheapest_total_path &&
-                                               (presorted_keys == 0 || !enable_incremental_sort))
-                                               continue;
+                               path = make_ordered_path(root,
+                                                                                grouped_rel,
+                                                                                path,
+                                                                                partially_grouped_rel->cheapest_total_path,
+                                                                                root->group_pathkeys);
 
-                                       /*
-                                        * We've no need to consider both a sort and incremental
-                                        * sort.  We'll just do a sort if there are no pre-sorted
-                                        * keys and an incremental sort when there are presorted
-                                        * keys.
-                                        */
-                                       if (presorted_keys == 0 || !enable_incremental_sort)
-                                               path = (Path *) create_sort_path(root,
-                                                                                                                grouped_rel,
-                                                                                                                path,
-                                                                                                                root->group_pathkeys,
-                                                                                                                -1.0);
-                                       else
-                                               path = (Path *) create_incremental_sort_path(root,
-                                                                                                                                        grouped_rel,
-                                                                                                                                        path,
-                                                                                                                                        root->group_pathkeys,
-                                                                                                                                        presorted_keys,
-                                                                                                                                        -1.0);
-                               }
+                               if (path == NULL)
+                                       continue;
 
                                if (parse->hasAggs)
                                        add_path(grouped_rel, (Path *)
@@ -7200,44 +7191,15 @@ create_partial_grouping_paths(PlannerInfo *root,
                foreach(lc, input_rel->pathlist)
                {
                        Path       *path = (Path *) lfirst(lc);
-                       bool            is_sorted;
-                       int                     presorted_keys;
 
-                       is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
-                                                                                                       path->pathkeys,
-                                                                                                       &presorted_keys);
-                       if (!is_sorted)
-                       {
-                               /*
-                                * Try at least sorting the cheapest path and also try
-                                * incrementally sorting any path which is partially sorted
-                                * already (no need to deal with paths which have presorted
-                                * keys when incremental sort is disabled unless it's the
-                                * cheapest input path).
-                                */
-                               if (path != cheapest_total_path &&
-                                       (presorted_keys == 0 || !enable_incremental_sort))
-                                       continue;
+                       path = make_ordered_path(root,
+                                                                        partially_grouped_rel,
+                                                                        path,
+                                                                        cheapest_total_path,
+                                                                        root->group_pathkeys);
 
-                               /*
-                                * We've no need to consider both a sort and incremental sort.
-                                * We'll just do a sort if there are no presorted keys and an
-                                * incremental sort when there are presorted keys.
-                                */
-                               if (presorted_keys == 0 || !enable_incremental_sort)
-                                       path = (Path *) create_sort_path(root,
-                                                                                                        partially_grouped_rel,
-                                                                                                        path,
-                                                                                                        root->group_pathkeys,
-                                                                                                        -1.0);
-                               else
-                                       path = (Path *) create_incremental_sort_path(root,
-                                                                                                                                partially_grouped_rel,
-                                                                                                                                path,
-                                                                                                                                root->group_pathkeys,
-                                                                                                                                presorted_keys,
-                                                                                                                                -1.0);
-                       }
+                       if (path == NULL)
+                               continue;
 
                        if (parse->hasAggs)
                                add_path(partially_grouped_rel, (Path *)
@@ -7268,45 +7230,15 @@ create_partial_grouping_paths(PlannerInfo *root,
                foreach(lc, input_rel->partial_pathlist)
                {
                        Path       *path = (Path *) lfirst(lc);
-                       bool            is_sorted;
-                       int                     presorted_keys;
-
-                       is_sorted = pathkeys_count_contained_in(root->group_pathkeys,
-                                                                                                       path->pathkeys,
-                                                                                                       &presorted_keys);
 
-                       if (!is_sorted)
-                       {
-                               /*
-                                * Try at least sorting the cheapest path and also try
-                                * incrementally sorting any path which is partially sorted
-                                * already (no need to deal with paths which have presorted
-                                * keys when incremental sort is disabled unless it's the
-                                * cheapest input path).
-                                */
-                               if (path != cheapest_partial_path &&
-                                       (presorted_keys == 0 || !enable_incremental_sort))
-                                       continue;
+                       path = make_ordered_path(root,
+                                                                        partially_grouped_rel,
+                                                                        path,
+                                                                        cheapest_partial_path,
+                                                                        root->group_pathkeys);
 
-                               /*
-                                * We've no need to consider both a sort and incremental sort.
-                                * We'll just do a sort if there are no presorted keys and an
-                                * incremental sort when there are presorted keys.
-                                */
-                               if (presorted_keys == 0 || !enable_incremental_sort)
-                                       path = (Path *) create_sort_path(root,
-                                                                                                        partially_grouped_rel,
-                                                                                                        path,
-                                                                                                        root->group_pathkeys,
-                                                                                                        -1.0);
-                               else
-                                       path = (Path *) create_incremental_sort_path(root,
-                                                                                                                                partially_grouped_rel,
-                                                                                                                                path,
-                                                                                                                                root->group_pathkeys,
-                                                                                                                                presorted_keys,
-                                                                                                                                -1.0);
-                       }
+                       if (path == NULL)
+                               continue;
 
                        if (parse->hasAggs)
                                add_partial_path(partially_grouped_rel, (Path *)