toast_helper.c File Reference

#include "postgres.h"
#include "access/detoast.h"
#include "access/table.h"
#include "access/toast_helper.h"
#include "access/toast_internals.h"
#include "catalog/pg_type_d.h"
#include "varatt.h"

Include dependency graph for toast_helper.c:

Go to the source code of this file.

Functions
void	toast_tuple_init (ToastTupleContext *ttc)
int	toast_tuple_find_biggest_attribute (ToastTupleContext *ttc, bool for_compression, bool check_main)
void	toast_tuple_try_compression (ToastTupleContext *ttc, int attribute)
void	toast_tuple_externalize (ToastTupleContext *ttc, int attribute, int options)
void	toast_tuple_cleanup (ToastTupleContext *ttc)
void	toast_delete_external (Relation rel, Datum *values, bool *isnull, bool is_speculative)

Function Documentation

toast_delete_external()

void toast_delete_external	(	Relation	rel,
		Datum *	values,
		bool *	isnull,
		bool	is_speculative
	)

Definition at line 319 of file toast_helper.c.

{
    TupleDesc   tupleDesc = rel->rd_att;
    int         numAttrs = tupleDesc->natts;
    int         i;
 
    for (i = 0; i < numAttrs; i++)
    {
        if (TupleDescAttr(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);
        }
    }
}

References attlen, i, TupleDescData::natts, RelationData::rd_att, toast_delete_datum(), TupleDescAttr, value, values, and VARATT_IS_EXTERNAL_ONDISK.

Referenced by heap_toast_delete().

toast_tuple_cleanup()

void toast_tuple_cleanup

(

ToastTupleContext *

ttc

)

Definition at line 276 of file toast_helper.c.

{
    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);
        }
    }
}

References DatumGetPointer(), i, TupleDescData::natts, pfree(), RelationData::rd_att, ToastAttrInfo::tai_colflags, toast_delete_datum(), TOAST_NEEDS_DELETE_OLD, TOAST_NEEDS_FREE, TOASTCOL_NEEDS_DELETE_OLD, TOASTCOL_NEEDS_FREE, ToastTupleContext::ttc_attr, ToastTupleContext::ttc_flags, ToastTupleContext::ttc_oldvalues, ToastTupleContext::ttc_rel, and ToastTupleContext::ttc_values.

Referenced by heap_toast_insert_or_update().

toast_tuple_externalize()

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

Definition at line 257 of file toast_helper.c.

{
    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);
}

References DatumGetPointer(), pfree(), ToastAttrInfo::tai_colflags, ToastAttrInfo::tai_oldexternal, TOAST_NEEDS_CHANGE, TOAST_NEEDS_FREE, toast_save_datum(), TOASTCOL_IGNORE, TOASTCOL_NEEDS_FREE, ToastTupleContext::ttc_attr, ToastTupleContext::ttc_flags, ToastTupleContext::ttc_rel, ToastTupleContext::ttc_values, and value.

Referenced by heap_toast_insert_or_update().

toast_tuple_find_biggest_attribute()

int toast_tuple_find_biggest_attribute	(	ToastTupleContext *	ttc,
		bool	for_compression,
		bool	check_main
	)

Definition at line 182 of file toast_helper.c.

{
    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;
}

References DatumGetPointer(), i, MAXALIGN, TupleDescData::natts, RelationData::rd_att, ToastAttrInfo::tai_colflags, ToastAttrInfo::tai_size, TOAST_POINTER_SIZE, TOASTCOL_IGNORE, TOASTCOL_INCOMPRESSIBLE, ToastTupleContext::ttc_attr, ToastTupleContext::ttc_rel, ToastTupleContext::ttc_values, TupleDescAttr, VARATT_IS_COMPRESSED, and VARATT_IS_EXTERNAL.

Referenced by heap_toast_insert_or_update().

toast_tuple_init()

void toast_tuple_init

(

ToastTupleContext *

ttc

)

Definition at line 42 of file toast_helper.c.

{
    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((char *) old_value, (char *) 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;
        }
    }
}

References DatumGetPointer(), detoast_attr(), detoast_external_attr(), i, TupleDescData::natts, PointerGetDatum(), RelationData::rd_att, ToastAttrInfo::tai_colflags, ToastAttrInfo::tai_compression, ToastAttrInfo::tai_oldexternal, ToastAttrInfo::tai_size, TOAST_HAS_NULLS, TOAST_NEEDS_CHANGE, TOAST_NEEDS_DELETE_OLD, TOAST_NEEDS_FREE, TOASTCOL_IGNORE, TOASTCOL_NEEDS_DELETE_OLD, TOASTCOL_NEEDS_FREE, ToastTupleContext::ttc_attr, ToastTupleContext::ttc_flags, ToastTupleContext::ttc_isnull, ToastTupleContext::ttc_oldisnull, ToastTupleContext::ttc_oldvalues, ToastTupleContext::ttc_rel, ToastTupleContext::ttc_values, TupleDescAttr, VARATT_IS_EXTERNAL, VARATT_IS_EXTERNAL_ONDISK, VARSIZE_ANY, and VARSIZE_EXTERNAL.

Referenced by heap_toast_insert_or_update().

toast_tuple_try_compression()

void toast_tuple_try_compression	(	ToastTupleContext *	ttc,
		int	attribute
	)

Definition at line 228 of file toast_helper.c.

{
    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;
    }
}

References DatumGetPointer(), pfree(), ToastAttrInfo::tai_colflags, ToastAttrInfo::tai_compression, ToastAttrInfo::tai_size, toast_compress_datum(), TOAST_NEEDS_CHANGE, TOAST_NEEDS_FREE, TOASTCOL_INCOMPRESSIBLE, TOASTCOL_NEEDS_FREE, ToastTupleContext::ttc_attr, ToastTupleContext::ttc_flags, ToastTupleContext::ttc_values, value, and VARSIZE.

Referenced by heap_toast_insert_or_update().