Tighten up some code in RelationBuildPartitionDesc.

This probably doesn't save anything meaningful in terms of
performance, but making the code simpler is a good idea anyway.

Code by Beena Emerson, extracted from a larger patch by Jeevan
Ladhe, slightly adjusted by me.

Discussion: http://postgr.es/m/CAOgcT0ONgwajdtkoq+AuYkdTPY9cLWWLjxt_k4SXue3eieAr+g@mail.gmail.com

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce6b2c2b76696687642434ed4b927a14429..50162632f5ca3ab5bcc2c87a2f3bc737a713c6db 100644 (file)
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -303,21 +303,18 @@ RelationBuildPartitionDesc(Relation rel)
                }
                else if (key->strategy == PARTITION_STRATEGY_RANGE)
                {
-                       int                     j,
-                                               k;
+                       int                     k;
                        PartitionRangeBound **all_bounds,
                                           *prev;
-                       bool       *distinct_indexes;
 
                        all_bounds = (PartitionRangeBound **) palloc0(2 * nparts *
                                                                                                                  sizeof(PartitionRangeBound *));
-                       distinct_indexes = (bool *) palloc(2 * nparts * sizeof(bool));
 
                        /*
                         * Create a unified list of range bounds across all the
                         * partitions.
                         */
-                       i = j = 0;
+                       i = ndatums = 0;
                        foreach(cell, boundspecs)
                        {
                                PartitionBoundSpec *spec = castNode(PartitionBoundSpec,
@@ -332,12 +329,12 @@ RelationBuildPartitionDesc(Relation rel)
                                                                                         true);
                                upper = make_one_range_bound(key, i, spec->upperdatums,
                                                                                         false);
-                               all_bounds[j] = lower;
-                               all_bounds[j + 1] = upper;
-                               j += 2;
+                               all_bounds[ndatums++] = lower;
+                               all_bounds[ndatums++] = upper;
                                i++;
                        }
-                       Assert(j == 2 * nparts);
+
+                       Assert(ndatums == nparts * 2);
 
                        /* Sort all the bounds in ascending order */
                        qsort_arg(all_bounds, 2 * nparts,
@@ -345,13 +342,12 @@ RelationBuildPartitionDesc(Relation rel)
                                          qsort_partition_rbound_cmp,
                                          (void *) key);
 
-                       /*
-                        * Count the number of distinct bounds to allocate an array of
-                        * that size.
-                        */
-                       ndatums = 0;
+                       /* Save distinct bounds from all_bounds into rbounds. */
+                       rbounds = (PartitionRangeBound **)
+                               palloc(ndatums * sizeof(PartitionRangeBound *));
+                       k = 0;
                        prev = NULL;
-                       for (i = 0; i < 2 * nparts; i++)
+                       for (i = 0; i < ndatums; i++)
                        {
                                PartitionRangeBound *cur = all_bounds[i];
                                bool            is_distinct = false;
@@ -388,34 +384,18 @@ RelationBuildPartitionDesc(Relation rel)
                                }
 
                                /*
-                                * Count the current bound if it is distinct from the previous
-                                * one.  Also, store if the index i contains a distinct bound
-                                * that we'd like put in the relcache array.
+                                * Only if the bound is distinct save it into a temporary
+                                * array i.e. rbounds which is later copied into boundinfo
+                                * datums array.
                                 */
                                if (is_distinct)
-                               {
-                                       distinct_indexes[i] = true;
-                                       ndatums++;
-                               }
-                               else
-                                       distinct_indexes[i] = false;
+                                       rbounds[k++] = all_bounds[i];
 
                                prev = cur;
                        }
 
-                       /*
-                        * Finally save them in an array from where they will be copied
-                        * into the relcache.
-                        */
-                       rbounds = (PartitionRangeBound **) palloc(ndatums *
-                                                                                                         sizeof(PartitionRangeBound *));
-                       k = 0;
-                       for (i = 0; i < 2 * nparts; i++)
-                       {
-                               if (distinct_indexes[i])
-                                       rbounds[k++] = all_bounds[i];
-                       }
-                       Assert(k == ndatums);
+                       /* Update ndatums to hold the count of distinct datums. */
+                       ndatums = k;
                }
                else
                        elog(ERROR, "unexpected partition strategy: %d",