Put abbreviation logic into puttuple_common()

Abbreviation code is very similar along tuplesort_put*() functions.  This
commit unifies that code and puts it into puttuple_common().  tuplesort_put*()
functions differs in the abbreviation condition, so it has been added as an
argument to the puttuple_common() function.

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 7e6b2b8c888f268c39e5a4cdb706192a63b32963..828efe701e55c1070d60a6d50f1f2ddff6e65a81 100644 (file)
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -616,7 +616,8 @@ static Tuplesortstate *tuplesort_begin_common(int workMem,
                                                                                          SortCoordinate coordinate,
                                                                                          int sortopt);
 static void tuplesort_begin_batch(Tuplesortstate *state);
-static void puttuple_common(Tuplesortstate *state, SortTuple *tuple);
+static void puttuple_common(Tuplesortstate *state, SortTuple *tuple,
+                                                       bool useAbbrev);
 static bool consider_abort_common(Tuplesortstate *state);
 static void inittapes(Tuplesortstate *state, bool mergeruns);
 static void inittapestate(Tuplesortstate *state, int maxTapes);
@@ -1841,7 +1842,6 @@ tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
 {
        MemoryContext oldcontext = MemoryContextSwitchTo(state->tuplecontext);
        SortTuple       stup;
-       Datum           original;
        MinimalTuple tuple;
        HeapTupleData htup;
 
@@ -1852,49 +1852,15 @@ tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
        /* set up first-column key value */
        htup.t_len = tuple->t_len + MINIMAL_TUPLE_OFFSET;
        htup.t_data = (HeapTupleHeader) ((char *) tuple - MINIMAL_TUPLE_OFFSET);
-       original = heap_getattr(&htup,
-                                                       state->sortKeys[0].ssup_attno,
-                                                       state->tupDesc,
-                                                       &stup.isnull1);
+       stup.datum1 = heap_getattr(&htup,
+                                                          state->sortKeys[0].ssup_attno,
+                                                          state->tupDesc,
+                                                          &stup.isnull1);
 
        MemoryContextSwitchTo(state->sortcontext);
 
-       if (!state->sortKeys->abbrev_converter || stup.isnull1)
-       {
-               /*
-                * Store ordinary Datum representation, or NULL value.  If there is a
-                * converter it won't expect NULL values, and cost model is not
-                * required to account for NULL, so in that case we avoid calling
-                * converter and just set datum1 to zeroed representation (to be
-                * consistent, and to support cheap inequality tests for NULL
-                * abbreviated keys).
-                */
-               stup.datum1 = original;
-       }
-       else if (!consider_abort_common(state))
-       {
-               /* Store abbreviated key representation */
-               stup.datum1 = state->sortKeys->abbrev_converter(original,
-                                                                                                               state->sortKeys);
-       }
-       else
-       {
-               /* Abort abbreviation */
-               stup.datum1 = original;
-
-               /*
-                * Set state to be consistent with never trying abbreviation.
-                *
-                * Alter datum1 representation in already-copied tuples, so as to
-                * ensure a consistent representation (current tuple was just
-                * handled).  It does not matter if some dumped tuples are already
-                * sorted on tape, since serialized tuples lack abbreviated keys
-                * (TSS_BUILDRUNS state prevents control reaching here in any case).
-                */
-               REMOVEABBREV(state, state->memtuples, state->memtupcount);
-       }
-
-       puttuple_common(state, &stup);
+       puttuple_common(state, &stup,
+                                       state->sortKeys->abbrev_converter && !stup.isnull1);
 
        MemoryContextSwitchTo(oldcontext);
 }
@@ -1908,7 +1874,6 @@ void
 tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
 {
        SortTuple       stup;
-       Datum           original;
        MemoryContext oldcontext = MemoryContextSwitchTo(state->tuplecontext);
 
        /* copy the tuple into sort storage */
@@ -1924,49 +1889,14 @@ tuplesort_putheaptuple(Tuplesortstate *state, HeapTuple tup)
         */
        if (state->haveDatum1)
        {
-               original = heap_getattr(tup,
-                                                               state->indexInfo->ii_IndexAttrNumbers[0],
-                                                               state->tupDesc,
-                                                               &stup.isnull1);
-
-               if (!state->sortKeys->abbrev_converter || stup.isnull1)
-               {
-                       /*
-                        * Store ordinary Datum representation, or NULL value.  If there
-                        * is a converter it won't expect NULL values, and cost model is
-                        * not required to account for NULL, so in that case we avoid
-                        * calling converter and just set datum1 to zeroed representation
-                        * (to be consistent, and to support cheap inequality tests for
-                        * NULL abbreviated keys).
-                        */
-                       stup.datum1 = original;
-               }
-               else if (!consider_abort_common(state))
-               {
-                       /* Store abbreviated key representation */
-                       stup.datum1 = state->sortKeys->abbrev_converter(original,
-                                                                                                                       state->sortKeys);
-               }
-               else
-               {
-                       /* Abort abbreviation */
-                       stup.datum1 = original;
-
-                       /*
-                        * Set state to be consistent with never trying abbreviation.
-                        *
-                        * Alter datum1 representation in already-copied tuples, so as to
-                        * ensure a consistent representation (current tuple was just
-                        * handled).  It does not matter if some dumped tuples are already
-                        * sorted on tape, since serialized tuples lack abbreviated keys
-                        * (TSS_BUILDRUNS state prevents control reaching here in any
-                        * case).
-                        */
-                       REMOVEABBREV(state, state->memtuples, state->memtupcount);
-               }
+               stup.datum1 = heap_getattr(tup,
+                                                                  state->indexInfo->ii_IndexAttrNumbers[0],
+                                                                  state->tupDesc,
+                                                                  &stup.isnull1);
        }
 
-       puttuple_common(state, &stup);
+       puttuple_common(state, &stup,
+                                       state->haveDatum1 && state->sortKeys->abbrev_converter && !stup.isnull1);
 
        MemoryContextSwitchTo(oldcontext);
 }
@@ -1982,7 +1912,6 @@ tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel,
 {
        MemoryContext oldcontext;
        SortTuple       stup;
-       Datum           original;
        IndexTuple      tuple;
 
        stup.tuple = index_form_tuple_context(RelationGetDescr(rel), values,
@@ -1991,49 +1920,15 @@ tuplesort_putindextuplevalues(Tuplesortstate *state, Relation rel,
        tuple->t_tid = *self;
        USEMEM(state, GetMemoryChunkSpace(stup.tuple));
        /* set up first-column key value */
-       original = index_getattr(tuple,
-                                                        1,
-                                                        RelationGetDescr(state->indexRel),
-                                                        &stup.isnull1);
+       stup.datum1 = index_getattr(tuple,
+                                                               1,
+                                                               RelationGetDescr(state->indexRel),
+                                                               &stup.isnull1);
 
        oldcontext = MemoryContextSwitchTo(state->sortcontext);
 
-       if (!state->sortKeys || !state->sortKeys->abbrev_converter || stup.isnull1)
-       {
-               /*
-                * Store ordinary Datum representation, or NULL value.  If there is a
-                * converter it won't expect NULL values, and cost model is not
-                * required to account for NULL, so in that case we avoid calling
-                * converter and just set datum1 to zeroed representation (to be
-                * consistent, and to support cheap inequality tests for NULL
-                * abbreviated keys).
-                */
-               stup.datum1 = original;
-       }
-       else if (!consider_abort_common(state))
-       {
-               /* Store abbreviated key representation */
-               stup.datum1 = state->sortKeys->abbrev_converter(original,
-                                                                                                               state->sortKeys);
-       }
-       else
-       {
-               /* Abort abbreviation */
-               stup.datum1 = original;
-
-               /*
-                * Set state to be consistent with never trying abbreviation.
-                *
-                * Alter datum1 representation in already-copied tuples, so as to
-                * ensure a consistent representation (current tuple was just
-                * handled).  It does not matter if some dumped tuples are already
-                * sorted on tape, since serialized tuples lack abbreviated keys
-                * (TSS_BUILDRUNS state prevents control reaching here in any case).
-                */
-               REMOVEABBREV(state, state->memtuples, state->memtupcount);
-       }
-
-       puttuple_common(state, &stup);
+       puttuple_common(state, &stup,
+                                       state->sortKeys && state->sortKeys->abbrev_converter && !stup.isnull1);
 
        MemoryContextSwitchTo(oldcontext);
 }
@@ -2074,43 +1969,15 @@ tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
        }
        else
        {
-               Datum           original = datumCopy(val, false, state->datumTypeLen);
-
                stup.isnull1 = false;
-               stup.tuple = DatumGetPointer(original);
+               stup.datum1 = datumCopy(val, false, state->datumTypeLen);
+               stup.tuple = DatumGetPointer(stup.datum1);
                USEMEM(state, GetMemoryChunkSpace(stup.tuple));
                MemoryContextSwitchTo(state->sortcontext);
-
-               if (!state->sortKeys->abbrev_converter)
-               {
-                       stup.datum1 = original;
-               }
-               else if (!consider_abort_common(state))
-               {
-                       /* Store abbreviated key representation */
-                       stup.datum1 = state->sortKeys->abbrev_converter(original,
-                                                                                                                       state->sortKeys);
-               }
-               else
-               {
-                       /* Abort abbreviation */
-                       stup.datum1 = original;
-
-                       /*
-                        * Set state to be consistent with never trying abbreviation.
-                        *
-                        * Alter datum1 representation in already-copied tuples, so as to
-                        * ensure a consistent representation (current tuple was just
-                        * handled).  It does not matter if some dumped tuples are already
-                        * sorted on tape, since serialized tuples lack abbreviated keys
-                        * (TSS_BUILDRUNS state prevents control reaching here in any
-                        * case).
-                        */
-                       REMOVEABBREV(state, state->memtuples, state->memtupcount);
-               }
        }
 
-       puttuple_common(state, &stup);
+       puttuple_common(state, &stup,
+                                       state->tuples && !isNull && state->sortKeys->abbrev_converter);
 
        MemoryContextSwitchTo(oldcontext);
 }
@@ -2119,10 +1986,41 @@ tuplesort_putdatum(Tuplesortstate *state, Datum val, bool isNull)
  * Shared code for tuple and datum cases.
  */
 static void
-puttuple_common(Tuplesortstate *state, SortTuple *tuple)
+puttuple_common(Tuplesortstate *state, SortTuple *tuple, bool useAbbrev)
 {
        Assert(!LEADER(state));
 
+       if (!useAbbrev)
+       {
+               /*
+                * Leave ordinary Datum representation, or NULL value.  If there is a
+                * converter it won't expect NULL values, and cost model is not
+                * required to account for NULL, so in that case we avoid calling
+                * converter and just set datum1 to zeroed representation (to be
+                * consistent, and to support cheap inequality tests for NULL
+                * abbreviated keys).
+                */
+       }
+       else if (!consider_abort_common(state))
+       {
+               /* Store abbreviated key representation */
+               tuple->datum1 = state->sortKeys->abbrev_converter(tuple->datum1,
+                                                                                                                 state->sortKeys);
+       }
+       else
+       {
+               /*
+                * Set state to be consistent with never trying abbreviation.
+                *
+                * Alter datum1 representation in already-copied tuples, so as to
+                * ensure a consistent representation (current tuple was just
+                * handled).  It does not matter if some dumped tuples are already
+                * sorted on tape, since serialized tuples lack abbreviated keys
+                * (TSS_BUILDRUNS state prevents control reaching here in any case).
+                */
+               REMOVEABBREV(state, state->memtuples, state->memtupcount);
+       }
+
        switch (state->status)
        {
                case TSS_INITIAL: