Rearrange make_partitionedrel_pruneinfo to avoid work when we can't prune.

Postpone most of the effort of constructing PartitionedRelPruneInfos
until after we have found out whether run-time pruning is needed at all.
This costs very little duplicated effort (basically just an extra
find_base_rel() call per partition) and saves quite a bit when we
can't do run-time pruning.

Also, merge the first loop (for building relid_subpart_map) into
the second loop, since we don't need the map to be valid during
that loop.

Amit Langote

Discussion: https://postgr.es/m/9d7c5112-cb99-6a47-d3be-cf1ee6862a1d@lab.ntt.co.jp

diff --git a/src/backend/partitioning/partprune.c b/src/backend/partitioning/partprune.c
index 31e0164ea99af4c33726ef9d1cddbad0bb86e326..c7f3ca2a2084883e1fbf7b1c39022b0e3b25ad18 100644 (file)
--- a/src/backend/partitioning/partprune.c
+++ b/src/backend/partitioning/partprune.c
@@ -326,46 +326,43 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
        int                     i;
 
        /*
-        * Construct a temporary array to map from planner relids to index of the
-        * partitioned_rel.  For convenience, we use 1-based indexes here, so that
-        * zero can represent an un-filled array entry.
+        * Examine each partitioned rel, constructing a temporary array to map
+        * from planner relids to index of the partitioned rel, and building a
+        * PartitionedRelPruneInfo for each partitioned rel.
+        *
+        * In this phase we discover whether runtime pruning is needed at all; if
+        * not, we can avoid doing further work.
         */
        relid_subpart_map = palloc0(sizeof(int) * root->simple_rel_array_size);
 
-       /*
-        * relid_subpart_map maps relid of a non-leaf partition to the index in
-        * 'partitioned_rels' of that rel (which will also be the index in the
-        * returned PartitionedRelPruneInfo list of the info for that partition).
-        */
        i = 1;
        foreach(lc, partitioned_rels)
-       {
-               Index           rti = lfirst_int(lc);
-
-               Assert(rti < root->simple_rel_array_size);
-               /* No duplicates please */
-               Assert(relid_subpart_map[rti] == 0);
-
-               relid_subpart_map[rti] = i++;
-       }
-
-       /* We now build a PartitionedRelPruneInfo for each partitioned rel */
-       foreach(lc, partitioned_rels)
        {
                Index           rti = lfirst_int(lc);
                RelOptInfo *subpart = find_base_rel(root, rti);
                PartitionedRelPruneInfo *pinfo;
-               Bitmapset  *present_parts;
-               int                     nparts = subpart->nparts;
                int                     partnatts = subpart->part_scheme->partnatts;
-               int                *subplan_map;
-               int                *subpart_map;
-               Oid                *relid_map;
                List       *partprunequal;
                List       *pruning_steps;
                bool            contradictory;
 
                /*
+                * Fill the mapping array.
+                *
+                * relid_subpart_map maps relid of a non-leaf partition to the index
+                * in 'partitioned_rels' of that rel (which will also be the index in
+                * the returned PartitionedRelPruneInfo list of the info for that
+                * partition).  We use 1-based indexes here, so that zero can
+                * represent an un-filled array entry.
+                */
+               Assert(rti < root->simple_rel_array_size);
+               /* No duplicates please */
+               Assert(relid_subpart_map[rti] == 0);
+               relid_subpart_map[rti] = i++;
+
+               /*
+                * Translate pruning qual, if necessary, for this partition.
+                *
                 * The first item in the list is the target partitioned relation.
                 */
                if (!targetpart)
@@ -411,6 +408,7 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
                                                                                                  targetpart->relids);
                }
 
+               /* Convert pruning qual to pruning steps. */
                pruning_steps = gen_partprune_steps(subpart, partprunequal,
                                                                                        &contradictory);
 
@@ -428,6 +426,47 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
                        return NIL;
                }
 
+               /* Begin constructing the PartitionedRelPruneInfo for this rel */
+               pinfo = makeNode(PartitionedRelPruneInfo);
+               pinfo->rtindex = rti;
+               pinfo->pruning_steps = pruning_steps;
+               /* Remaining fields will be filled in the next loop */
+
+               pinfolist = lappend(pinfolist, pinfo);
+
+               /*
+                * Determine which pruning types should be enabled at this level. This
+                * also records paramids relevant to pruning steps in 'pinfo'.
+                */
+               doruntimeprune |= analyze_partkey_exprs(pinfo, pruning_steps,
+                                                                                               partnatts);
+       }
+
+       if (!doruntimeprune)
+       {
+               /* No run-time pruning required. */
+               pfree(relid_subpart_map);
+               return NIL;
+       }
+
+       /*
+        * Run-time pruning will be required, so initialize other information.
+        * That includes two maps -- one needed to convert partition indexes of
+        * leaf partitions to the indexes of their subplans in the subplan list,
+        * another needed to convert partition indexes of sub-partitioned
+        * partitions to the indexes of their PartitionedRelPruneInfo in the
+        * PartitionedRelPruneInfo list.
+        */
+       foreach(lc, pinfolist)
+       {
+               PartitionedRelPruneInfo *pinfo = lfirst(lc);
+               RelOptInfo *subpart = find_base_rel(root, pinfo->rtindex);
+               Bitmapset  *present_parts;
+               int                     nparts = subpart->nparts;
+               int                *subplan_map;
+               int                *subpart_map;
+               Oid                *relid_map;
+
                /*
                 * Construct the subplan and subpart maps for this partitioning level.
                 * Here we convert to zero-based indexes, with -1 for empty entries.
@@ -459,30 +498,16 @@ make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel,
                                present_parts = bms_add_member(present_parts, i);
                }
 
-               pinfo = makeNode(PartitionedRelPruneInfo);
-               pinfo->rtindex = rti;
-               pinfo->pruning_steps = pruning_steps;
+               /* Record the maps and other information. */
                pinfo->present_parts = present_parts;
                pinfo->nparts = nparts;
                pinfo->subplan_map = subplan_map;
                pinfo->subpart_map = subpart_map;
                pinfo->relid_map = relid_map;
-
-               /* Determine which pruning types should be enabled at this level */
-               doruntimeprune |= analyze_partkey_exprs(pinfo, pruning_steps,
-                                                                                               partnatts);
-
-               pinfolist = lappend(pinfolist, pinfo);
        }
 
        pfree(relid_subpart_map);
 
-       if (!doruntimeprune)
-       {
-               /* No run-time pruning required. */
-               return NIL;
-       }
-
        *matchedsubplans = subplansfound;
 
        return pinfolist;
@@ -2907,6 +2932,9 @@ pull_exec_paramids_walker(Node *node, Bitmapset **context)
  *
  * Returns true if any executor partition pruning should be attempted at this
  * level.  Also fills fields of *pinfo to record how to process each step.
+ *
+ * Note: when this is called, not much of *pinfo is valid; but that's OK
+ * since we only use it as an output area.
  */
 static bool
 analyze_partkey_exprs(PartitionedRelPruneInfo *pinfo, List *steps,