/*-------------------------------------------------------------------------

 *

 * heaptoast.c

 *    Heap-specific definitions for external and compressed storage

 *    of variable size attributes.

 *

 * Copyright (c) 2000-2026, PostgreSQL Global Development Group

 *

 *

 * IDENTIFICATION

 *    src/backend/access/heap/heaptoast.c

 *

 *

 * INTERFACE ROUTINES

 *    heap_toast_insert_or_update -

 *      Try to make a given tuple fit into one page by compressing

 *      or moving off attributes

 *

 *    heap_toast_delete -

 *      Reclaim toast storage when a tuple is deleted

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/detoast.h"

#include "access/genam.h"

#include "access/heapam.h"

#include "access/heaptoast.h"

#include "access/toast_helper.h"

#include "access/toast_internals.h"

#include "utils/fmgroids.h"

/* ----------

 * heap_toast_delete -

 *

 *  Cascaded delete toast-entries on DELETE

 * ----------

 */

void

heap_toast_delete(Relation rel, HeapTuple oldtup, bool is_speculative)

{

  TupleDesc tupleDesc;

  Datum   toast_values[MaxHeapAttributeNumber];

  bool    toast_isnull[MaxHeapAttributeNumber];

  /*

   * We should only ever be called for tuples of plain relations or

   * materialized views --- recursing on a toast rel is bad news.

   */

  Assert(rel->rd_rel->relkind == RELKIND_RELATION ||

       rel->rd_rel->relkind == RELKIND_MATVIEW);

  /*

   * Get the tuple descriptor and break down the tuple into fields.

   *

   * NOTE: it's debatable whether to use heap_deform_tuple() here or just

   * heap_getattr() only the varlena columns.  The latter could win if there

   * are few varlena columns and many non-varlena ones. However,

   * heap_deform_tuple costs only O(N) while the heap_getattr way would cost

   * O(N^2) if there are many varlena columns, so it seems better to err on

   * the side of linear cost.  (We won't even be here unless there's at

   * least one varlena column, by the way.)

   */

  tupleDesc = rel->rd_att;

  Assert(tupleDesc->natts <= MaxHeapAttributeNumber);

  heap_deform_tuple(oldtup, tupleDesc, toast_values, toast_isnull);

  /* Do the real work. */

  toast_delete_external(rel, toast_values, toast_isnull, is_speculative);

}

/* ----------

 * heap_toast_insert_or_update -

 *

 *  Delete no-longer-used toast-entries and create new ones to

 *  make the new tuple fit on INSERT or UPDATE

 *

 * Inputs:

 *  newtup: the candidate new tuple to be inserted

 *  oldtup: the old row version for UPDATE, or NULL for INSERT

 *  options: options to be passed to heap_insert() for toast rows

 * Result:

 *  either newtup if no toasting is needed, or a palloc'd modified tuple

 *  that is what should actually get stored

 *

 * NOTE: neither newtup nor oldtup will be modified.  This is a change

 * from the pre-8.1 API of this routine.

 * ----------

 */

HeapTuple

heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup,

              uint32 options)

{

  HeapTuple result_tuple;

  TupleDesc tupleDesc;

  int     numAttrs;

  Size    maxDataLen;

  Size    hoff;

  bool    toast_isnull[MaxHeapAttributeNumber];

  bool    toast_oldisnull[MaxHeapAttributeNumber];

  Datum   toast_values[MaxHeapAttributeNumber];

  Datum   toast_oldvalues[MaxHeapAttributeNumber];

  ToastAttrInfo toast_attr[MaxHeapAttributeNumber];

  ToastTupleContext ttc;

  /*

   * Ignore the INSERT_SPECULATIVE option. Speculative insertions/super

   * deletions just normally insert/delete the toast values. It seems

   * easiest to deal with that here, instead on, potentially, multiple

   * callers.

   */

  options &= ~HEAP_INSERT_SPECULATIVE;

  /*

   * We should only ever be called for tuples of plain relations or

   * materialized views --- recursing on a toast rel is bad news.

   */

  Assert(rel->rd_rel->relkind == RELKIND_RELATION ||

       rel->rd_rel->relkind == RELKIND_MATVIEW);

  /*

   * Get the tuple descriptor and break down the tuple(s) into fields.

   */

  tupleDesc = rel->rd_att;

  numAttrs = tupleDesc->natts;

  Assert(numAttrs <= MaxHeapAttributeNumber);

  heap_deform_tuple(newtup, tupleDesc, toast_values, toast_isnull);

  if (oldtup != NULL)

    heap_deform_tuple(oldtup, tupleDesc, toast_oldvalues, toast_oldisnull);

  /* ----------

   * Prepare for toasting

   * ----------

   */

  ttc.ttc_rel = rel;

  ttc.ttc_values = toast_values;

  ttc.ttc_isnull = toast_isnull;

  if (oldtup == NULL)

  {

    ttc.ttc_oldvalues = NULL;

    ttc.ttc_oldisnull = NULL;

  }

  else

  {

    ttc.ttc_oldvalues = toast_oldvalues;

    ttc.ttc_oldisnull = toast_oldisnull;

  }

  ttc.ttc_attr = toast_attr;

  toast_tuple_init(&ttc);

  /* ----------

   * Compress and/or save external until data fits into target length

   *

   *  1: Inline compress attributes with attstorage EXTENDED, and store very

   *     large attributes with attstorage EXTENDED or EXTERNAL external

   *     immediately

   *  2: Store attributes with attstorage EXTENDED or EXTERNAL external

   *  3: Inline compress attributes with attstorage MAIN

   *  4: Store attributes with attstorage MAIN external

   * ----------

   */

  /* compute header overhead --- this should match heap_form_tuple() */

  hoff = SizeofHeapTupleHeader;

  if ((ttc.ttc_flags & TOAST_HAS_NULLS) != 0)

    hoff += BITMAPLEN(numAttrs);

  hoff = MAXALIGN(hoff);

  /* now convert to a limit on the tuple data size */

  maxDataLen = RelationGetToastTupleTarget(rel, TOAST_TUPLE_TARGET) - hoff;

  /*

   * Look for attributes with attstorage EXTENDED to compress.  Also find

   * large attributes with attstorage EXTENDED or EXTERNAL, and store them

   * external.

   */

  while (heap_compute_data_size(tupleDesc,

                  toast_values, toast_isnull,

                  true) > maxDataLen)

  {

    int     biggest_attno;

    biggest_attno = toast_tuple_find_biggest_attribute(&ttc, true, false);

    if (biggest_attno < 0)

      break;

    /*

     * Attempt to compress it inline, if it has attstorage EXTENDED

     */

    if (TupleDescAttr(tupleDesc, biggest_attno)->attstorage == TYPSTORAGE_EXTENDED)

      toast_tuple_try_compression(&ttc, biggest_attno);

    else

    {

      /*

       * has attstorage EXTERNAL, ignore on subsequent compression

       * passes

       */

      toast_attr[biggest_attno].tai_colflags |= TOASTCOL_INCOMPRESSIBLE;

    }

    /*

     * If this value is by itself more than maxDataLen (after compression

     * if any), push it out to the toast table immediately, if possible.

     * This avoids uselessly compressing other fields in the common case

     * where we have one long field and several short ones.

     *

     * XXX maybe the threshold should be less than maxDataLen?

     */

    if (toast_attr[biggest_attno].tai_size > maxDataLen &&

      rel->rd_rel->reltoastrelid != InvalidOid)

      toast_tuple_externalize(&ttc, biggest_attno, options);

  }

  /*

   * Second we look for attributes of attstorage EXTENDED or EXTERNAL that

   * are still inline, and make them external.  But skip this if there's no

   * toast table to push them to.

   */

  while (heap_compute_data_size(tupleDesc,

                  toast_values, toast_isnull,

                  true) > maxDataLen &&

       rel->rd_rel->reltoastrelid != InvalidOid)

  {

    int     biggest_attno;

    biggest_attno = toast_tuple_find_biggest_attribute(&ttc, false, false);

    if (biggest_attno < 0)

      break;

    toast_tuple_externalize(&ttc, biggest_attno, options);

  }

  /*

   * Round 3 - this time we take attributes with storage MAIN into

   * compression

   */

  while (heap_compute_data_size(tupleDesc,

                  toast_values, toast_isnull,

                  true) > maxDataLen)

  {

    int     biggest_attno;

    biggest_attno = toast_tuple_find_biggest_attribute(&ttc, true, true);

    if (biggest_attno < 0)

      break;

    toast_tuple_try_compression(&ttc, biggest_attno);

  }

  /*

   * Finally we store attributes of type MAIN externally.  At this point we

   * increase the target tuple size, so that MAIN attributes aren't stored

   * externally unless really necessary.

   */

  maxDataLen = TOAST_TUPLE_TARGET_MAIN - hoff;

  while (heap_compute_data_size(tupleDesc,

                  toast_values, toast_isnull,

                  true) > maxDataLen &&

       rel->rd_rel->reltoastrelid != InvalidOid)

  {

    int     biggest_attno;

    biggest_attno = toast_tuple_find_biggest_attribute(&ttc, false, true);

    if (biggest_attno < 0)

      break;

    toast_tuple_externalize(&ttc, biggest_attno, options);

  }

  /*

   * In the case we toasted any values, we need to build a new heap tuple

   * with the changed values.

   */

  if ((ttc.ttc_flags & TOAST_NEEDS_CHANGE) != 0)

  {

    HeapTupleHeader olddata = newtup->t_data;

    HeapTupleHeader new_data;

    int32   new_header_len;

    int32   new_data_len;

    int32   new_tuple_len;

    /*

     * Calculate the new size of the tuple.

     *

     * Note: we used to assume here that the old tuple's t_hoff must equal

     * the new_header_len value, but that was incorrect.  The old tuple

     * might have a smaller-than-current natts, if there's been an ALTER

     * TABLE ADD COLUMN since it was stored; and that would lead to a

     * different conclusion about the size of the null bitmap, or even

     * whether there needs to be one at all.

     */

    new_header_len = SizeofHeapTupleHeader;

    if ((ttc.ttc_flags & TOAST_HAS_NULLS) != 0)

      new_header_len += BITMAPLEN(numAttrs);

    new_header_len = MAXALIGN(new_header_len);

    new_data_len = heap_compute_data_size(tupleDesc,

                        toast_values, toast_isnull,

                        false);

    new_tuple_len = new_header_len + new_data_len;

    /*

     * Allocate and zero the space needed, and fill HeapTupleData fields.

     */

    result_tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + new_tuple_len);

    result_tuple->t_len = new_tuple_len;

    result_tuple->t_self = newtup->t_self;

    result_tuple->t_tableOid = newtup->t_tableOid;

    new_data = (HeapTupleHeader) ((char *) result_tuple + HEAPTUPLESIZE);

    result_tuple->t_data = new_data;

    /*

     * Copy the existing tuple header, but adjust natts and t_hoff.

     */

    memcpy(new_data, olddata, SizeofHeapTupleHeader);

    HeapTupleHeaderSetNatts(new_data, numAttrs);

    new_data->t_hoff = new_header_len;

    /* Copy over the data, and fill the null bitmap if needed */

    heap_fill_tuple(tupleDesc,

            toast_values,

            toast_isnull,

            (char *) new_data + new_header_len,

            new_data_len,

            &(new_data->t_infomask),

            ((ttc.ttc_flags & TOAST_HAS_NULLS) != 0) ?

            new_data->t_bits : NULL);

  }

  else

    result_tuple = newtup;

  toast_tuple_cleanup(&ttc);

  return result_tuple;

}

/* ----------

 * toast_flatten_tuple -

 *

 *  "Flatten" a tuple to contain no out-of-line toasted fields.

 *  (This does not eliminate compressed or short-header datums.)

 *

 *  Note: we expect the caller already checked HeapTupleHasExternal(tup),

 *  so there is no need for a short-circuit path.

 * ----------

 */

HeapTuple

toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)

{

  HeapTuple new_tuple;

  int     numAttrs = tupleDesc->natts;

  int     i;

  Datum   toast_values[MaxTupleAttributeNumber];

  bool    toast_isnull[MaxTupleAttributeNumber];

  bool    toast_free[MaxTupleAttributeNumber];

  /*

   * Break down the tuple into fields.

   */

  Assert(numAttrs <= MaxTupleAttributeNumber);

  heap_deform_tuple(tup, tupleDesc, toast_values, toast_isnull);

  memset(toast_free, 0, numAttrs * sizeof(bool));

  for (i = 0; i < numAttrs; i++)

  {

    /*

     * Look at non-null varlena attributes

     */

    if (!toast_isnull[i] && TupleDescCompactAttr(tupleDesc, i)->attlen == -1)

    {

      varlena    *new_value;

      new_value = (varlena *) DatumGetPointer(toast_values[i]);

      if (VARATT_IS_EXTERNAL(new_value))

      {

        new_value = detoast_external_attr(new_value);

        toast_values[i] = PointerGetDatum(new_value);

        toast_free[i] = true;

      }

    }

  }

  /*

   * Form the reconfigured tuple.

   */

  new_tuple = heap_form_tuple(tupleDesc, toast_values, toast_isnull);

  /*

   * Be sure to copy the tuple's identity fields.  We also make a point of

   * copying visibility info, just in case anybody looks at those fields in

   * a syscache entry.

   */

  new_tuple->t_self = tup->t_self;

  new_tuple->t_tableOid = tup->t_tableOid;

  new_tuple->t_data->t_choice = tup->t_data->t_choice;

  new_tuple->t_data->t_ctid = tup->t_data->t_ctid;

  new_tuple->t_data->t_infomask &= ~HEAP_XACT_MASK;

  new_tuple->t_data->t_infomask |=

    tup->t_data->t_infomask & HEAP_XACT_MASK;

  new_tuple->t_data->t_infomask2 &= ~HEAP2_XACT_MASK;

  new_tuple->t_data->t_infomask2 |=

    tup->t_data->t_infomask2 & HEAP2_XACT_MASK;

  /*

   * If the input tuple is a datum tuple, need to set its length (which was

   * reset by the t_choice assignment above).

   *

   * If it was versioned and had fewer attributes than the descriptor, it

   * will now be full-width and as part of that might have a different

   * version.

   */

  if (HeapTupleHeaderIsDatum(tup->t_data))

    heap_tuple_set_datum(new_tuple->t_data, tupleDesc, new_tuple->t_len);

  /*

   * Free allocated temp values

   */

  for (i = 0; i < numAttrs; i++)

    if (toast_free[i])

      pfree(DatumGetPointer(toast_values[i]));

  return new_tuple;

}

/* ----------

 * toast_flatten_tuple_to_datum -

 *

 *  "Flatten" a tuple containing out-of-line toasted fields into a Datum.

 *  The result is always palloc'd in the current memory context.

 *

 *  We have a general rule that Datums of container types (rows, arrays,

 *  ranges, etc) must not contain any external TOAST pointers.  Without

 *  this rule, we'd have to look inside each Datum when preparing a tuple

 *  for storage, which would be expensive and would fail to extend cleanly

 *  to new sorts of container types.

 *

 *  However, we don't want to say that tuples represented as HeapTuples

 *  can't contain toasted fields, so instead this routine should be called

 *  when such a HeapTuple is being converted into a Datum.

 *

 *  While we're at it, we decompress any compressed fields too.  This is not

 *  necessary for correctness, but reflects an expectation that compression

 *  will be more effective if applied to the whole tuple not individual

 *  fields.  We are not so concerned about that that we want to deconstruct

 *  and reconstruct tuples just to get rid of compressed fields, however.

 *  So callers typically won't call this unless they see that the tuple has

 *  at least one external field.

 *

 *  On the other hand, in-line short-header varlena fields are left alone.

 *  If we "untoasted" them here, they'd just get changed back to short-header

 *  format anyway within heap_fill_tuple.

 * ----------

 */

Datum

toast_flatten_tuple_to_datum(HeapTupleHeader tup,

               uint32 tup_len,

               TupleDesc tupleDesc)

{

  HeapTupleHeader new_data;

  int32   new_header_len;

  int32   new_data_len;

  int32   new_tuple_len;

  HeapTupleData tmptup;

  int     numAttrs = tupleDesc->natts;

  int     i;

  bool    has_nulls = false;

  Datum   toast_values[MaxTupleAttributeNumber];

  bool    toast_isnull[MaxTupleAttributeNumber];

  bool    toast_free[MaxTupleAttributeNumber];

  /* Build a temporary HeapTuple control structure */

  tmptup.t_len = tup_len;

  ItemPointerSetInvalid(&(tmptup.t_self));

  tmptup.t_tableOid = InvalidOid;

  tmptup.t_data = tup;

  /*

   * Break down the tuple into fields.

   */

  Assert(numAttrs <= MaxTupleAttributeNumber);

  heap_deform_tuple(&tmptup, tupleDesc, toast_values, toast_isnull);

  memset(toast_free, 0, numAttrs * sizeof(bool));

  for (i = 0; i < numAttrs; i++)

  {

    /*

     * Look at non-null varlena attributes

     */

    if (toast_isnull[i])

      has_nulls = true;

    else if (TupleDescCompactAttr(tupleDesc, i)->attlen == -1)

    {

      varlena    *new_value;

      new_value = (varlena *) DatumGetPointer(toast_values[i]);

      if (VARATT_IS_EXTERNAL(new_value) ||

        VARATT_IS_COMPRESSED(new_value))

      {

        new_value = detoast_attr(new_value);

        toast_values[i] = PointerGetDatum(new_value);

        toast_free[i] = true;

      }

    }

  }

  /*

   * Calculate the new size of the tuple.

   *

   * This should match the reconstruction code in

   * heap_toast_insert_or_update.

   */

  new_header_len = SizeofHeapTupleHeader;

  if (has_nulls)

    new_header_len += BITMAPLEN(numAttrs);

  new_header_len = MAXALIGN(new_header_len);

  new_data_len = heap_compute_data_size(tupleDesc,

                      toast_values, toast_isnull,

                      false);

  new_tuple_len = new_header_len + new_data_len;

  new_data = (HeapTupleHeader) palloc0(new_tuple_len);

  /*

   * Copy the existing tuple header, but adjust natts and t_hoff.

   */

  memcpy(new_data, tup, SizeofHeapTupleHeader);

  HeapTupleHeaderSetNatts(new_data, numAttrs);

  new_data->t_hoff = new_header_len;

  /* Set the composite-Datum header fields correctly */

  heap_tuple_set_datum(new_data, tupleDesc, new_tuple_len);

  /* Copy over the data, and fill the null bitmap if needed */

  heap_fill_tuple(tupleDesc,

          toast_values,

          toast_isnull,

          (char *) new_data + new_header_len,

          new_data_len,

          &(new_data->t_infomask),

          has_nulls ? new_data->t_bits : NULL);

  /*

   * Free allocated temp values

   */

  for (i = 0; i < numAttrs; i++)

    if (toast_free[i])

      pfree(DatumGetPointer(toast_values[i]));

  return PointerGetDatum(new_data);

}

/* ----------

 * toast_build_flattened_tuple -

 *

 *  Build a tuple containing no out-of-line toasted fields.

 *  (This does not eliminate compressed or short-header datums.)

 *

 *  This is essentially just like heap_form_tuple, except that it will

 *  expand any external-data pointers beforehand.

 *

 *  It's not very clear whether it would be preferable to decompress

 *  in-line compressed datums while at it.  For now, we don't.

 * ----------

 */

HeapTuple

toast_build_flattened_tuple(TupleDesc tupleDesc,

              const Datum *values,

              const bool *isnull)

{

  HeapTuple new_tuple;

  int     numAttrs = tupleDesc->natts;

  int     num_to_free;

  int     i;

  Datum   new_values[MaxTupleAttributeNumber];

  void     *freeable_values[MaxTupleAttributeNumber];

  /*

   * We can pass the caller's isnull array directly to heap_form_tuple, but

   * we potentially need to modify the values array.

   */

  Assert(numAttrs <= MaxTupleAttributeNumber);

  memcpy(new_values, values, numAttrs * sizeof(Datum));

  num_to_free = 0;

  for (i = 0; i < numAttrs; i++)

  {

    /*

     * Look at non-null varlena attributes

     */

    if (!isnull[i] && TupleDescCompactAttr(tupleDesc, i)->attlen == -1)

    {

      varlena    *new_value;

      new_value = (varlena *) DatumGetPointer(new_values[i]);

      if (VARATT_IS_EXTERNAL(new_value))

      {

        new_value = detoast_external_attr(new_value);

        new_values[i] = PointerGetDatum(new_value);

        freeable_values[num_to_free++] = new_value;

      }

    }

  }

  /*

   * Form the reconfigured tuple.

   */

  new_tuple = heap_form_tuple(tupleDesc, new_values, isnull);

  /*

   * Free allocated temp values

   */

  for (i = 0; i < num_to_free; i++)

    pfree(freeable_values[i]);

  return new_tuple;

}

/*

 * Fetch a TOAST slice from a heap table.

 *

 * toastrel is the relation from which chunks are to be fetched.

 * valueid identifies the TOAST value from which chunks are being fetched.

 * attrsize is the total size of the TOAST value.

 * sliceoffset is the byte offset within the TOAST value from which to fetch.

 * slicelength is the number of bytes to be fetched from the TOAST value.

 * result is the varlena into which the results should be written.

 */

void

heap_fetch_toast_slice(Relation toastrel, Oid8 valueid, int32 attrsize,

             int32 sliceoffset, int32 slicelength,

             varlena *result)

{

  Relation   *toastidxs;

  ScanKeyData toastkey[3];

  TupleDesc toasttupDesc = toastrel->rd_att;

  int     nscankeys;

  SysScanDesc toastscan;

  HeapTuple ttup;

  int32   expectedchunk;

  int32   totalchunks;

  int     startchunk;

  int     endchunk;

  int     num_indexes;

  int     validIndex;

  int32   max_chunk_size;

  Oid     toast_typid;

  /* Look for the valid index of toast relation */

  validIndex = toast_open_indexes(toastrel,

                  AccessShareLock,

                  &toastidxs,

                  &num_indexes);

  toast_typid = TupleDescAttr(toastrel->rd_att, 0)->atttypid;

  max_chunk_size = TOAST_MAX_CHUNK_SIZE(toast_typid);

  totalchunks = ((attrsize - 1) / max_chunk_size) + 1;

  startchunk = sliceoffset / max_chunk_size;

  endchunk = (sliceoffset + slicelength - 1) / max_chunk_size;

  Assert(endchunk <= totalchunks);

  /* Set up a scan key to fetch from the index. */

  toast_valueid_scankey_init(&toastkey[0], toast_typid, valueid);

  /*

   * No additional condition if fetching all chunks. Otherwise, use an

   * equality condition for one chunk, and a range condition otherwise.

   */

  if (startchunk == 0 && endchunk == totalchunks - 1)

    nscankeys = 1;

  else if (startchunk == endchunk)

  {

    ScanKeyInit(&toastkey[1],

          (AttrNumber) 2,

          BTEqualStrategyNumber, F_INT4EQ,

          Int32GetDatum(startchunk));

    nscankeys = 2;

  }

  else

  {

    ScanKeyInit(&toastkey[1],

          (AttrNumber) 2,

          BTGreaterEqualStrategyNumber, F_INT4GE,

          Int32GetDatum(startchunk));

    ScanKeyInit(&toastkey[2],

          (AttrNumber) 2,

          BTLessEqualStrategyNumber, F_INT4LE,

          Int32GetDatum(endchunk));

    nscankeys = 3;

  }

  /* Prepare for scan */

  toastscan = systable_beginscan_ordered(toastrel, toastidxs[validIndex],

                       get_toast_snapshot(), nscankeys, toastkey);

  /*

   * Read the chunks by index

   *

   * The index is on (valueid, chunkidx) so they will come in order

   */

  expectedchunk = startchunk;

  while ((ttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)

  {

    int32   curchunk;

    Pointer   chunk;

    bool    isnull;

    char     *chunkdata;

    int32   chunksize;

    int32   expected_size;

    int32   chcpystrt;

    int32   chcpyend;

    /*

     * Have a chunk, extract the sequence number and the data

     */

    curchunk = DatumGetInt32(fastgetattr(ttup, 2, toasttupDesc, &isnull));

    Assert(!isnull);

    chunk = DatumGetPointer(fastgetattr(ttup, 3, toasttupDesc, &isnull));

    Assert(!isnull);

    if (!VARATT_IS_EXTENDED(chunk))

    {

      chunksize = VARSIZE(chunk) - VARHDRSZ;

      chunkdata = VARDATA(chunk);

    }

    else if (VARATT_IS_SHORT(chunk))

    {

      /* could happen due to heap_form_tuple doing its thing */

      chunksize = VARSIZE_SHORT(chunk) - VARHDRSZ_SHORT;

      chunkdata = VARDATA_SHORT(chunk);

    }

    else

    {

      /* should never happen */

      elog(ERROR, "found toasted toast chunk for toast value %" PRIu64 " in %s",

         valueid, RelationGetRelationName(toastrel));

      chunksize = 0;    /* keep compiler quiet */

      chunkdata = NULL;

    }

    /*

     * Some checks on the data we've found

     */

    if (curchunk != expectedchunk)

      ereport(ERROR,

          (errcode(ERRCODE_DATA_CORRUPTED),

           errmsg_internal("unexpected chunk number %d (expected %d) for toast value %" PRIu64 " in %s",

                   curchunk, expectedchunk, valueid,

                   RelationGetRelationName(toastrel))));

    if (curchunk > endchunk)

      ereport(ERROR,

          (errcode(ERRCODE_DATA_CORRUPTED),

           errmsg_internal("unexpected chunk number %d (out of range %d..%d) for toast value %" PRIu64 " in %s",

                   curchunk,

                   startchunk, endchunk, valueid,

                   RelationGetRelationName(toastrel))));

    expected_size = curchunk < totalchunks - 1 ? max_chunk_size

      : attrsize - ((totalchunks - 1) * max_chunk_size);

    if (chunksize != expected_size)

      ereport(ERROR,

          (errcode(ERRCODE_DATA_CORRUPTED),

           errmsg_internal("unexpected chunk size %d (expected %d) in chunk %d of %d for toast value %" PRIu64 " in %s",

                   chunksize, expected_size,

                   curchunk, totalchunks, valueid,

                   RelationGetRelationName(toastrel))));

    /*

     * Copy the data into proper place in our result

     */

    chcpystrt = 0;

    chcpyend = chunksize - 1;

    if (curchunk == startchunk)

      chcpystrt = sliceoffset % max_chunk_size;

    if (curchunk == endchunk)

      chcpyend = (sliceoffset + slicelength - 1) % max_chunk_size;

    memcpy(VARDATA(result) +

         (curchunk * max_chunk_size - sliceoffset) + chcpystrt,

         chunkdata + chcpystrt,

         (chcpyend - chcpystrt) + 1);

    expectedchunk++;

  }

  /*

   * Final checks that we successfully fetched the datum

   */

  if (expectedchunk != (endchunk + 1))

    ereport(ERROR,

        (errcode(ERRCODE_DATA_CORRUPTED),

         errmsg_internal("missing chunk number %d for toast value %" PRIu64 " in %s",

                 expectedchunk, valueid,

                 RelationGetRelationName(toastrel))));

  /* End scan and close indexes. */

  systable_endscan_ordered(toastscan);

  toast_close_indexes(toastidxs, num_indexes, AccessShareLock);

}