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",