Add new Tuplesortstate.removeabbrev function

This commit is the preparation to move abbreviation logic into
puttuple_common().  The new removeabbrev function turns datum1 representation
of SortTuple's from the abbreviated key to the first column value.  Therefore,
it encapsulates the differential part of abbreviation handling code in
tuplesort_put*() functions, making these functions similar.

Discussion: https://postgr.es/m/CAPpHfdvjix0Ahx-H3Jp1M2R%2B_74P-zKnGGygx4OWr%3DbUQ8BNdw%40mail.gmail.com
Author: Alexander Korotkov
Reviewed-by: Pavel Borisov, Maxim Orlov, Matthias van de Meent
Reviewed-by: Andres Freund, John Naylor

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 3e06e5391a6a6762ea79bee316a190e36c364892..7e6b2b8c888f268c39e5a4cdb706192a63b32963 100644 (file)
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -279,6 +279,13 @@ struct Tuplesortstate
     */
    SortTupleComparator comparetup;
 
+   /*
+    * Alter datum1 representation in the SortTuple's array back from the
+    * abbreviated key to the first column value.
+    */
+   void        (*removeabbrev) (Tuplesortstate *state, SortTuple *stups,
+                                int count);
+
    /*
     * Function to write a stored tuple onto tape.  The representation of the
     * tuple on tape need not be the same as it is in memory; requirements on
@@ -540,6 +547,7 @@ struct Sharedsort
            pfree(buf); \
    } while(0)
 
+#define REMOVEABBREV(state,stup,count) ((*(state)->removeabbrev) (state, stup, count))
 #define COMPARETUP(state,a,b)  ((*(state)->comparetup) (a, b, state))
 #define WRITETUP(state,tape,stup)  ((*(state)->writetup) (state, tape, stup))
 #define READTUP(state,stup,tape,len) ((*(state)->readtup) (state, stup, tape, len))
@@ -629,6 +637,14 @@ static void reversedirection(Tuplesortstate *state);
 static unsigned int getlen(LogicalTape *tape, bool eofOK);
 static void markrunend(LogicalTape *tape);
 static void *readtup_alloc(Tuplesortstate *state, Size tuplen);
+static void removeabbrev_heap(Tuplesortstate *state, SortTuple *stups,
+                             int count);
+static void removeabbrev_cluster(Tuplesortstate *state, SortTuple *stups,
+                                int count);
+static void removeabbrev_index(Tuplesortstate *state, SortTuple *stups,
+                              int count);
+static void removeabbrev_datum(Tuplesortstate *state, SortTuple *stups,
+                              int count);
 static int comparetup_heap(const SortTuple *a, const SortTuple *b,
                            Tuplesortstate *state);
 static void writetup_heap(Tuplesortstate *state, LogicalTape *tape,
@@ -1042,6 +1058,7 @@ tuplesort_begin_heap(TupleDesc tupDesc,
                                sortopt & TUPLESORT_RANDOMACCESS,
                                PARALLEL_SORT(state));
 
+   state->removeabbrev = removeabbrev_heap;
    state->comparetup = comparetup_heap;
    state->writetup = writetup_heap;
    state->readtup = readtup_heap;
@@ -1117,6 +1134,7 @@ tuplesort_begin_cluster(TupleDesc tupDesc,
                                sortopt & TUPLESORT_RANDOMACCESS,
                                PARALLEL_SORT(state));
 
+   state->removeabbrev = removeabbrev_cluster;
    state->comparetup = comparetup_cluster;
    state->writetup = writetup_cluster;
    state->readtup = readtup_cluster;
@@ -1221,6 +1239,7 @@ tuplesort_begin_index_btree(Relation heapRel,
                                sortopt & TUPLESORT_RANDOMACCESS,
                                PARALLEL_SORT(state));
 
+   state->removeabbrev = removeabbrev_index;
    state->comparetup = comparetup_index_btree;
    state->writetup = writetup_index;
    state->readtup = readtup_index;
@@ -1297,6 +1316,7 @@ tuplesort_begin_index_hash(Relation heapRel,
 
    state->nKeys = 1;           /* Only one sort column, the hash code */
 
+   state->removeabbrev = removeabbrev_index;
    state->comparetup = comparetup_index_hash;
    state->writetup = writetup_index;
    state->readtup = readtup_index;
@@ -1337,6 +1357,7 @@ tuplesort_begin_index_gist(Relation heapRel,
 
    state->nKeys = IndexRelationGetNumberOfKeyAttributes(indexRel);
 
+   state->removeabbrev = removeabbrev_index;
    state->comparetup = comparetup_index_btree;
    state->writetup = writetup_index;
    state->readtup = readtup_index;
@@ -1400,6 +1421,7 @@ tuplesort_begin_datum(Oid datumType, Oid sortOperator, Oid sortCollation,
                                sortopt & TUPLESORT_RANDOMACCESS,
                                PARALLEL_SORT(state));
 
+   state->removeabbrev = removeabbrev_datum;
    state->comparetup = comparetup_datum;
    state->writetup = writetup_datum;
    state->readtup = readtup_datum;
@@ -1858,8 +1880,6 @@ tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
    else
    {
        /* Abort abbreviation */
-       int         i;
-
        stup.datum1 = original;
 
        /*
@@ -1871,20 +1891,7 @@ tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
         * sorted on tape, since serialized tuples lack abbreviated keys
         * (TSS_BUILDRUNS state prevents control reaching here in any case).
         */
-       for (i = 0; i < state->memtupcount; i++)
-       {
-           SortTuple  *mtup = &state->memtuples[i];
-
-           htup.t_len = ((MinimalTuple) mtup->tuple)->t_len +
-               MINIMAL_TUPLE_OFFSET;
-           htup.t_data = (HeapTupleHeader) ((char *) mtup->tuple -
-                                            MINIMAL_TUPLE_OFFSET);
-
-           mtup->datum1 = heap_getattr(&htup,
-                                       state->sortKeys[0].ssup_attno,
-                                       state->tupDesc,
-                                       &mtup->isnull1);
-       }
+       REMOVEABBREV(state, state->memtuples, state->memtupcount);
    }
 
    puttuple_common(state, &stup);
@@ -1943,8 +1950,6 @@ tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
        else
        {
            /* Abort abbreviation */
-           int         i;
-
            stup.datum1 = original;
 
            /*
@@ -1957,16 +1962,7 @@ tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
             * (TSS_BUILDRUNS state prevents control reaching here in any
             * case).
             */
-           for (i = 0; i < state->memtupcount; i++)
-           {
-               SortTuple  *mtup = &state->memtuples[i];
-
-               tup = (HeapTuple) mtup->tuple;
-               mtup->datum1 = heap_getattr(tup,
-                                           state->indexInfo->ii_IndexAttrNumbers[0],
-                                           state->tupDesc,
-                                           &mtup->isnull1);
-           }
+           REMOVEABBREV(state, state->memtuples, state->memtupcount);
        }
    }
 
@@ -2023,8 +2019,6 @@ tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel,
    else
    {
        /* Abort abbreviation */
-       int         i;
-
        stup.datum1 = original;
 
        /*
@@ -2036,16 +2030,7 @@ tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel,
         * sorted on tape, since serialized tuples lack abbreviated keys
         * (TSS_BUILDRUNS state prevents control reaching here in any case).
         */
-       for (i = 0; i < state->memtupcount; i++)
-       {
-           SortTuple  *mtup = &state->memtuples[i];
-
-           tuple = mtup->tuple;
-           mtup->datum1 = index_getattr(tuple,
-                                        1,
-                                        RelationGetDescr(state->indexRel),
-                                        &mtup->isnull1);
-       }
+       REMOVEABBREV(state, state->memtuples, state->memtupcount);
    }
 
    puttuple_common(state, &stup);
@@ -2109,8 +2094,6 @@ tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
        else
        {
            /* Abort abbreviation */
-           int         i;
-
            stup.datum1 = original;
 
            /*
@@ -2123,12 +2106,7 @@ tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
             * (TSS_BUILDRUNS state prevents control reaching here in any
             * case).
             */
-           for (i = 0; i < state->memtupcount; i++)
-           {
-               SortTuple  *mtup = &state->memtuples[i];
-
-               mtup->datum1 = PointerGetDatum(mtup->tuple);
-           }
+           REMOVEABBREV(state, state->memtuples, state->memtupcount);
        }
    }
 
@@ -3985,6 +3963,26 @@ readtup_alloc(Tuplesortstate *state, Size tuplen)
  * Routines specialized for HeapTuple (actually MinimalTuple) case
  */
 
+static void
+removeabbrev_heap(Tuplesortstate *state, SortTuple *stups, int count)
+{
+   int         i;
+
+   for (i = 0; i < count; i++)
+   {
+       HeapTupleData htup;
+
+       htup.t_len = ((MinimalTuple) stups[i].tuple)->t_len +
+           MINIMAL_TUPLE_OFFSET;
+       htup.t_data = (HeapTupleHeader) ((char *) stups[i].tuple -
+                                        MINIMAL_TUPLE_OFFSET);
+       stups[i].datum1 = heap_getattr(&htup,
+                                      state->sortKeys[0].ssup_attno,
+                                      state->tupDesc,
+                                      &stups[i].isnull1);
+   }
+}
+
 static int
 comparetup_heap(const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
 {
@@ -4103,6 +4101,23 @@ readtup_heap(Tuplesortstate *state, SortTuple *stup,
  * comparisons per a btree index definition)
  */
 
+static void
+removeabbrev_cluster(Tuplesortstate *state, SortTuple *stups, int count)
+{
+   int         i;
+
+   for (i = 0; i < count; i++)
+   {
+       HeapTuple   tup;
+
+       tup = (HeapTuple) stups[i].tuple;
+       stups[i].datum1 = heap_getattr(tup,
+                                      state->indexInfo->ii_IndexAttrNumbers[0],
+                                      state->tupDesc,
+                                      &stups[i].isnull1);
+   }
+}
+
 static int
 comparetup_cluster(const SortTuple *a, const SortTuple *b,
                   Tuplesortstate *state)
@@ -4272,6 +4287,23 @@ readtup_cluster(Tuplesortstate *state, SortTuple *stup,
  * functions can be shared.
  */
 
+static void
+removeabbrev_index(Tuplesortstate *state, SortTuple *stups, int count)
+{
+   int         i;
+
+   for (i = 0; i < count; i++)
+   {
+       IndexTuple  tuple;
+
+       tuple = stups[i].tuple;
+       stups[i].datum1 = index_getattr(tuple,
+                                       1,
+                                       RelationGetDescr(state->indexRel),
+                                       &stups[i].isnull1);
+   }
+}
+
 static int
 comparetup_index_btree(const SortTuple *a, const SortTuple *b,
                       Tuplesortstate *state)
@@ -4504,6 +4536,15 @@ readtup_index(Tuplesortstate *state, SortTuple *stup,
  * Routines specialized for DatumTuple case
  */
 
+static void
+removeabbrev_datum(Tuplesortstate *state, SortTuple *stups, int count)
+{
+   int         i;
+
+   for (i = 0; i < count; i++)
+       stups[i].datum1 = PointerGetDatum(stups[i].tuple);
+}
+
 static int
 comparetup_datum(const SortTuple *a, const SortTuple *b, Tuplesortstate *state)
 {