tupmacs.h File Reference

#include "catalog/pg_type_d.h"
#include "port/pg_bitutils.h"
#include "port/pg_bswap.h"
#include "varatt.h"

Include dependency graph for tupmacs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	SPREAD_BITS_MULTIPLIER_32   0x204081U
#define	fetchatt(A, T)   fetch_att(T, (A)->attbyval, (A)->attlen)
#define	att_align_datum(cur_offset, attalign, attlen, attdatum)
#define	att_datum_alignby(cur_offset, attalignby, attlen, attdatum)
#define	att_align_pointer(cur_offset, attalign, attlen, attptr)
#define	att_pointer_alignby(cur_offset, attalignby, attlen, attptr)
#define	att_align_nominal(cur_offset, attalign)    att_nominal_alignby(cur_offset, typalign_to_alignby(attalign))
#define	att_nominal_alignby(cur_offset, attalignby)    TYPEALIGN(attalignby, cur_offset)
#define	att_addlength_datum(cur_offset, attlen, attdatum)    att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum))
#define	att_addlength_pointer(cur_offset, attlen, attptr)

Functions
static bool	att_isnull (int ATT, const bits8 *BITS)
static void	populate_isnull_array (const bits8 *bits, int natts, bool *isnull)
static Datum	fetch_att (const void *T, bool attbyval, int attlen)
static Datum	fetch_att_noerr (const void *T, bool attbyval, int attlen)
static Datum	align_fetch_then_add (const char *tupptr, uint32 *off, bool attbyval, int attlen, uint8 attalignby)
static int	first_null_attr (const bits8 *bits, int natts)
static uint8	typalign_to_alignby (char typalign)
static void	store_att_byval (void *T, Datum newdatum, int attlen)

Macro Definition Documentation

att_addlength_datum

#define att_addlength_datum	(		cur_offset,
			attlen,
			attdatum
	)		att_addlength_pointer(cur_offset, attlen, DatumGetPointer(attdatum))

Definition at line 419 of file tupmacs.h.

    : (((attlen) == -1) ? \
    ( \
        (cur_offset) + VARSIZE_ANY(attptr) \
    ) \
    : \
    ( \
        AssertMacro((attlen) == -2), \
        (cur_offset) + (strlen((const char *) (attptr)) + 1) \
    )) \
)
 
#ifndef FRONTEND
/*
 * store_att_byval is a partial inverse of fetch_att: store a given Datum
 * value into a tuple data area at the specified address.  However, it only
 * handles the byval case, because in typical usage the caller needs to
 * distinguish by-val and by-ref cases anyway, and so a do-it-all function
 * wouldn't be convenient.
 */
static inline void
store_att_byval(void *T, Datum newdatum, int attlen)
{
    switch (attlen)
    {
        case sizeof(char):
            *(char *) T = DatumGetChar(newdatum);
            break;
        case sizeof(int16):
            *(int16 *) T = DatumGetInt16(newdatum);
            break;
        case sizeof(int32):
            *(int32 *) T = DatumGetInt32(newdatum);
            break;
        case sizeof(int64):
            *(int64 *) T = DatumGetInt64(newdatum);
            break;
        default:
            elog(ERROR, "unsupported byval length: %d", attlen);
    }
}
#endif                          /* FRONTEND */
 
#endif                          /* TUPMACS_H */

att_addlength_pointer

#define att_addlength_pointer	(		cur_offset,
			attlen,
			attptr
	)

Value:

( \
    ((attlen) > 0) ? \
    ( \
        (cur_offset) + (attlen) \
    ) \
    : (((attlen) == -1) ? \
    ( \
        (cur_offset) + VARSIZE_ANY(attptr) \
    ) \
    : \
    ( \
        AssertMacro((attlen) == -2), \
        (cur_offset) + (strlen((const char *) (attptr)) + 1) \
    )) \
)

Definition at line 431 of file tupmacs.h.

    : (((attlen) == -1) ? \
    ( \
        (cur_offset) + VARSIZE_ANY(attptr) \
    ) \
    : \
    ( \
        AssertMacro((attlen) == -2), \
        (cur_offset) + (strlen((const char *) (attptr)) + 1) \
    )) \
)

att_align_datum

#define att_align_datum	(		cur_offset,
			attalign,
			attlen,
			attdatum
	)

Value:

( \
    ((attlen) == -1 && VARATT_IS_SHORT(DatumGetPointer(attdatum))) ? \
    (uintptr_t) (cur_offset) : \
	att_align_nominal(cur_offset, attalign) \
)

Definition at line 341 of file tupmacs.h.

                             : \
	att_align_nominal(cur_offset, attalign) \
)

att_align_nominal

#define att_align_nominal	(		cur_offset,
			attalign
	)		att_nominal_alignby(cur_offset, typalign_to_alignby(attalign))

Definition at line 404 of file tupmacs.h.

att_align_pointer

#define att_align_pointer	(		cur_offset,
			attalign,
			attlen,
			attptr
	)

Value:

( \
    ((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? \
    (uintptr_t) (cur_offset) : \
    att_align_nominal(cur_offset, attalign) \
)

Definition at line 372 of file tupmacs.h.

                             : \
	att_align_nominal(cur_offset, attalign) \
)

att_datum_alignby

#define att_datum_alignby	(		cur_offset,
			attalignby,
			attlen,
			attdatum
	)

Value:

    ( \
    ((attlen) == -1 && VARATT_IS_SHORT(DatumGetPointer(attdatum))) ? \
    (uintptr_t) (cur_offset) : \
	TYPEALIGN(attalignby, cur_offset))

Definition at line 352 of file tupmacs.h.

                             : \
	TYPEALIGN(attalignby, cur_offset))

att_nominal_alignby

#define att_nominal_alignby	(		cur_offset,
			attalignby
	)		TYPEALIGN(attalignby, cur_offset)

Definition at line 411 of file tupmacs.h.

att_pointer_alignby

#define att_pointer_alignby	(		cur_offset,
			attalignby,
			attlen,
			attptr
	)

Value:

    ( \
    ((attlen) == -1 && VARATT_NOT_PAD_BYTE(attptr)) ? \
    (uintptr_t) (cur_offset) : \
    TYPEALIGN(attalignby, cur_offset))

Definition at line 383 of file tupmacs.h.

                             : \
	TYPEALIGN(attalignby, cur_offset))

fetchatt

#define fetchatt	(		A,
			T
	)		fetch_att(T, (A)->attbyval, (A)->attlen)

Definition at line 102 of file tupmacs.h.

SPREAD_BITS_MULTIPLIER_32

#define SPREAD_BITS_MULTIPLIER_32   0x204081U

Function Documentation

align_fetch_then_add()

static Datum align_fetch_then_add ( const char *  tupptr, uint32 *  off, bool  attbyval, int  attlen, uint8  attalignby  )

inlinestatic

Definition at line 172 of file tupmacs.h.

{
    Datum       res;
 
    if (attlen > 0)
    {
        const char *offset_ptr;
 
        *off = TYPEALIGN(attalignby, *off);
        offset_ptr = tupptr + *off;
        *off += attlen;
        if (attbyval)
        {
            switch (attlen)
            {
                case sizeof(char):
                    return CharGetDatum(*((const char *) offset_ptr));
                case sizeof(int16):
                    return Int16GetDatum(*((const int16 *) offset_ptr));
                case sizeof(int32):
                    return Int32GetDatum(*((const int32 *) offset_ptr));
                default:
 
                    /*
                     * populate_compact_attribute_internal() should have
                     * checked
                     */
                    Assert(attlen == sizeof(int64));
                    return Int64GetDatum(*((const int64 *) offset_ptr));
            }
        }
        return PointerGetDatum(offset_ptr);
    }
    else if (attlen == -1)
    {
        if (!VARATT_IS_SHORT(tupptr + *off))
            *off = TYPEALIGN(attalignby, *off);
 
        res = PointerGetDatum(tupptr + *off);
        *off += VARSIZE_ANY(DatumGetPointer(res));
        return res;
    }
    else
    {
        Assert(attlen == -2);
        *off = TYPEALIGN(attalignby, *off);
        res = PointerGetDatum(tupptr + *off);
        *off += strlen(tupptr + *off) + 1;
        return res;
    }
}

References Assert, attbyval, attlen, CharGetDatum(), DatumGetPointer(), fb(), Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), PointerGetDatum(), TYPEALIGN, VARATT_IS_SHORT(), and VARSIZE_ANY().

Referenced by heap_deform_tuple(), index_deform_tuple_internal(), and slot_deform_heap_tuple().

att_isnull()

static bool att_isnull ( int  ATT, const bits8 *  BITS  )

inlinestatic

Definition at line 28 of file tupmacs.h.

{
    return !(BITS[ATT >> 3] & (1 << (ATT & 0x07)));
}

References fb().

Referenced by brin_deconstruct_tuple(), check_tuple_attribute(), fastgetattr(), first_null_attr(), heap_attisnull(), heap_deform_tuple(), index_deform_tuple_internal(), index_getattr(), nocache_index_getattr(), nocachegetattr(), and tuple_data_split_internal().

fetch_att()

static Datum fetch_att ( const void *  T, bool  attbyval, int  attlen  )

inlinestatic

Definition at line 108 of file tupmacs.h.

{
    if (attbyval)
    {
        switch (attlen)
        {
            case sizeof(char):
                return CharGetDatum(*((const char *) T));
            case sizeof(int16):
                return Int16GetDatum(*((const int16 *) T));
            case sizeof(int32):
                return Int32GetDatum(*((const int32 *) T));
            case sizeof(int64):
                return Int64GetDatum(*((const int64 *) T));
            default:
                elog(ERROR, "unsupported byval length: %d", attlen);
                return 0;
        }
    }
    else
        return PointerGetDatum(T);
}

References attbyval, attlen, CharGetDatum(), elog, ERROR, fb(), Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), PointerGetDatum(), and T.

Referenced by array_iter_next(), array_iterate(), array_replace_internal(), array_to_text_internal(), ArrayCast(), brin_range_deserialize(), deconstruct_array(), ExecEvalHashedScalarArrayOp(), ExecEvalScalarArrayOp(), multirange_get_bounds(), PLyList_FromArray_recurse(), range_deserialize(), statext_mcv_deserialize(), width_bucket_array_fixed(), and width_bucket_array_variable().

fetch_att_noerr()

static Datum fetch_att_noerr ( const void *  T, bool  attbyval, int  attlen  )

inlinestatic

Definition at line 137 of file tupmacs.h.

{
    if (attbyval)
    {
        switch (attlen)
        {
            case sizeof(int32):
                return Int32GetDatum(*((const int32 *) T));
            case sizeof(int16):
                return Int16GetDatum(*((const int16 *) T));
            case sizeof(char):
                return CharGetDatum(*((const char *) T));
            default:
                Assert(attlen == sizeof(int64));
                return Int64GetDatum(*((const int64 *) T));
        }
    }
    else
        return PointerGetDatum(T);
}

References Assert, attbyval, attlen, CharGetDatum(), fb(), Int16GetDatum(), Int32GetDatum(), Int64GetDatum(), PointerGetDatum(), and T.

Referenced by heap_deform_tuple(), index_deform_tuple_internal(), and slot_deform_heap_tuple().

first_null_attr()

static int first_null_attr ( const bits8 *  bits, int  natts  )

inlinestatic

Definition at line 244 of file tupmacs.h.

{
    int         nattByte = natts >> 3;
    int         bytenum;
    int         res;
 
#ifdef USE_ASSERT_CHECKING
    int         firstnull_check = natts;
 
    /* Do it the slow way and check we get the same answer. */
    for (int i = 0; i < natts; i++)
    {
        if (att_isnull(i, bits))
        {
            firstnull_check = i;
            break;
        }
    }
#endif
 
    /* Process all bytes up to just before the byte for the natts attribute */
    for (bytenum = 0; bytenum < nattByte; bytenum++)
    {
        /* break if there's any NULL attrs (a 0 bit) */
        if (bits[bytenum] != 0xFF)
            break;
    }
 
    /*
     * Look for the highest 0-bit in the 'bytenum' element.  To do this, we
     * promote the uint8 to uint32 before performing the bitwise NOT and
     * looking for the first 1-bit.  This works even when the byte is 0xFF, as
     * the bitwise NOT of 0xFF in 32 bits is 0xFFFFFF00, in which case
     * pg_rightmost_one_pos32() will return 8.  We may end up with a value
     * higher than natts here, but we'll fix that with the Min() below.
     */
    res = bytenum << 3;
    res += pg_rightmost_one_pos32(~((uint32) bits[bytenum]));
 
    /*
     * Since we did no masking to mask out bits beyond the natts'th bit, we
     * may have found a bit higher than natts, so we must cap res to natts
     */
    res = Min(res, natts);
 
    /* Ensure we got the same answer as the att_isnull() loop got */
    Assert(res == firstnull_check);
 
    return res;
}

References Assert, att_isnull(), fb(), i, Min, and pg_rightmost_one_pos32().

Referenced by heap_deform_tuple(), index_deform_tuple_internal(), nocache_index_getattr(), nocachegetattr(), and slot_deform_heap_tuple().

populate_isnull_array()

static void populate_isnull_array ( const bits8 *  bits, int  natts, bool *  isnull  )

inlinestatic

Definition at line 43 of file tupmacs.h.

{
    int         nbytes = (natts + 7) >> 3;
 
    /*
     * Multiplying the inverted NULL bitmap byte by this value results in the
     * lowest bit in each byte being set the same as each bit of the inverted
     * byte.  We perform this as 2 32-bit operations rather than a single
     * 64-bit operation as multiplying by the required value to do this in
     * 64-bits would result in overflowing a uint64 in some cases.
     *
     * XXX if we ever require BMI2 (-march=x86-64-v3), then this could be done
     * more efficiently on most X86-64 CPUs with the PDEP instruction.  Beware
     * that some chips (e.g. AMD's Zen2) are horribly inefficient at PDEP.
     */
#define SPREAD_BITS_MULTIPLIER_32 0x204081U
 
    for (int i = 0; i < nbytes; i++, isnull += 8)
    {
        uint64      isnull_8;
        bits8       nullbyte = ~bits[i];
 
        /* Convert the lower 4 bits of NULL bitmap word into a 64 bit int */
        isnull_8 = (nullbyte & 0xf) * SPREAD_BITS_MULTIPLIER_32;
 
        /*
         * Convert the upper 4 bits of NULL bitmap word into a 64 bit int,
         * shift into the upper 32 bit and bitwise-OR with the result of the
         * lower 4 bits.
         */
        isnull_8 |= ((uint64) ((nullbyte >> 4) * SPREAD_BITS_MULTIPLIER_32)) << 32;
 
        /* Mask out all other bits apart from the lowest bit of each byte. */
        isnull_8 &= UINT64CONST(0x0101010101010101);
 
#ifdef WORDS_BIGENDIAN
 
        /*
         * Fix byte order on big-endian machines before copying to the array.
         */
        isnull_8 = pg_bswap64(isnull_8);
#endif
        memcpy(isnull, &isnull_8, sizeof(uint64));
    }
}

References fb(), i, pg_bswap64(), SPREAD_BITS_MULTIPLIER_32, and UINT64CONST.

Referenced by slot_deform_heap_tuple().

store_att_byval()

static void store_att_byval ( void *  T, Datum  newdatum, int  attlen  )

inlinestatic

Definition at line 457 of file tupmacs.h.

{
    switch (attlen)
    {
        case sizeof(char):
            *(char *) T = DatumGetChar(newdatum);
            break;
        case sizeof(int16):
            *(int16 *) T = DatumGetInt16(newdatum);
            break;
        case sizeof(int32):
            *(int32 *) T = DatumGetInt32(newdatum);
            break;
        case sizeof(int64):
            *(int64 *) T = DatumGetInt64(newdatum);
            break;
        default:
            elog(ERROR, "unsupported byval length: %d", attlen);
    }
}

References attlen, DatumGetChar(), DatumGetInt16(), DatumGetInt32(), DatumGetInt64(), elog, ERROR, fb(), and T.

Referenced by ArrayCastAndSet(), brin_range_serialize(), datum_write(), fill_val(), and statext_mcv_serialize().

typalign_to_alignby()

static uint8 typalign_to_alignby ( char  typalign )

inlinestatic

Definition at line 302 of file tupmacs.h.

{
    uint8       alignby;
 
    switch (typalign)
    {
        case TYPALIGN_CHAR:
            alignby = sizeof(char);
            break;
        case TYPALIGN_SHORT:
            alignby = ALIGNOF_SHORT;
            break;
        case TYPALIGN_INT:
            alignby = ALIGNOF_INT;
            break;
        case TYPALIGN_DOUBLE:
            alignby = ALIGNOF_DOUBLE;
            break;
        default:
#ifndef FRONTEND
            elog(ERROR, "invalid typalign value: %c", typalign);
#else
            fprintf(stderr, "invalid typalign value: %c\n", typalign);
            exit(1);
#endif
            alignby = 0;
            break;
    }
    return alignby;
}

References elog, ERROR, fb(), fprintf, and typalign.

Referenced by array_create_iterator(), array_fill_internal(), array_in(), array_iter_setup(), array_map(), array_replace_internal(), array_seek(), array_set_element(), array_slice_size(), array_to_text_internal(), construct_md_array(), CopyArrayEls(), deconstruct_array(), EA_get_flat_size(), ExecEvalHashedScalarArrayOp(), ExecEvalScalarArrayOp(), get_text_array_contents(), multirange_size_estimate(), PLyList_FromArray_recurse(), populate_compact_attribute_internal(), ReadArrayBinary(), width_bucket_array_variable(), and write_multirange_data().