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

 *

 * toast_helper.c

 *    Helper functions for table AMs implementing compressed or

 *    out-of-line storage of varlena attributes.

 *

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

 *

 * IDENTIFICATION

 *    src/backend/access/table/toast_helper.c

 *

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

 */

#include "postgres.h"

#include "access/detoast.h"

#include "access/toast_helper.h"

#include "access/toast_internals.h"

#include "catalog/pg_type_d.h"

#include "varatt.h"

/*

 * Prepare to TOAST a tuple.

 *

 * tupleDesc, toast_values, and toast_isnull are required parameters; they

 * provide the necessary details about the tuple to be toasted.

 *

 * toast_oldvalues and toast_oldisnull should be NULL for a newly-inserted

 * tuple; for an update, they should describe the existing tuple.

 *

 * All of these arrays should have a length equal to tupleDesc->natts.

 *

 * On return, toast_flags and toast_attr will have been initialized.

 * toast_flags is just a single uint8, but toast_attr is a caller-provided

 * array with a length equal to tupleDesc->natts.  The caller need not

 * perform any initialization of the array before calling this function.

 */

void

toast_tuple_init(ToastTupleContext *ttc)

{

  TupleDesc tupleDesc = ttc->ttc_rel->rd_att;

  int     numAttrs = tupleDesc->natts;

  int     i;

  ttc->ttc_flags = 0;

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

  {

    Form_pg_attribute att = TupleDescAttr(tupleDesc, i);

    struct varlena *old_value;

    struct varlena *new_value;

    ttc->ttc_attr[i].tai_colflags = 0;

    ttc->ttc_attr[i].tai_oldexternal = NULL;

    ttc->ttc_attr[i].tai_compression = att->attcompression;

    if (ttc->ttc_oldvalues != NULL)

    {

      /*

       * For UPDATE get the old and new values of this attribute

       */

      old_value =

        (struct varlena *) DatumGetPointer(ttc->ttc_oldvalues[i]);

      new_value =

        (struct varlena *) DatumGetPointer(ttc->ttc_values[i]);

      /*

       * If the old value is stored on disk, check if it has changed so

       * we have to delete it later.

       */

      if (att->attlen == -1 && !ttc->ttc_oldisnull[i] &&

        VARATT_IS_EXTERNAL_ONDISK(old_value))

      {

        if (ttc->ttc_isnull[i] ||

          !VARATT_IS_EXTERNAL_ONDISK(new_value) ||

          memcmp(old_value, new_value,

               VARSIZE_EXTERNAL(old_value)) != 0)

        {

          /*

           * The old external stored value isn't needed any more

           * after the update

           */

          ttc->ttc_attr[i].tai_colflags |= TOASTCOL_NEEDS_DELETE_OLD;

          ttc->ttc_flags |= TOAST_NEEDS_DELETE_OLD;

        }

        else

        {

          /*

           * This attribute isn't changed by this update so we reuse

           * the original reference to the old value in the new

           * tuple.

           */

          ttc->ttc_attr[i].tai_colflags |= TOASTCOL_IGNORE;

          continue;

        }

      }

    }

    else

    {

      /*

       * For INSERT simply get the new value

       */

      new_value = (struct varlena *) DatumGetPointer(ttc->ttc_values[i]);

    }

    /*

     * Handle NULL attributes

     */

    if (ttc->ttc_isnull[i])

    {

      ttc->ttc_attr[i].tai_colflags |= TOASTCOL_IGNORE;

      ttc->ttc_flags |= TOAST_HAS_NULLS;

      continue;

    }

    /*

     * Now look at varlena attributes

     */

    if (att->attlen == -1)

    {

      /*

       * If the table's attribute says PLAIN always, force it so.

       */

      if (att->attstorage == TYPSTORAGE_PLAIN)

        ttc->ttc_attr[i].tai_colflags |= TOASTCOL_IGNORE;

      /*

       * We took care of UPDATE above, so any external value we find

       * still in the tuple must be someone else's that we cannot reuse

       * (this includes the case of an out-of-line in-memory datum).

       * Fetch it back (without decompression, unless we are forcing

       * PLAIN storage).  If necessary, we'll push it out as a new

       * external value below.

       */

      if (VARATT_IS_EXTERNAL(new_value))

      {

        ttc->ttc_attr[i].tai_oldexternal = new_value;

        if (att->attstorage == TYPSTORAGE_PLAIN)

          new_value = detoast_attr(new_value);

        else

          new_value = detoast_external_attr(new_value);

        ttc->ttc_values[i] = PointerGetDatum(new_value);

        ttc->ttc_attr[i].tai_colflags |= TOASTCOL_NEEDS_FREE;

        ttc->ttc_flags |= (TOAST_NEEDS_CHANGE | TOAST_NEEDS_FREE);

      }

      /*

       * Remember the size of this attribute

       */

      ttc->ttc_attr[i].tai_size = VARSIZE_ANY(new_value);

    }

    else

    {

      /*

       * Not a varlena attribute, plain storage always

       */

      ttc->ttc_attr[i].tai_colflags |= TOASTCOL_IGNORE;

    }

  }

}

/*

 * Find the largest varlena attribute that satisfies certain criteria.

 *

 * The relevant column must not be marked TOASTCOL_IGNORE, and if the

 * for_compression flag is passed as true, it must also not be marked

 * TOASTCOL_INCOMPRESSIBLE.

 *

 * The column must have attstorage EXTERNAL or EXTENDED if check_main is

 * false, and must have attstorage MAIN if check_main is true.

 *

 * The column must have a minimum size of MAXALIGN(TOAST_POINTER_SIZE);

 * if not, no benefit is to be expected by compressing it.

 *

 * The return value is the index of the biggest suitable column, or

 * -1 if there is none.

 */

int

toast_tuple_find_biggest_attribute(ToastTupleContext *ttc,

                   bool for_compression, bool check_main)

{

  TupleDesc tupleDesc = ttc->ttc_rel->rd_att;

  int     numAttrs = tupleDesc->natts;

  int     biggest_attno = -1;

  int32   biggest_size = MAXALIGN(TOAST_POINTER_SIZE);

  int32   skip_colflags = TOASTCOL_IGNORE;

  int     i;

  if (for_compression)

    skip_colflags |= TOASTCOL_INCOMPRESSIBLE;

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

  {

    Form_pg_attribute att = TupleDescAttr(tupleDesc, i);

    if ((ttc->ttc_attr[i].tai_colflags & skip_colflags) != 0)

      continue;

    if (VARATT_IS_EXTERNAL(DatumGetPointer(ttc->ttc_values[i])))

      continue;     /* can't happen, toast_action would be PLAIN */

    if (for_compression &&

      VARATT_IS_COMPRESSED(DatumGetPointer(ttc->ttc_values[i])))

      continue;

    if (check_main && att->attstorage != TYPSTORAGE_MAIN)

      continue;

    if (!check_main && att->attstorage != TYPSTORAGE_EXTENDED &&

      att->attstorage != TYPSTORAGE_EXTERNAL)

      continue;

    if (ttc->ttc_attr[i].tai_size > biggest_size)

    {

      biggest_attno = i;

      biggest_size = ttc->ttc_attr[i].tai_size;

    }

  }

  return biggest_attno;

}

/*

 * Try compression for an attribute.

 *

 * If we find that the attribute is not compressible, mark it so.

 */

void

toast_tuple_try_compression(ToastTupleContext *ttc, int attribute)

{

  Datum    *value = &ttc->ttc_values[attribute];

  Datum   new_value;

  ToastAttrInfo *attr = &ttc->ttc_attr[attribute];

  new_value = toast_compress_datum(*value, attr->tai_compression);

  if (DatumGetPointer(new_value) != NULL)

  {

    /* successful compression */

    if ((attr->tai_colflags & TOASTCOL_NEEDS_FREE) != 0)

      pfree(DatumGetPointer(*value));

    *value = new_value;

    attr->tai_colflags |= TOASTCOL_NEEDS_FREE;

    attr->tai_size = VARSIZE(DatumGetPointer(*value));

    ttc->ttc_flags |= (TOAST_NEEDS_CHANGE | TOAST_NEEDS_FREE);

  }

  else

  {

    /* incompressible, ignore on subsequent compression passes */

    attr->tai_colflags |= TOASTCOL_INCOMPRESSIBLE;

  }

}

/*

 * Move an attribute to external storage.

 */

void

toast_tuple_externalize(ToastTupleContext *ttc, int attribute, int options)

{

  Datum    *value = &ttc->ttc_values[attribute];

  Datum   old_value = *value;

  ToastAttrInfo *attr = &ttc->ttc_attr[attribute];

  attr->tai_colflags |= TOASTCOL_IGNORE;

  *value = toast_save_datum(ttc->ttc_rel, old_value, attr->tai_oldexternal,

                options);

  if ((attr->tai_colflags & TOASTCOL_NEEDS_FREE) != 0)

    pfree(DatumGetPointer(old_value));

  attr->tai_colflags |= TOASTCOL_NEEDS_FREE;

  ttc->ttc_flags |= (TOAST_NEEDS_CHANGE | TOAST_NEEDS_FREE);

}

/*

 * Perform appropriate cleanup after one tuple has been subjected to TOAST.

 */

void

toast_tuple_cleanup(ToastTupleContext *ttc)

{

  TupleDesc tupleDesc = ttc->ttc_rel->rd_att;

  int     numAttrs = tupleDesc->natts;

  /*

   * Free allocated temp values

   */

  if ((ttc->ttc_flags & TOAST_NEEDS_FREE) != 0)

  {

    int     i;

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

    {

      ToastAttrInfo *attr = &ttc->ttc_attr[i];

      if ((attr->tai_colflags & TOASTCOL_NEEDS_FREE) != 0)

        pfree(DatumGetPointer(ttc->ttc_values[i]));

    }

  }

  /*

   * Delete external values from the old tuple

   */

  if ((ttc->ttc_flags & TOAST_NEEDS_DELETE_OLD) != 0)

  {

    int     i;

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

    {

      ToastAttrInfo *attr = &ttc->ttc_attr[i];

      if ((attr->tai_colflags & TOASTCOL_NEEDS_DELETE_OLD) != 0)

        toast_delete_datum(ttc->ttc_rel, ttc->ttc_oldvalues[i], false);

    }

  }

}

/*

 * Check for external stored attributes and delete them from the secondary

 * relation.

 */

void

toast_delete_external(Relation rel, const Datum *values, const bool *isnull,

            bool is_speculative)

{

  TupleDesc tupleDesc = rel->rd_att;

  int     numAttrs = tupleDesc->natts;

  int     i;

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

  {

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

    {

      Datum   value = values[i];

      if (isnull[i])

        continue;

      else if (VARATT_IS_EXTERNAL_ONDISK(value))

        toast_delete_datum(rel, value, is_speculative);

    }

  }

}