Rename PathKeyInfo to GroupByOrdering

0452b461bc made optimizer explore alternative orderings of group-by pathkeys.
The PathKeyInfo data structure was used to store the particular ordering of
group-by pathkeys and corresponding clauses.  It turns out that PathKeyInfo
is not the best name for that purpose.  This commit renames this data structure
to GroupByOrdering, and revises its comment.

Discussion: https://postgr.es/m/db0fc3a4-966c-4cec-a136-94024d39212d%40postgrespro.ru
Reported-by: Tom Lane
Author: Andrei Lepikhov
Reviewed-by: Alexander Korotkov, Pavel Borisov

diff --git a/src/backend/optimizer/path/pathkeys.c b/src/backend/optimizer/path/pathkeys.c
index 02e46a6eaafdc09cd75b8f1ac23636b78f9beff9..0a25b6384bbb0a4d4ba33023a70c2e0d6008fe4f 100644 (file)
--- a/src/backend/optimizer/path/pathkeys.c
+++ b/src/backend/optimizer/path/pathkeys.c
@@ -450,7 +450,7 @@ group_keys_reorder_by_pathkeys(List *pathkeys, List **group_pathkeys,
 /*
  * pathkeys_are_duplicate
  *             Check if give pathkeys are already contained the list of
- *             PathKeyInfo's.
+ *             GroupByOrdering's.
  */
 static bool
 pathkeys_are_duplicate(List *infos, List *pathkeys)
@@ -459,7 +459,7 @@ pathkeys_are_duplicate(List *infos, List *pathkeys)
 
        foreach(lc, infos)
        {
-               PathKeyInfo *info = lfirst_node(PathKeyInfo, lc);
+               GroupByOrdering *info = lfirst_node(GroupByOrdering, lc);
 
                if (compare_pathkeys(pathkeys, info->pathkeys) == PATHKEYS_EQUAL)
                        return true;
@@ -471,7 +471,7 @@ pathkeys_are_duplicate(List *infos, List *pathkeys)
  * get_useful_group_keys_orderings
  *             Determine which orderings of GROUP BY keys are potentially interesting.
  *
- * Returns a list of PathKeyInfo items, each representing an interesting
+ * Returns a list of GroupByOrdering items, each representing an interesting
  * ordering of GROUP BY keys.  Each item stores pathkeys and clauses in the
  * matching order.
  *
@@ -486,13 +486,13 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
 {
        Query      *parse = root->parse;
        List       *infos = NIL;
-       PathKeyInfo *info;
+       GroupByOrdering *info;
 
        List       *pathkeys = root->group_pathkeys;
        List       *clauses = root->processed_groupClause;
 
        /* always return at least the original pathkeys/clauses */
-       info = makeNode(PathKeyInfo);
+       info = makeNode(GroupByOrdering);
        info->pathkeys = pathkeys;
        info->clauses = clauses;
        infos = lappend(infos, info);
@@ -528,7 +528,7 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
                        (enable_incremental_sort || n == root->num_groupby_pathkeys) &&
                        !pathkeys_are_duplicate(infos, pathkeys))
                {
-                       info = makeNode(PathKeyInfo);
+                       info = makeNode(GroupByOrdering);
                        info->pathkeys = pathkeys;
                        info->clauses = clauses;
 
@@ -553,7 +553,7 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
                        (enable_incremental_sort || n == list_length(root->sort_pathkeys)) &&
                        !pathkeys_are_duplicate(infos, pathkeys))
                {
-                       info = makeNode(PathKeyInfo);
+                       info = makeNode(GroupByOrdering);
                        info->pathkeys = pathkeys;
                        info->clauses = clauses;
 
@@ -563,7 +563,7 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
 
 #ifdef USE_ASSERT_CHECKING
        {
-               PathKeyInfo *pinfo = linitial_node(PathKeyInfo, infos);
+               GroupByOrdering *pinfo = linitial_node(GroupByOrdering, infos);
                ListCell   *lc;
 
                /* Test consistency of info structures */
@@ -572,7 +572,7 @@ get_useful_group_keys_orderings(PlannerInfo *root, Path *path)
                        ListCell   *lc1,
                                           *lc2;
 
-                       info = lfirst_node(PathKeyInfo, lc);
+                       info = lfirst_node(GroupByOrdering, lc);
 
                        Assert(list_length(info->clauses) == list_length(pinfo->clauses));
                        Assert(list_length(info->pathkeys) == list_length(pinfo->pathkeys));

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index ea107c70cb896f91a92a4a9acb81e38ce5267cbb..084c6796d0395c90b94ff144c6977169fa3f2c06 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -6917,7 +6917,7 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
 
                        foreach(lc2, pathkey_orderings)
                        {
-                               PathKeyInfo *info = (PathKeyInfo *) lfirst(lc2);
+                               GroupByOrdering *info = (GroupByOrdering *) lfirst(lc2);
 
                                /* restore the path (we replace it in the loop) */
                                path = path_save;
@@ -6998,7 +6998,7 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
                                /* process all potentially interesting grouping reorderings */
                                foreach(lc2, pathkey_orderings)
                                {
-                                       PathKeyInfo *info = (PathKeyInfo *) lfirst(lc2);
+                                       GroupByOrdering *info = (GroupByOrdering *) lfirst(lc2);
 
                                        /* restore the path (we replace it in the loop) */
                                        path = path_save;
@@ -7249,7 +7249,7 @@ create_partial_grouping_paths(PlannerInfo *root,
                        /* process all potentially interesting grouping reorderings */
                        foreach(lc2, pathkey_orderings)
                        {
-                               PathKeyInfo *info = (PathKeyInfo *) lfirst(lc2);
+                               GroupByOrdering *info = (GroupByOrdering *) lfirst(lc2);
 
                                /* restore the path (we replace it in the loop) */
                                path = path_save;
@@ -7305,7 +7305,7 @@ create_partial_grouping_paths(PlannerInfo *root,
                        /* process all potentially interesting grouping reorderings */
                        foreach(lc2, pathkey_orderings)
                        {
-                               PathKeyInfo *info = (PathKeyInfo *) lfirst(lc2);
+                               GroupByOrdering *info = (GroupByOrdering *) lfirst(lc2);
 
 
                                /* restore the path (we replace it in the loop) */

diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h
index 14ef296ab72f34518d782a5f176c976daafeeca2..78489398294d84dd92c9f22c098bf321d0f122da 100644 (file)
--- a/src/include/nodes/pathnodes.h
+++ b/src/include/nodes/pathnodes.h
@@ -1468,14 +1468,21 @@ typedef struct PathKey
 } PathKey;
 
 /*
- * Combines the information about pathkeys and the associated clauses.
+ * Contains an order of group-by clauses and the corresponding list of
+ * pathkeys.
+ *
+ * The elements of 'clauses' list should have the same order as the head of
+ * 'pathkeys' list.  The tleSortGroupRef of the clause should be equal to
+ * ec_sortref of the pathkey equivalence class.  If there are redundant
+ * clauses with the same tleSortGroupRef, they must be grouped together.
  */
-typedef struct PathKeyInfo
+typedef struct GroupByOrdering
 {
        NodeTag         type;
+
        List       *pathkeys;
        List       *clauses;
-} PathKeyInfo;
+} GroupByOrdering;
 
 /*
  * VolatileFunctionStatus -- allows nodes to cache their

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index d427a1c16a504142fb2202eb5c2857ad4697b34f..4f57078d133cb83e4e8ef6f0a9d481b70040c602 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1056,6 +1056,7 @@ GrantRoleStmt
 GrantStmt
 GrantTargetType
 Group
+GroupByOrdering
 GroupClause
 GroupPath
 GroupPathExtraData
@@ -2067,7 +2068,6 @@ PathClauseUsage
 PathCostComparison
 PathHashStack
 PathKey
-PathKeyInfo
 PathKeysComparison
 PathTarget
 PatternInfo