LCOV - code coverage report
Current view: top level - src/backend/access/common - indextuple.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16devel Lines: 162 169 95.9 %
Date: 2022-08-17 03:10:30 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * indextuple.c
       4             :  *     This file contains index tuple accessor and mutator routines,
       5             :  *     as well as various tuple utilities.
       6             :  *
       7             :  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  *
      11             :  * IDENTIFICATION
      12             :  *    src/backend/access/common/indextuple.c
      13             :  *
      14             :  *-------------------------------------------------------------------------
      15             :  */
      16             : 
      17             : #include "postgres.h"
      18             : 
      19             : #include "access/detoast.h"
      20             : #include "access/heaptoast.h"
      21             : #include "access/htup_details.h"
      22             : #include "access/itup.h"
      23             : #include "access/toast_internals.h"
      24             : 
      25             : /*
      26             :  * This enables de-toasting of index entries.  Needed until VACUUM is
      27             :  * smart enough to rebuild indexes from scratch.
      28             :  */
      29             : #define TOAST_INDEX_HACK
      30             : 
      31             : /* ----------------------------------------------------------------
      32             :  *                index_ tuple interface routines
      33             :  * ----------------------------------------------------------------
      34             :  */
      35             : 
      36             :  /* ----------------
      37             :   *     index_form_tuple
      38             :   *
      39             :   *     As index_form_tuple_context, but allocates the returned tuple in the
      40             :   *     CurrentMemoryContext.
      41             :   * ----------------
      42             :   */
      43             : IndexTuple
      44    16141156 : index_form_tuple(TupleDesc tupleDescriptor,
      45             :                  Datum *values,
      46             :                  bool *isnull)
      47             : {
      48    16141156 :     return index_form_tuple_context(tupleDescriptor, values, isnull,
      49             :                                     CurrentMemoryContext);
      50             : }
      51             : 
      52             : /* ----------------
      53             :  *      index_form_tuple_context
      54             :  *
      55             :  *      This shouldn't leak any memory; otherwise, callers such as
      56             :  *      tuplesort_putindextuplevalues() will be very unhappy.
      57             :  *
      58             :  *      This shouldn't perform external table access provided caller
      59             :  *      does not pass values that are stored EXTERNAL.
      60             :  *
      61             :  *      Allocates returned tuple in provided 'context'.
      62             :  * ----------------
      63             :  */
      64             : IndexTuple
      65    38995374 : index_form_tuple_context(TupleDesc tupleDescriptor,
      66             :                          Datum *values,
      67             :                          bool *isnull,
      68             :                          MemoryContext context)
      69             : {
      70             :     char       *tp;             /* tuple pointer */
      71             :     IndexTuple  tuple;          /* return tuple */
      72             :     Size        size,
      73             :                 data_size,
      74             :                 hoff;
      75             :     int         i;
      76    38995374 :     unsigned short infomask = 0;
      77    38995374 :     bool        hasnull = false;
      78    38995374 :     uint16      tupmask = 0;
      79    38995374 :     int         numberOfAttributes = tupleDescriptor->natts;
      80             : 
      81             : #ifdef TOAST_INDEX_HACK
      82             :     Datum       untoasted_values[INDEX_MAX_KEYS];
      83             :     bool        untoasted_free[INDEX_MAX_KEYS];
      84             : #endif
      85             : 
      86    38995374 :     if (numberOfAttributes > INDEX_MAX_KEYS)
      87           0 :         ereport(ERROR,
      88             :                 (errcode(ERRCODE_TOO_MANY_COLUMNS),
      89             :                  errmsg("number of index columns (%d) exceeds limit (%d)",
      90             :                         numberOfAttributes, INDEX_MAX_KEYS)));
      91             : 
      92             : #ifdef TOAST_INDEX_HACK
      93   111537070 :     for (i = 0; i < numberOfAttributes; i++)
      94             :     {
      95    72541696 :         Form_pg_attribute att = TupleDescAttr(tupleDescriptor, i);
      96             : 
      97    72541696 :         untoasted_values[i] = values[i];
      98    72541696 :         untoasted_free[i] = false;
      99             : 
     100             :         /* Do nothing if value is NULL or not of varlena type */
     101    72541696 :         if (isnull[i] || att->attlen != -1)
     102    69609136 :             continue;
     103             : 
     104             :         /*
     105             :          * If value is stored EXTERNAL, must fetch it so we are not depending
     106             :          * on outside storage.  This should be improved someday.
     107             :          */
     108     2932560 :         if (VARATT_IS_EXTERNAL(DatumGetPointer(values[i])))
     109             :         {
     110         362 :             untoasted_values[i] =
     111         362 :                 PointerGetDatum(detoast_external_attr((struct varlena *)
     112             :                                                       DatumGetPointer(values[i])));
     113         362 :             untoasted_free[i] = true;
     114             :         }
     115             : 
     116             :         /*
     117             :          * If value is above size target, and is of a compressible datatype,
     118             :          * try to compress it in-line.
     119             :          */
     120     2932560 :         if (!VARATT_IS_EXTENDED(DatumGetPointer(untoasted_values[i])) &&
     121     2284714 :             VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
     122      116258 :             (att->attstorage == TYPSTORAGE_EXTENDED ||
     123      113680 :              att->attstorage == TYPSTORAGE_MAIN))
     124             :         {
     125             :             Datum       cvalue;
     126             : 
     127        2578 :             cvalue = toast_compress_datum(untoasted_values[i],
     128        2578 :                                           att->attcompression);
     129             : 
     130        2578 :             if (DatumGetPointer(cvalue) != NULL)
     131             :             {
     132             :                 /* successful compression */
     133         248 :                 if (untoasted_free[i])
     134           0 :                     pfree(DatumGetPointer(untoasted_values[i]));
     135         248 :                 untoasted_values[i] = cvalue;
     136         248 :                 untoasted_free[i] = true;
     137             :             }
     138             :         }
     139             :     }
     140             : #endif
     141             : 
     142   111511022 :     for (i = 0; i < numberOfAttributes; i++)
     143             :     {
     144    72539588 :         if (isnull[i])
     145             :         {
     146       23940 :             hasnull = true;
     147       23940 :             break;
     148             :         }
     149             :     }
     150             : 
     151    38995374 :     if (hasnull)
     152       23940 :         infomask |= INDEX_NULL_MASK;
     153             : 
     154    38995374 :     hoff = IndexInfoFindDataOffset(infomask);
     155             : #ifdef TOAST_INDEX_HACK
     156    38995374 :     data_size = heap_compute_data_size(tupleDescriptor,
     157             :                                        untoasted_values, isnull);
     158             : #else
     159             :     data_size = heap_compute_data_size(tupleDescriptor,
     160             :                                        values, isnull);
     161             : #endif
     162    38995374 :     size = hoff + data_size;
     163    38995374 :     size = MAXALIGN(size);      /* be conservative */
     164             : 
     165    38995374 :     tp = (char *) MemoryContextAllocZero(context, size);
     166    38995374 :     tuple = (IndexTuple) tp;
     167             : 
     168    38995374 :     heap_fill_tuple(tupleDescriptor,
     169             : #ifdef TOAST_INDEX_HACK
     170             :                     untoasted_values,
     171             : #else
     172             :                     values,
     173             : #endif
     174             :                     isnull,
     175             :                     (char *) tp + hoff,
     176             :                     data_size,
     177             :                     &tupmask,
     178             :                     (hasnull ? (bits8 *) tp + sizeof(IndexTupleData) : NULL));
     179             : 
     180             : #ifdef TOAST_INDEX_HACK
     181   111537070 :     for (i = 0; i < numberOfAttributes; i++)
     182             :     {
     183    72541696 :         if (untoasted_free[i])
     184         610 :             pfree(DatumGetPointer(untoasted_values[i]));
     185             :     }
     186             : #endif
     187             : 
     188             :     /*
     189             :      * We do this because heap_fill_tuple wants to initialize a "tupmask"
     190             :      * which is used for HeapTuples, but we want an indextuple infomask. The
     191             :      * only relevant info is the "has variable attributes" field. We have
     192             :      * already set the hasnull bit above.
     193             :      */
     194    38995374 :     if (tupmask & HEAP_HASVARWIDTH)
     195     7204878 :         infomask |= INDEX_VAR_MASK;
     196             : 
     197             :     /* Also assert we got rid of external attributes */
     198             : #ifdef TOAST_INDEX_HACK
     199             :     Assert((tupmask & HEAP_HASEXTERNAL) == 0);
     200             : #endif
     201             : 
     202             :     /*
     203             :      * Here we make sure that the size will fit in the field reserved for it
     204             :      * in t_info.
     205             :      */
     206    38995374 :     if ((size & INDEX_SIZE_MASK) != size)
     207           0 :         ereport(ERROR,
     208             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     209             :                  errmsg("index row requires %zu bytes, maximum size is %zu",
     210             :                         size, (Size) INDEX_SIZE_MASK)));
     211             : 
     212    38995374 :     infomask |= size;
     213             : 
     214             :     /*
     215             :      * initialize metadata
     216             :      */
     217    38995374 :     tuple->t_info = infomask;
     218    38995374 :     return tuple;
     219             : }
     220             : 
     221             : /* ----------------
     222             :  *      nocache_index_getattr
     223             :  *
     224             :  *      This gets called from index_getattr() macro, and only in cases
     225             :  *      where we can't use cacheoffset and the value is not null.
     226             :  *
     227             :  *      This caches attribute offsets in the attribute descriptor.
     228             :  *
     229             :  *      An alternative way to speed things up would be to cache offsets
     230             :  *      with the tuple, but that seems more difficult unless you take
     231             :  *      the storage hit of actually putting those offsets into the
     232             :  *      tuple you send to disk.  Yuck.
     233             :  *
     234             :  *      This scheme will be slightly slower than that, but should
     235             :  *      perform well for queries which hit large #'s of tuples.  After
     236             :  *      you cache the offsets once, examining all the other tuples using
     237             :  *      the same attribute descriptor will go much quicker. -cim 5/4/91
     238             :  * ----------------
     239             :  */
     240             : Datum
     241    11576430 : nocache_index_getattr(IndexTuple tup,
     242             :                       int attnum,
     243             :                       TupleDesc tupleDesc)
     244             : {
     245             :     char       *tp;             /* ptr to data part of tuple */
     246    11576430 :     bits8      *bp = NULL;      /* ptr to null bitmap in tuple */
     247    11576430 :     bool        slow = false;   /* do we have to walk attrs? */
     248             :     int         data_off;       /* tuple data offset */
     249             :     int         off;            /* current offset within data */
     250             : 
     251             :     /* ----------------
     252             :      *   Three cases:
     253             :      *
     254             :      *   1: No nulls and no variable-width attributes.
     255             :      *   2: Has a null or a var-width AFTER att.
     256             :      *   3: Has nulls or var-widths BEFORE att.
     257             :      * ----------------
     258             :      */
     259             : 
     260    11576430 :     data_off = IndexInfoFindDataOffset(tup->t_info);
     261             : 
     262    11576430 :     attnum--;
     263             : 
     264    11576430 :     if (IndexTupleHasNulls(tup))
     265             :     {
     266             :         /*
     267             :          * there's a null somewhere in the tuple
     268             :          *
     269             :          * check to see if desired att is null
     270             :          */
     271             : 
     272             :         /* XXX "knows" t_bits are just after fixed tuple header! */
     273       42328 :         bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
     274             : 
     275             :         /*
     276             :          * Now check to see if any preceding bits are null...
     277             :          */
     278             :         {
     279       42328 :             int         byte = attnum >> 3;
     280       42328 :             int         finalbit = attnum & 0x07;
     281             : 
     282             :             /* check for nulls "before" final bit of last byte */
     283       42328 :             if ((~bp[byte]) & ((1 << finalbit) - 1))
     284          12 :                 slow = true;
     285             :             else
     286             :             {
     287             :                 /* check for nulls in any "earlier" bytes */
     288             :                 int         i;
     289             : 
     290       42316 :                 for (i = 0; i < byte; i++)
     291             :                 {
     292           0 :                     if (bp[i] != 0xFF)
     293             :                     {
     294           0 :                         slow = true;
     295           0 :                         break;
     296             :                     }
     297             :                 }
     298             :             }
     299             :         }
     300             :     }
     301             : 
     302    11576430 :     tp = (char *) tup + data_off;
     303             : 
     304    11576430 :     if (!slow)
     305             :     {
     306             :         Form_pg_attribute att;
     307             : 
     308             :         /*
     309             :          * If we get here, there are no nulls up to and including the target
     310             :          * attribute.  If we have a cached offset, we can use it.
     311             :          */
     312    11576418 :         att = TupleDescAttr(tupleDesc, attnum);
     313    11576418 :         if (att->attcacheoff >= 0)
     314       42172 :             return fetchatt(att, tp + att->attcacheoff);
     315             : 
     316             :         /*
     317             :          * Otherwise, check for non-fixed-length attrs up to and including
     318             :          * target.  If there aren't any, it's safe to cheaply initialize the
     319             :          * cached offsets for these attrs.
     320             :          */
     321    11534246 :         if (IndexTupleHasVarwidths(tup))
     322             :         {
     323             :             int         j;
     324             : 
     325    12055130 :             for (j = 0; j <= attnum; j++)
     326             :             {
     327    12051504 :                 if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
     328             :                 {
     329    11448092 :                     slow = true;
     330    11448092 :                     break;
     331             :                 }
     332             :             }
     333             :         }
     334             :     }
     335             : 
     336    11534258 :     if (!slow)
     337             :     {
     338       86154 :         int         natts = tupleDesc->natts;
     339       86154 :         int         j = 1;
     340             : 
     341             :         /*
     342             :          * If we get here, we have a tuple with no nulls or var-widths up to
     343             :          * and including the target attribute, so we can use the cached offset
     344             :          * ... only we don't have it yet, or we'd not have got here.  Since
     345             :          * it's cheap to compute offsets for fixed-width columns, we take the
     346             :          * opportunity to initialize the cached offsets for *all* the leading
     347             :          * fixed-width columns, in hope of avoiding future visits to this
     348             :          * routine.
     349             :          */
     350       86154 :         TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
     351             : 
     352             :         /* we might have set some offsets in the slow path previously */
     353       86154 :         while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
     354           0 :             j++;
     355             : 
     356       86154 :         off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
     357       86154 :             TupleDescAttr(tupleDesc, j - 1)->attlen;
     358             : 
     359      196580 :         for (; j < natts; j++)
     360             :         {
     361      114010 :             Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
     362             : 
     363      114010 :             if (att->attlen <= 0)
     364        3584 :                 break;
     365             : 
     366      110426 :             off = att_align_nominal(off, att->attalign);
     367             : 
     368      110426 :             att->attcacheoff = off;
     369             : 
     370      110426 :             off += att->attlen;
     371             :         }
     372             : 
     373             :         Assert(j > attnum);
     374             : 
     375       86154 :         off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
     376             :     }
     377             :     else
     378             :     {
     379    11448104 :         bool        usecache = true;
     380             :         int         i;
     381             : 
     382             :         /*
     383             :          * Now we know that we have to walk the tuple CAREFULLY.  But we still
     384             :          * might be able to cache some offsets for next time.
     385             :          *
     386             :          * Note - This loop is a little tricky.  For each non-null attribute,
     387             :          * we have to first account for alignment padding before the attr,
     388             :          * then advance over the attr based on its length.  Nulls have no
     389             :          * storage and no alignment padding either.  We can use/set
     390             :          * attcacheoff until we reach either a null or a var-width attribute.
     391             :          */
     392    11448104 :         off = 0;
     393    11448104 :         for (i = 0;; i++)       /* loop exit is at "break" */
     394    13194310 :         {
     395    24642414 :             Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
     396             : 
     397    24642414 :             if (IndexTupleHasNulls(tup) && att_isnull(i, bp))
     398             :             {
     399          12 :                 usecache = false;
     400          12 :                 continue;       /* this cannot be the target att */
     401             :             }
     402             : 
     403             :             /* If we know the next offset, we can skip the rest */
     404    24642402 :             if (usecache && att->attcacheoff >= 0)
     405    12018256 :                 off = att->attcacheoff;
     406    12624146 :             else if (att->attlen == -1)
     407             :             {
     408             :                 /*
     409             :                  * We can only cache the offset for a varlena attribute if the
     410             :                  * offset is already suitably aligned, so that there would be
     411             :                  * no pad bytes in any case: then the offset will be valid for
     412             :                  * either an aligned or unaligned value.
     413             :                  */
     414     2867774 :                 if (usecache &&
     415        8930 :                     off == att_align_nominal(off, att->attalign))
     416        1370 :                     att->attcacheoff = off;
     417             :                 else
     418             :                 {
     419     2857474 :                     off = att_align_pointer(off, att->attalign, -1,
     420             :                                             tp + off);
     421     2857474 :                     usecache = false;
     422             :                 }
     423             :             }
     424             :             else
     425             :             {
     426             :                 /* not varlena, so safe to use att_align_nominal */
     427     9765302 :                 off = att_align_nominal(off, att->attalign);
     428             : 
     429     9765302 :                 if (usecache)
     430       18916 :                     att->attcacheoff = off;
     431             :             }
     432             : 
     433    24642402 :             if (i == attnum)
     434    11448104 :                 break;
     435             : 
     436    13194298 :             off = att_addlength_pointer(off, att->attlen, tp + off);
     437             : 
     438    13194298 :             if (usecache && att->attlen <= 0)
     439    11420294 :                 usecache = false;
     440             :         }
     441             :     }
     442             : 
     443    11534258 :     return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
     444             : }
     445             : 
     446             : /*
     447             :  * Convert an index tuple into Datum/isnull arrays.
     448             :  *
     449             :  * The caller must allocate sufficient storage for the output arrays.
     450             :  * (INDEX_MAX_KEYS entries should be enough.)
     451             :  *
     452             :  * This is nearly the same as heap_deform_tuple(), but for IndexTuples.
     453             :  * One difference is that the tuple should never have any missing columns.
     454             :  */
     455             : void
     456     3447974 : index_deform_tuple(IndexTuple tup, TupleDesc tupleDescriptor,
     457             :                    Datum *values, bool *isnull)
     458             : {
     459             :     char       *tp;             /* ptr to tuple data */
     460             :     bits8      *bp;             /* ptr to null bitmap in tuple */
     461             : 
     462             :     /* XXX "knows" t_bits are just after fixed tuple header! */
     463     3447974 :     bp = (bits8 *) ((char *) tup + sizeof(IndexTupleData));
     464             : 
     465     3447974 :     tp = (char *) tup + IndexInfoFindDataOffset(tup->t_info);
     466             : 
     467     3447974 :     index_deform_tuple_internal(tupleDescriptor, values, isnull,
     468     3447974 :                                 tp, bp, IndexTupleHasNulls(tup));
     469     3447974 : }
     470             : 
     471             : /*
     472             :  * Convert an index tuple into Datum/isnull arrays,
     473             :  * without assuming any specific layout of the index tuple header.
     474             :  *
     475             :  * Caller must supply pointer to data area, pointer to nulls bitmap
     476             :  * (which can be NULL if !hasnulls), and hasnulls flag.
     477             :  */
     478             : void
     479     3508840 : index_deform_tuple_internal(TupleDesc tupleDescriptor,
     480             :                             Datum *values, bool *isnull,
     481             :                             char *tp, bits8 *bp, int hasnulls)
     482             : {
     483     3508840 :     int         natts = tupleDescriptor->natts; /* number of atts to extract */
     484             :     int         attnum;
     485     3508840 :     int         off = 0;        /* offset in tuple data */
     486     3508840 :     bool        slow = false;   /* can we use/set attcacheoff? */
     487             : 
     488             :     /* Assert to protect callers who allocate fixed-size arrays */
     489             :     Assert(natts <= INDEX_MAX_KEYS);
     490             : 
     491     8075544 :     for (attnum = 0; attnum < natts; attnum++)
     492             :     {
     493     4566704 :         Form_pg_attribute thisatt = TupleDescAttr(tupleDescriptor, attnum);
     494             : 
     495     4566704 :         if (hasnulls && att_isnull(attnum, bp))
     496             :         {
     497        4472 :             values[attnum] = (Datum) 0;
     498        4472 :             isnull[attnum] = true;
     499        4472 :             slow = true;        /* can't use attcacheoff anymore */
     500        4472 :             continue;
     501             :         }
     502             : 
     503     4562232 :         isnull[attnum] = false;
     504             : 
     505     4562232 :         if (!slow && thisatt->attcacheoff >= 0)
     506     4541016 :             off = thisatt->attcacheoff;
     507       21216 :         else if (thisatt->attlen == -1)
     508             :         {
     509             :             /*
     510             :              * We can only cache the offset for a varlena attribute if the
     511             :              * offset is already suitably aligned, so that there would be no
     512             :              * pad bytes in any case: then the offset will be valid for either
     513             :              * an aligned or unaligned value.
     514             :              */
     515       10350 :             if (!slow &&
     516           8 :                 off == att_align_nominal(off, thisatt->attalign))
     517           8 :                 thisatt->attcacheoff = off;
     518             :             else
     519             :             {
     520       10334 :                 off = att_align_pointer(off, thisatt->attalign, -1,
     521             :                                         tp + off);
     522       10334 :                 slow = true;
     523             :             }
     524             :         }
     525             :         else
     526             :         {
     527             :             /* not varlena, so safe to use att_align_nominal */
     528       10874 :             off = att_align_nominal(off, thisatt->attalign);
     529             : 
     530       10874 :             if (!slow)
     531        1294 :                 thisatt->attcacheoff = off;
     532             :         }
     533             : 
     534     4562232 :         values[attnum] = fetchatt(thisatt, tp + off);
     535             : 
     536     4562232 :         off = att_addlength_pointer(off, thisatt->attlen, tp + off);
     537             : 
     538     4562232 :         if (thisatt->attlen <= 0)
     539       84126 :             slow = true;        /* can't use attcacheoff anymore */
     540             :     }
     541     3508840 : }
     542             : 
     543             : /*
     544             :  * Create a palloc'd copy of an index tuple.
     545             :  */
     546             : IndexTuple
     547     5212854 : CopyIndexTuple(IndexTuple source)
     548             : {
     549             :     IndexTuple  result;
     550             :     Size        size;
     551             : 
     552     5212854 :     size = IndexTupleSize(source);
     553     5212854 :     result = (IndexTuple) palloc(size);
     554     5212854 :     memcpy(result, source, size);
     555     5212854 :     return result;
     556             : }
     557             : 
     558             : /*
     559             :  * Create a palloc'd copy of an index tuple, leaving only the first
     560             :  * leavenatts attributes remaining.
     561             :  *
     562             :  * Truncation is guaranteed to result in an index tuple that is no
     563             :  * larger than the original.  It is safe to use the IndexTuple with
     564             :  * the original tuple descriptor, but caller must avoid actually
     565             :  * accessing truncated attributes from returned tuple!  In practice
     566             :  * this means that index_getattr() must be called with special care,
     567             :  * and that the truncated tuple should only ever be accessed by code
     568             :  * under caller's direct control.
     569             :  *
     570             :  * It's safe to call this function with a buffer lock held, since it
     571             :  * never performs external table access.  If it ever became possible
     572             :  * for index tuples to contain EXTERNAL TOAST values, then this would
     573             :  * have to be revisited.
     574             :  */
     575             : IndexTuple
     576      108682 : index_truncate_tuple(TupleDesc sourceDescriptor, IndexTuple source,
     577             :                      int leavenatts)
     578             : {
     579             :     TupleDesc   truncdesc;
     580             :     Datum       values[INDEX_MAX_KEYS];
     581             :     bool        isnull[INDEX_MAX_KEYS];
     582             :     IndexTuple  truncated;
     583             : 
     584             :     Assert(leavenatts <= sourceDescriptor->natts);
     585             : 
     586             :     /* Easy case: no truncation actually required */
     587      108682 :     if (leavenatts == sourceDescriptor->natts)
     588       49718 :         return CopyIndexTuple(source);
     589             : 
     590             :     /* Create temporary descriptor to scribble on */
     591       58964 :     truncdesc = palloc(TupleDescSize(sourceDescriptor));
     592       58964 :     TupleDescCopy(truncdesc, sourceDescriptor);
     593       58964 :     truncdesc->natts = leavenatts;
     594             : 
     595             :     /* Deform, form copy of tuple with fewer attributes */
     596       58964 :     index_deform_tuple(source, truncdesc, values, isnull);
     597       58964 :     truncated = index_form_tuple(truncdesc, values, isnull);
     598       58964 :     truncated->t_tid = source->t_tid;
     599             :     Assert(IndexTupleSize(truncated) <= IndexTupleSize(source));
     600             : 
     601             :     /*
     602             :      * Cannot leak memory here, TupleDescCopy() doesn't allocate any inner
     603             :      * structure, so, plain pfree() should clean all allocated memory
     604             :      */
     605       58964 :     pfree(truncdesc);
     606             : 
     607       58964 :     return truncated;
     608             : }

Generated by: LCOV version 1.14