Improve ExecFindInitialMatchingSubPlans's subplan renumbering logic.

We don't need two passes if we scan child partitions before parents,
as that way the children's present_parts are up to date before they're
needed.  I (tgl) think there's actually a bug being fixed here, for the
case of an intermediate partitioned table with no direct leaf children,
but haven't attempted to construct a test case to prove it.

David Rowley

Discussion: https://postgr.es/m/CAKJS1f-6GODRNgEtdPxCnAPme2h2hTztB6LmtfdmcYAAOE0kQg@mail.gmail.com

diff --git a/src/backend/executor/execPartition.c b/src/backend/executor/execPartition.c
index 80c12cfcc0deb0947e963d44a6bbd529b568fbab..33513ff1d155d013b8e38be7a49024c9f033cfe0 100644 (file)
--- a/src/backend/executor/execPartition.c
+++ b/src/backend/executor/execPartition.c
@@ -1442,8 +1442,8 @@ ExecSetupPartitionPruneState(PlanState *planstate, List *partitionpruneinfo)
                int                     n_steps;
 
                /*
-                * We must make a copy of this rather than pointing directly to the
-                * plan's version as we may end up making modifications to it later.
+                * We must copy the subplan_map rather than pointing directly to the
+                * plan's version, as we may end up making modifications to it later.
                 */
                pprune->subplan_map = palloc(sizeof(int) * pinfo->nparts);
                memcpy(pprune->subplan_map, pinfo->subplan_map,
@@ -1589,8 +1589,8 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
                int                     newidx;
 
                /*
-                * First we must build an array which we can use to adjust the
-                * existing subplan_map so that it contains the new subplan indexes.
+                * First we must build a temporary array which maps old subplan
+                * indexes to new ones.
                 */
                new_subplan_indexes = (int *) palloc(sizeof(int) * nsubplans);
                newidx = 0;
@@ -1603,79 +1603,55 @@ ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate, int nsubplans)
                }
 
                /*
-                * Now we can re-sequence each PartitionPruneInfo's subplan_map so
-                * that they point to the new index of the subplan.
+                * Now we can update each PartitionPruneInfo's subplan_map with new
+                * subplan indexes.  We must also recompute its present_parts bitmap.
+                * We perform this loop in back-to-front order so that we determine
+                * present_parts for the lowest-level partitioned tables first.  This
+                * way we can tell whether a sub-partitioned table's partitions were
+                * entirely pruned so we can exclude that from 'present_parts'.
                 */
-               for (i = 0; i < prunestate->num_partprunedata; i++)
+               for (i = prunestate->num_partprunedata - 1; i >= 0; i--)
                {
                        int                     nparts;
                        int                     j;
 
                        pprune = &prunestate->partprunedata[i];
                        nparts = pprune->context.nparts;
-
-                       /*
-                        * We also need to reset the present_parts field so that it only
-                        * contains partition indexes that we actually still have subplans
-                        * for.  It seems easier to build a fresh one, rather than trying
-                        * to update the existing one.
-                        */
+                       /* We just rebuild present_parts from scratch */
                        bms_free(pprune->present_parts);
                        pprune->present_parts = NULL;
 
                        for (j = 0; j < nparts; j++)
                        {
                                int                     oldidx = pprune->subplan_map[j];
+                               int                     subidx;
 
                                /*
                                 * If this partition existed as a subplan then change the old
                                 * subplan index to the new subplan index.  The new index may
                                 * become -1 if the partition was pruned above, or it may just
                                 * come earlier in the subplan list due to some subplans being
-                                * removed earlier in the list.
+                                * removed earlier in the list.  If it's a subpartition, add
+                                * it to present_parts unless it's entirely pruned.
                                 */
                                if (oldidx >= 0)
                                {
+                                       Assert(oldidx < nsubplans);
                                        pprune->subplan_map[j] = new_subplan_indexes[oldidx];
 
                                        if (new_subplan_indexes[oldidx] >= 0)
                                                pprune->present_parts =
                                                        bms_add_member(pprune->present_parts, j);
                                }
-                       }
-               }
-
-               /*
-                * Now we must determine which sub-partitioned tables still have
-                * unpruned partitions.  The easiest way to do this is to simply loop
-                * over each PartitionPruningData again checking if there are any
-                * 'present_parts' in the sub-partitioned table.  We needn't bother
-                * doing this if there are no sub-partitioned tables.
-                */
-               if (prunestate->num_partprunedata > 1)
-               {
-                       for (i = 0; i < prunestate->num_partprunedata; i++)
-                       {
-                               int                     nparts;
-                               int                     j;
-
-                               pprune = &prunestate->partprunedata[i];
-                               nparts = pprune->context.nparts;
-
-                               for (j = 0; j < nparts; j++)
+                               else if ((subidx = pprune->subpart_map[j]) >= 0)
                                {
-                                       int                     subidx = pprune->subpart_map[j];
-
-                                       if (subidx >= 0)
-                                       {
-                                               PartitionPruningData *subprune;
+                                       PartitionPruningData *subprune;
 
-                                               subprune = &prunestate->partprunedata[subidx];
+                                       subprune = &prunestate->partprunedata[subidx];
 
-                                               if (!bms_is_empty(subprune->present_parts))
-                                                       pprune->present_parts =
-                                                               bms_add_member(pprune->present_parts, j);
-                                       }
+                                       if (!bms_is_empty(subprune->present_parts))
+                                               pprune->present_parts =
+                                                       bms_add_member(pprune->present_parts, j);
                                }
                        }
                }