#include "access/htup.h"
#include "access/transam.h"
#include "access/tupdesc.h"
#include "access/tupmacs.h"
#include "storage/bufpage.h"
#include "varatt.h"

Include dependency graph for htup_details.h:

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

Go to the source code of this file.

Data Structures
struct	HeapTupleFields

struct	DatumTupleFields

struct	HeapTupleHeaderData

struct	MinimalTupleData

Macros
#define	MaxTupleAttributeNumber 1664 /* 8 * 208 */

#define	MaxHeapAttributeNumber 1600 /* 8 * 200 */

#define	FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2 2

#define	FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK 3

#define	FIELDNO_HEAPTUPLEHEADERDATA_HOFF 4

#define	FIELDNO_HEAPTUPLEHEADERDATA_BITS 5

#define	SizeofHeapTupleHeader offsetof(HeapTupleHeaderData, t_bits)

#define	HEAP_HASNULL 0x0001 /* has null attribute(s) */

#define	HEAP_HASVARWIDTH 0x0002 /* has variable-width attribute(s) */

#define	HEAP_HASEXTERNAL 0x0004 /* has external stored attribute(s) */

#define	HEAP_HASOID_OLD 0x0008 /* has an object-id field */

#define	HEAP_XMAX_KEYSHR_LOCK 0x0010 /* xmax is a key-shared locker */

#define	HEAP_COMBOCID 0x0020 /* t_cid is a combo CID */

#define	HEAP_XMAX_EXCL_LOCK 0x0040 /* xmax is exclusive locker */

#define	HEAP_XMAX_LOCK_ONLY 0x0080 /* xmax, if valid, is only a locker */

#define	HEAP_XMAX_SHR_LOCK (HEAP_XMAX_EXCL_LOCK \| HEAP_XMAX_KEYSHR_LOCK)

#define	HEAP_LOCK_MASK

#define	HEAP_XMIN_COMMITTED 0x0100 /* t_xmin committed */

#define	HEAP_XMIN_INVALID 0x0200 /* t_xmin invalid/aborted */

#define	HEAP_XMIN_FROZEN (HEAP_XMIN_COMMITTED\|HEAP_XMIN_INVALID)

#define	HEAP_XMAX_COMMITTED 0x0400 /* t_xmax committed */

#define	HEAP_XMAX_INVALID 0x0800 /* t_xmax invalid/aborted */

#define	HEAP_XMAX_IS_MULTI 0x1000 /* t_xmax is a MultiXactId */

#define	HEAP_UPDATED 0x2000 /* this is UPDATEd version of row */

#define	HEAP_MOVED_OFF

#define	HEAP_MOVED_IN

#define	HEAP_MOVED (HEAP_MOVED_OFF \| HEAP_MOVED_IN)

#define	HEAP_XACT_MASK 0xFFF0 /* visibility-related bits */

#define	HEAP_XMAX_BITS

#define	HEAP_NATTS_MASK 0x07FF /* 11 bits for number of attributes */

#define	HEAP_KEYS_UPDATED

#define	HEAP_HOT_UPDATED 0x4000 /* tuple was HOT-updated */

#define	HEAP_ONLY_TUPLE 0x8000 /* this is heap-only tuple */

#define	HEAP2_XACT_MASK 0xE000 /* visibility-related bits */

#define	HEAP_TUPLE_HAS_MATCH HEAP_ONLY_TUPLE /* tuple has a join match */

#define	HeapTupleHeaderGetNatts(tup) ((tup)->t_infomask2 & HEAP_NATTS_MASK)

#define	HeapTupleHeaderSetNatts(tup, natts)

#define	HeapTupleHeaderHasExternal(tup) (((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)

#define	MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))

#define	MinHeapTupleSize MAXALIGN(SizeofHeapTupleHeader)

#define	MaxHeapTuplesPerPage

#define	MaxAttrSize (10 * 1024 * 1024)

#define	MINIMAL_TUPLE_OFFSET ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) / MAXIMUM_ALIGNOF * MAXIMUM_ALIGNOF)

#define	MINIMAL_TUPLE_PADDING ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) % MAXIMUM_ALIGNOF)

#define	MINIMAL_TUPLE_DATA_OFFSET offsetof(MinimalTupleData, t_infomask2)

#define	SizeofMinimalTupleHeader offsetof(MinimalTupleData, t_bits)

Typedefs
typedef struct HeapTupleFields	HeapTupleFields

typedef struct DatumTupleFields	DatumTupleFields

Functions
static bool	HEAP_XMAX_IS_LOCKED_ONLY (uint16 infomask)

static bool	HEAP_LOCKED_UPGRADED (uint16 infomask)

static bool	HEAP_XMAX_IS_SHR_LOCKED (uint16 infomask)

static bool	HEAP_XMAX_IS_EXCL_LOCKED (uint16 infomask)

static bool	HEAP_XMAX_IS_KEYSHR_LOCKED (uint16 infomask)

static bool	HeapTupleHeaderXminFrozen (const HeapTupleHeaderData *tup)

static TransactionId	HeapTupleHeaderGetRawXmin (const HeapTupleHeaderData *tup)

static TransactionId	HeapTupleHeaderGetXmin (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetXmin (HeapTupleHeaderData *tup, TransactionId xid)

static bool	HeapTupleHeaderXminCommitted (const HeapTupleHeaderData *tup)

static bool	HeapTupleHeaderXminInvalid (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetXminFrozen (HeapTupleHeaderData *tup)

static TransactionId	HeapTupleHeaderGetRawXmax (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetXmax (HeapTupleHeaderData *tup, TransactionId xid)

static TransactionId	HeapTupleHeaderGetUpdateXid (const HeapTupleHeaderData *tup)

static CommandId	HeapTupleHeaderGetRawCommandId (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetCmin (HeapTupleHeaderData *tup, CommandId cid)

static void	HeapTupleHeaderSetCmax (HeapTupleHeaderData *tup, CommandId cid, bool iscombo)

static TransactionId	HeapTupleHeaderGetXvac (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetXvac (HeapTupleHeaderData *tup, TransactionId xid)

	StaticAssertDecl (MaxOffsetNumber< SpecTokenOffsetNumber, "invalid speculative token constant")

static bool	HeapTupleHeaderIsSpeculative (const HeapTupleHeaderData *tup)

static BlockNumber	HeapTupleHeaderGetSpeculativeToken (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetSpeculativeToken (HeapTupleHeaderData *tup, BlockNumber token)

static bool	HeapTupleHeaderIndicatesMovedPartitions (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetMovedPartitions (HeapTupleHeaderData *tup)

static uint32	HeapTupleHeaderGetDatumLength (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetDatumLength (HeapTupleHeaderData *tup, uint32 len)

static Oid	HeapTupleHeaderGetTypeId (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetTypeId (HeapTupleHeaderData *tup, Oid datum_typeid)

static int32	HeapTupleHeaderGetTypMod (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetTypMod (HeapTupleHeaderData *tup, int32 typmod)

static bool	HeapTupleHeaderIsHotUpdated (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetHotUpdated (HeapTupleHeaderData *tup)

static void	HeapTupleHeaderClearHotUpdated (HeapTupleHeaderData *tup)

static bool	HeapTupleHeaderIsHeapOnly (const HeapTupleHeaderData *tup)

static void	HeapTupleHeaderSetHeapOnly (HeapTupleHeaderData *tup)

static void	HeapTupleHeaderClearHeapOnly (HeapTupleHeaderData *tup)

static int	BITMAPLEN (int NATTS)

static bool	HeapTupleHeaderHasMatch (const MinimalTupleData *tup)

static void	HeapTupleHeaderSetMatch (MinimalTupleData *tup)

static void	HeapTupleHeaderClearMatch (MinimalTupleData *tup)

static void *	GETSTRUCT (const HeapTupleData *tuple)

static bool	HeapTupleHasNulls (const HeapTupleData *tuple)

static bool	HeapTupleNoNulls (const HeapTupleData *tuple)

static bool	HeapTupleHasVarWidth (const HeapTupleData *tuple)

static bool	HeapTupleAllFixed (const HeapTupleData *tuple)

static bool	HeapTupleHasExternal (const HeapTupleData *tuple)

static bool	HeapTupleIsHotUpdated (const HeapTupleData *tuple)

static void	HeapTupleSetHotUpdated (const HeapTupleData *tuple)

static void	HeapTupleClearHotUpdated (const HeapTupleData *tuple)

static bool	HeapTupleIsHeapOnly (const HeapTupleData *tuple)

static void	HeapTupleSetHeapOnly (const HeapTupleData *tuple)

static void	HeapTupleClearHeapOnly (const HeapTupleData *tuple)

Size	heap_compute_data_size (TupleDesc tupleDesc, const Datum values, const bool isnull)

void	heap_fill_tuple (TupleDesc tupleDesc, const Datum values, const bool isnull, char data, Size data_size, uint16 infomask, uint8 *bit)

bool	heap_attisnull (HeapTuple tup, int attnum, TupleDesc tupleDesc)

Datum	nocachegetattr (HeapTuple tup, int attnum, TupleDesc tupleDesc)

Datum	heap_getsysattr (HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

Datum	getmissingattr (TupleDesc tupleDesc, int attnum, bool *isnull)

HeapTuple	heap_copytuple (HeapTuple tuple)

void	heap_copytuple_with_tuple (HeapTuple src, HeapTuple dest)

Datum	heap_copy_tuple_as_datum (HeapTuple tuple, TupleDesc tupleDesc)

HeapTuple	heap_form_tuple (TupleDesc tupleDescriptor, const Datum values, const bool isnull)

HeapTuple	heap_modify_tuple (HeapTuple tuple, TupleDesc tupleDesc, const Datum replValues, const bool replIsnull, const bool *doReplace)

HeapTuple	heap_modify_tuple_by_cols (HeapTuple tuple, TupleDesc tupleDesc, int nCols, const int replCols, const Datum replValues, const bool *replIsnull)

void	heap_deform_tuple (HeapTuple tuple, TupleDesc tupleDesc, Datum values, bool isnull)

void	heap_freetuple (HeapTuple htup)

MinimalTuple	heap_form_minimal_tuple (TupleDesc tupleDescriptor, const Datum values, const bool isnull, Size extra)

void	heap_free_minimal_tuple (MinimalTuple mtup)

MinimalTuple	heap_copy_minimal_tuple (MinimalTuple mtup, Size extra)

HeapTuple	heap_tuple_from_minimal_tuple (MinimalTuple mtup)

MinimalTuple	minimal_tuple_from_heap_tuple (HeapTuple htup, Size extra)

size_t	varsize_any (void *p)

HeapTuple	heap_expand_tuple (HeapTuple sourceTuple, TupleDesc tupleDesc)

MinimalTuple	minimal_expand_tuple (HeapTuple sourceTuple, TupleDesc tupleDesc)

static Datum	fastgetattr (HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

static Datum	heap_getattr (HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)

Macro Definition Documentation

◆ FIELDNO_HEAPTUPLEHEADERDATA_BITS

#define FIELDNO_HEAPTUPLEHEADERDATA_BITS 5

Definition at line 177 of file htup_details.h.

◆ FIELDNO_HEAPTUPLEHEADERDATA_HOFF

#define FIELDNO_HEAPTUPLEHEADERDATA_HOFF 4

Definition at line 172 of file htup_details.h.

◆ FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK

#define FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK 3

Definition at line 169 of file htup_details.h.

◆ FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2

#define FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2 2

Definition at line 166 of file htup_details.h.

◆ HEAP2_XACT_MASK

#define HEAP2_XACT_MASK 0xE000 /* visibility-related bits */

Definition at line 293 of file htup_details.h.

◆ HEAP_COMBOCID

#define HEAP_COMBOCID 0x0020 /* t_cid is a combo CID */

Definition at line 195 of file htup_details.h.

◆ HEAP_HASEXTERNAL

#define HEAP_HASEXTERNAL 0x0004 /* has external stored attribute(s) */

Definition at line 192 of file htup_details.h.

◆ HEAP_HASNULL

#define HEAP_HASNULL 0x0001 /* has null attribute(s) */

Definition at line 190 of file htup_details.h.

◆ HEAP_HASOID_OLD

#define HEAP_HASOID_OLD 0x0008 /* has an object-id field */

Definition at line 193 of file htup_details.h.

◆ HEAP_HASVARWIDTH

#define HEAP_HASVARWIDTH 0x0002 /* has variable-width attribute(s) */

Definition at line 191 of file htup_details.h.

◆ HEAP_HOT_UPDATED

#define HEAP_HOT_UPDATED 0x4000 /* tuple was HOT-updated */

Definition at line 290 of file htup_details.h.

◆ HEAP_KEYS_UPDATED

#define HEAP_KEYS_UPDATED

Value:

0x2000 /* tuple was updated and key cols

* modified, or tuple deleted */

Definition at line 289 of file htup_details.h.

:
*/
#define HEAP_NATTS_MASK         0x07FF  /* 11 bits for number of attributes */
/* bits 0x1800 are available */
#define HEAP_KEYS_UPDATED       0x2000  /* tuple was updated and key cols
                                         * modified, or tuple deleted */
#define HEAP_HOT_UPDATED        0x4000  /* tuple was HOT-updated */
#define HEAP_ONLY_TUPLE         0x8000  /* this is heap-only tuple */
 
#define HEAP2_XACT_MASK         0xE000  /* visibility-related bits */
 
/*
 * HEAP_TUPLE_HAS_MATCH is a temporary flag used during hash joins.  It is
 * only used in tuples that are in the hash table, and those don't need
 * any visibility information, so we can overlay it on a visibility flag
 * instead of using up a dedicated bit.
 */
#define HEAP_TUPLE_HAS_MATCH    HEAP_ONLY_TUPLE /* tuple has a join match */
 
/*
 * HeapTupleHeader accessor functions
 */
 
static bool HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup);
 
/*
 * HeapTupleHeaderGetRawXmin returns the "raw" xmin field, which is the xid
 * originally used to insert the tuple.  However, the tuple might actually
 * be frozen (via HeapTupleHeaderSetXminFrozen) in which case the tuple's xmin
 * is visible to every snapshot.  Prior to PostgreSQL 9.4, we actually changed
 * the xmin to FrozenTransactionId, and that value may still be encountered
 * on disk.
 */
static inline TransactionId
HeapTupleHeaderGetRawXmin(const HeapTupleHeaderData *tup)
{
    return tup->t_choice.t_heap.t_xmin;
}
 
static inline TransactionId
HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
{
    return HeapTupleHeaderXminFrozen(tup) ?
        FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup);
}
 
static inline void
HeapTupleHeaderSetXmin(HeapTupleHeaderData *tup, TransactionId xid)
{
    tup->t_choice.t_heap.t_xmin = xid;
}
 
static inline bool
HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
{
    return (tup->t_infomask & HEAP_XMIN_COMMITTED) != 0;
}
 
static inline bool
HeapTupleHeaderXminInvalid(const HeapTupleHeaderData *tup) \
{
    return (tup->t_infomask & (HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID)) ==
        HEAP_XMIN_INVALID;
}
 
static inline bool
HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup)
{
    return (tup->t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN;
}
 
static inline void
HeapTupleHeaderSetXminFrozen(HeapTupleHeaderData *tup)
{
    Assert(!HeapTupleHeaderXminInvalid(tup));
    tup->t_infomask |= HEAP_XMIN_FROZEN;
}
 
static inline TransactionId
HeapTupleHeaderGetRawXmax(const HeapTupleHeaderData *tup)
{
    return tup->t_choice.t_heap.t_xmax;
}
 
static inline void
HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
{
    tup->t_choice.t_heap.t_xmax = xid;
}
 
#ifndef FRONTEND
/*
 * HeapTupleHeaderGetRawXmax gets you the raw Xmax field.  To find out the Xid
 * that updated a tuple, you might need to resolve the MultiXactId if certain
 * bits are set.  HeapTupleHeaderGetUpdateXid checks those bits and takes care
 * to resolve the MultiXactId if necessary.  This might involve multixact I/O,
 * so it should only be used if absolutely necessary.
 */
static inline TransactionId
HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
{
    if (!((tup)->t_infomask & HEAP_XMAX_INVALID) &&
        ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) &&
        !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY))
        return HeapTupleGetUpdateXid(tup);
    else
        return HeapTupleHeaderGetRawXmax(tup);
}
#endif                          /* FRONTEND */
 
/*
 * HeapTupleHeaderGetRawCommandId will give you what's in the header whether
 * it is useful or not.  Most code should use HeapTupleHeaderGetCmin or
 * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
 * get a legitimate result, ie you are in the originating transaction!
 */
static inline CommandId
HeapTupleHeaderGetRawCommandId(const HeapTupleHeaderData *tup)
{
    return tup->t_choice.t_heap.t_field3.t_cid;
}
 
/* SetCmin is reasonably simple since we never need a combo CID */
static inline void
HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
{
    Assert(!(tup->t_infomask & HEAP_MOVED));
    tup->t_choice.t_heap.t_field3.t_cid = cid;
    tup->t_infomask &= ~HEAP_COMBOCID;
}
 
/* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
static inline void
HeapTupleHeaderSetCmax(HeapTupleHeaderData *tup, CommandId cid, bool iscombo)
{
    Assert(!((tup)->t_infomask & HEAP_MOVED));
    tup->t_choice.t_heap.t_field3.t_cid = cid;
    if (iscombo)
        tup->t_infomask |= HEAP_COMBOCID;
    else
        tup->t_infomask &= ~HEAP_COMBOCID;
}
 
static inline TransactionId
HeapTupleHeaderGetXvac(const HeapTupleHeaderData *tup)
{
    if (tup->t_infomask & HEAP_MOVED)
        return tup->t_choice.t_heap.t_field3.t_xvac;
    else
        return InvalidTransactionId;
}
 
static inline void
HeapTupleHeaderSetXvac(HeapTupleHeaderData *tup, TransactionId xid)
{
    Assert(tup->t_infomask & HEAP_MOVED);
    tup->t_choice.t_heap.t_field3.t_xvac = xid;
}
 
StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
                 "invalid speculative token constant");
 
static inline bool
HeapTupleHeaderIsSpeculative(const HeapTupleHeaderData *tup)
{
    return ItemPointerGetOffsetNumberNoCheck(&tup->t_ctid) == SpecTokenOffsetNumber;
}
 
static inline BlockNumber
HeapTupleHeaderGetSpeculativeToken(const HeapTupleHeaderData *tup)
{
    Assert(HeapTupleHeaderIsSpeculative(tup));
    return ItemPointerGetBlockNumber(&tup->t_ctid);
}
 
static inline void
HeapTupleHeaderSetSpeculativeToken(HeapTupleHeaderData *tup, BlockNumber token)
{
    ItemPointerSet(&tup->t_ctid, token, SpecTokenOffsetNumber);
}
 
static inline bool
HeapTupleHeaderIndicatesMovedPartitions(const HeapTupleHeaderData *tup)
{
    return ItemPointerIndicatesMovedPartitions(&tup->t_ctid);
}
 
static inline void
HeapTupleHeaderSetMovedPartitions(HeapTupleHeaderData *tup)
{
    ItemPointerSetMovedPartitions(&tup->t_ctid);
}
 
static inline uint32
HeapTupleHeaderGetDatumLength(const HeapTupleHeaderData *tup)
{
    return VARSIZE(tup);
}
 
static inline void
HeapTupleHeaderSetDatumLength(HeapTupleHeaderData *tup, uint32 len)
{
    SET_VARSIZE(tup, len);
}
 
static inline Oid
HeapTupleHeaderGetTypeId(const HeapTupleHeaderData *tup)
{
    return tup->t_choice.t_datum.datum_typeid;
}
 
static inline void
HeapTupleHeaderSetTypeId(HeapTupleHeaderData *tup, Oid datum_typeid)
{
    tup->t_choice.t_datum.datum_typeid = datum_typeid;
}
 
static inline int32
HeapTupleHeaderGetTypMod(const HeapTupleHeaderData *tup)
{
    return tup->t_choice.t_datum.datum_typmod;
}
 
static inline void
HeapTupleHeaderSetTypMod(HeapTupleHeaderData *tup, int32 typmod)
{
    tup->t_choice.t_datum.datum_typmod = typmod;
}
 
/*
 * Note that we stop considering a tuple HOT-updated as soon as it is known
 * aborted or the would-be updating transaction is known aborted.  For best
 * efficiency, check tuple visibility before using this function, so that the
 * INVALID bits will be as up to date as possible.
 */
static inline bool
HeapTupleHeaderIsHotUpdated(const HeapTupleHeaderData *tup)
{
    return
        (tup->t_infomask2 & HEAP_HOT_UPDATED) != 0 &&
        (tup->t_infomask & HEAP_XMAX_INVALID) == 0 &&
        !HeapTupleHeaderXminInvalid(tup);
}
 
static inline void
HeapTupleHeaderSetHotUpdated(HeapTupleHeaderData *tup)
{
    tup->t_infomask2 |= HEAP_HOT_UPDATED;
}
 
static inline void
HeapTupleHeaderClearHotUpdated(HeapTupleHeaderData *tup)
{
    tup->t_infomask2 &= ~HEAP_HOT_UPDATED;
}
 
static inline bool
HeapTupleHeaderIsHeapOnly(const HeapTupleHeaderData *tup) \
{
    return (tup->t_infomask2 & HEAP_ONLY_TUPLE) != 0;
}
 
static inline void
HeapTupleHeaderSetHeapOnly(HeapTupleHeaderData *tup)
{
    tup->t_infomask2 |= HEAP_ONLY_TUPLE;
}
 
static inline void
HeapTupleHeaderClearHeapOnly(HeapTupleHeaderData *tup)
{
    tup->t_infomask2 &= ~HEAP_ONLY_TUPLE;
}
 
/*
 * These are used with both HeapTuple and MinimalTuple, so they must be
 * macros.
 */
 
#define HeapTupleHeaderGetNatts(tup) \
    ((tup)->t_infomask2 & HEAP_NATTS_MASK)
 
#define HeapTupleHeaderSetNatts(tup, natts) \
( \
    (tup)->t_infomask2 = ((tup)->t_infomask2 & ~HEAP_NATTS_MASK) | (natts) \
)
 
#define HeapTupleHeaderHasExternal(tup) \
        (((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)
 
 
/*
 * BITMAPLEN(NATTS) -
 *      Computes size of null bitmap given number of data columns.
 */
static inline int
BITMAPLEN(int NATTS)
{
    return (NATTS + 7) / 8;
}
 
/*
 * MaxHeapTupleSize is the maximum allowed size of a heap tuple, including
 * header and MAXALIGN alignment padding.  Basically it's BLCKSZ minus the
 * other stuff that has to be on a disk page.  Since heap pages use no
 * "special space", there's no deduction for that.
 *
 * NOTE: we allow for the ItemId that must point to the tuple, ensuring that
 * an otherwise-empty page can indeed hold a tuple of this size.  Because
 * ItemIds and tuples have different alignment requirements, don't assume that
 * you can, say, fit 2 tuples of size MaxHeapTupleSize/2 on the same page.
 */
#define MaxHeapTupleSize  (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
#define MinHeapTupleSize  MAXALIGN(SizeofHeapTupleHeader)
 
/*
 * MaxHeapTuplesPerPage is an upper bound on the number of tuples that can
 * fit on one heap page.  (Note that indexes could have more, because they
 * use a smaller tuple header.)  We arrive at the divisor because each tuple
 * must be maxaligned, and it must have an associated line pointer.
 *
 * Note: with HOT, there could theoretically be more line pointers (not actual
 * tuples) than this on a heap page.  However we constrain the number of line
 * pointers to this anyway, to avoid excessive line-pointer bloat and not
 * require increases in the size of work arrays.
 */
#define MaxHeapTuplesPerPage    \
    ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
            (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))))
 
/*
 * MaxAttrSize is a somewhat arbitrary upper limit on the declared size of
 * data fields of char(n) and similar types.  It need not have anything
 * directly to do with the *actual* upper limit of varlena values, which
 * is currently 1Gb (see TOAST structures in varatt.h).  I've set it
 * at 10Mb which seems like a reasonable number --- tgl 8/6/00.
 */
#define MaxAttrSize     (10 * 1024 * 1024)
 
 
/*
 * MinimalTuple is an alternative representation that is used for transient
 * tuples inside the executor, in places where transaction status information
 * is not required, the tuple rowtype is known, and shaving off a few bytes
 * is worthwhile because we need to store many tuples.  The representation
 * is chosen so that tuple access routines can work with either full or
 * minimal tuples via a HeapTupleData pointer structure.  The access routines
 * see no difference, except that they must not access the transaction status
 * or t_ctid fields because those aren't there.
 *
 * For the most part, MinimalTuples should be accessed via TupleTableSlot
 * routines.  These routines will prevent access to the "system columns"
 * and thereby prevent accidental use of the nonexistent fields.
 *
 * MinimalTupleData contains a length word, some padding, and fields matching
 * HeapTupleHeaderData beginning with t_infomask2. The padding is chosen so
 * that offsetof(t_infomask2) is the same modulo MAXIMUM_ALIGNOF in both
 * structs.   This makes data alignment rules equivalent in both cases.
 *
 * When a minimal tuple is accessed via a HeapTupleData pointer, t_data is
 * set to point MINIMAL_TUPLE_OFFSET bytes before the actual start of the
 * minimal tuple --- that is, where a full tuple matching the minimal tuple's
 * data would start.  This trick is what makes the structs seem equivalent.
 *
 * Note that t_hoff is computed the same as in a full tuple, hence it includes
 * the MINIMAL_TUPLE_OFFSET distance.  t_len does not include that, however.
 *
 * MINIMAL_TUPLE_DATA_OFFSET is the offset to the first useful (non-pad) data
 * other than the length word.  tuplesort.c and tuplestore.c use this to avoid
 * writing the padding to disk.
 */
#define MINIMAL_TUPLE_OFFSET \
    ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) / MAXIMUM_ALIGNOF * MAXIMUM_ALIGNOF)
#define MINIMAL_TUPLE_PADDING \
    ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) % MAXIMUM_ALIGNOF)
#define MINIMAL_TUPLE_DATA_OFFSET \
    offsetof(MinimalTupleData, t_infomask2)
 
struct MinimalTupleData
{
    uint32      t_len;          /* actual length of minimal tuple */
 
    char        mt_padding[MINIMAL_TUPLE_PADDING];
 
    /* Fields below here must match HeapTupleHeaderData! */
 
    uint16      t_infomask2;    /* number of attributes + various flags */
 
    uint16      t_infomask;     /* various flag bits, see below */
 
    uint8       t_hoff;         /* sizeof header incl. bitmap, padding */
 
    /* ^ - 23 bytes - ^ */
 
    uint8       t_bits[FLEXIBLE_ARRAY_MEMBER];  /* bitmap of NULLs */
 
    /* MORE DATA FOLLOWS AT END OF STRUCT */
};
 
/* typedef appears in htup.h */
 
#define SizeofMinimalTupleHeader offsetof(MinimalTupleData, t_bits)
 
/*
 * MinimalTuple accessor functions
 */
 
static inline bool
HeapTupleHeaderHasMatch(const MinimalTupleData *tup)
{
    return (tup->t_infomask2 & HEAP_TUPLE_HAS_MATCH) != 0;
}
 
static inline void
HeapTupleHeaderSetMatch(MinimalTupleData *tup)
{
    tup->t_infomask2 |= HEAP_TUPLE_HAS_MATCH;
}
 
static inline void
HeapTupleHeaderClearMatch(MinimalTupleData *tup)
{
    tup->t_infomask2 &= ~HEAP_TUPLE_HAS_MATCH;
}
 
 
/*
 * GETSTRUCT - given a HeapTuple pointer, return address of the user data
 */
static inline void *
GETSTRUCT(const HeapTupleData *tuple)
{
    return ((char *) (tuple->t_data) + tuple->t_data->t_hoff);
}
 
/*
 * Accessor functions to be used with HeapTuple pointers.
 */
 
static inline bool
HeapTupleHasNulls(const HeapTupleData *tuple)
{
    return (tuple->t_data->t_infomask & HEAP_HASNULL) != 0;
}
 
static inline bool
HeapTupleNoNulls(const HeapTupleData *tuple)
{
    return !HeapTupleHasNulls(tuple);
}
 
static inline bool
HeapTupleHasVarWidth(const HeapTupleData *tuple)
{
    return (tuple->t_data->t_infomask & HEAP_HASVARWIDTH) != 0;
}
 
static inline bool
HeapTupleAllFixed(const HeapTupleData *tuple)
{
    return !HeapTupleHasVarWidth(tuple);
}
 
static inline bool
HeapTupleHasExternal(const HeapTupleData *tuple)
{
    return (tuple->t_data->t_infomask & HEAP_HASEXTERNAL) != 0;
}
 
static inline bool
HeapTupleIsHotUpdated(const HeapTupleData *tuple)
{
    return HeapTupleHeaderIsHotUpdated(tuple->t_data);
}
 
static inline void
HeapTupleSetHotUpdated(const HeapTupleData *tuple)
{
    HeapTupleHeaderSetHotUpdated(tuple->t_data);
}
 
static inline void
HeapTupleClearHotUpdated(const HeapTupleData *tuple)
{
    HeapTupleHeaderClearHotUpdated(tuple->t_data);
}
 
static inline bool
HeapTupleIsHeapOnly(const HeapTupleData *tuple)
{
    return HeapTupleHeaderIsHeapOnly(tuple->t_data);
}
 
static inline void
HeapTupleSetHeapOnly(const HeapTupleData *tuple)
{
    HeapTupleHeaderSetHeapOnly(tuple->t_data);
}
 
static inline void
HeapTupleClearHeapOnly(const HeapTupleData *tuple)
{
    HeapTupleHeaderClearHeapOnly(tuple->t_data);
}
 
/* prototypes for functions in common/heaptuple.c */
extern Size heap_compute_data_size(TupleDesc tupleDesc,
                                   const Datum *values, const bool *isnull);
extern void heap_fill_tuple(TupleDesc tupleDesc,
                            const Datum *values, const bool *isnull,
                            char *data, Size data_size,
                            uint16 *infomask, uint8 *bit);
extern bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc);
extern Datum nocachegetattr(HeapTuple tup, int attnum,
                            TupleDesc tupleDesc);
extern Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
                             bool *isnull);
extern Datum getmissingattr(TupleDesc tupleDesc,
                            int attnum, bool *isnull);
extern HeapTuple heap_copytuple(HeapTuple tuple);
extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest);
extern Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc);
extern HeapTuple heap_form_tuple(TupleDesc tupleDescriptor,
                                 const Datum *values, const bool *isnull);
extern HeapTuple heap_modify_tuple(HeapTuple tuple,
                                   TupleDesc tupleDesc,
                                   const Datum *replValues,
                                   const bool *replIsnull,
                                   const bool *doReplace);
extern HeapTuple heap_modify_tuple_by_cols(HeapTuple tuple,
                                           TupleDesc tupleDesc,
                                           int nCols,
                                           const int *replCols,
                                           const Datum *replValues,
                                           const bool *replIsnull);
extern void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
                              Datum *values, bool *isnull);
extern void heap_freetuple(HeapTuple htup);
extern MinimalTuple heap_form_minimal_tuple(TupleDesc tupleDescriptor,
                                            const Datum *values, const bool *isnull,
                                            Size extra);
extern void heap_free_minimal_tuple(MinimalTuple mtup);
extern MinimalTuple heap_copy_minimal_tuple(MinimalTuple mtup, Size extra);
extern HeapTuple heap_tuple_from_minimal_tuple(MinimalTuple mtup);
extern MinimalTuple minimal_tuple_from_heap_tuple(HeapTuple htup, Size extra);
extern size_t varsize_any(void *p);
extern HeapTuple heap_expand_tuple(HeapTuple sourceTuple, TupleDesc tupleDesc);
extern MinimalTuple minimal_expand_tuple(HeapTuple sourceTuple, TupleDesc tupleDesc);
 
#ifndef FRONTEND
/*
 *  fastgetattr
 *      Fetch a user attribute's value as a Datum (might be either a
 *      value, or a pointer into the data area of the tuple).
 *
 *      This must not be used when a system attribute might be requested.
 *      Furthermore, the passed attnum MUST be valid.  Use heap_getattr()
 *      instead, if in doubt.
 *
 *      This gets called many times, so we macro the cacheable and NULL
 *      lookups, and call nocachegetattr() for the rest.
 */
static inline Datum
fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
{
    Assert(attnum > 0);
 
    *isnull = false;
    if (HeapTupleNoNulls(tup))
    {
        CompactAttribute *att;
 
        att = TupleDescCompactAttr(tupleDesc, attnum - 1);
        if (att->attcacheoff >= 0)
            return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
                            att->attcacheoff);
        else
            return nocachegetattr(tup, attnum, tupleDesc);
    }
    else
    {
        if (att_isnull(attnum - 1, tup->t_data->t_bits))
        {
            *isnull = true;
            return (Datum) 0;
        }
        else
            return nocachegetattr(tup, attnum, tupleDesc);
    }
}
 
/*
 *  heap_getattr
 *      Extract an attribute of a heap tuple and return it as a Datum.
 *      This works for either system or user attributes.  The given attnum
 *      is properly range-checked.
 *
 *      If the field in question has a NULL value, we return a zero Datum
 *      and set *isnull == true.  Otherwise, we set *isnull == false.
 *
 *      <tup> is the pointer to the heap tuple.  <attnum> is the attribute
 *      number of the column (field) caller wants.  <tupleDesc> is a
 *      pointer to the structure describing the row and all its fields.
 *
 */
static inline Datum
heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
{
    if (attnum > 0)
    {
        if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
            return getmissingattr(tupleDesc, attnum, isnull);
        else
            return fastgetattr(tup, attnum, tupleDesc, isnull);
    }
    else
        return heap_getsysattr(tup, attnum, tupleDesc, isnull);
}
#endif                          /* FRONTEND */
 
#endif                          /* HTUP_DETAILS_H */
 

◆ HEAP_LOCK_MASK

#define HEAP_LOCK_MASK

Value:

(HEAP_XMAX_SHR_LOCK | HEAP_XMAX_EXCL_LOCK | \

HEAP_XMAX_KEYSHR_LOCK)

HEAP_XMAX_SHR_LOCK

#define HEAP_XMAX_SHR_LOCK

Definition htup_details.h:200

HEAP_XMAX_EXCL_LOCK

#define HEAP_XMAX_EXCL_LOCK

Definition htup_details.h:196

HEAP_XMAX_KEYSHR_LOCK

#define HEAP_XMAX_KEYSHR_LOCK

Definition htup_details.h:194

Definition at line 202 of file htup_details.h.

◆ HEAP_MOVED

#define HEAP_MOVED (HEAP_MOVED_OFF | HEAP_MOVED_IN)

Definition at line 213 of file htup_details.h.

◆ HEAP_MOVED_IN

#define HEAP_MOVED_IN

Value:

                                         0x8000 /* moved from another place by pre-9.0
                                         * VACUUM FULL; kept for binary
                                         * upgrade support */

Definition at line 212 of file htup_details.h.

◆ HEAP_MOVED_OFF

#define HEAP_MOVED_OFF

Value:

                                         0x4000 /* moved to another place by pre-9.0
                                         * VACUUM FULL; kept for binary
                                         * upgrade support */

Definition at line 211 of file htup_details.h.

◆ HEAP_NATTS_MASK

#define HEAP_NATTS_MASK 0x07FF /* 11 bits for number of attributes */

Definition at line 287 of file htup_details.h.

◆ HEAP_ONLY_TUPLE

#define HEAP_ONLY_TUPLE 0x8000 /* this is heap-only tuple */

Definition at line 291 of file htup_details.h.

◆ HEAP_TUPLE_HAS_MATCH

#define HEAP_TUPLE_HAS_MATCH HEAP_ONLY_TUPLE /* tuple has a join match */

Definition at line 301 of file htup_details.h.

◆ HEAP_UPDATED

#define HEAP_UPDATED 0x2000 /* this is UPDATEd version of row */

Definition at line 210 of file htup_details.h.

◆ HEAP_XACT_MASK

#define HEAP_XACT_MASK 0xFFF0 /* visibility-related bits */

Definition at line 215 of file htup_details.h.

◆ HEAP_XMAX_BITS

#define HEAP_XMAX_BITS

Value:

(HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID | \

HEAP_XMAX_IS_MULTI | HEAP_LOCK_MASK | HEAP_XMAX_LOCK_ONLY)

HEAP_LOCK_MASK

#define HEAP_LOCK_MASK

Definition htup_details.h:202

HEAP_XMAX_COMMITTED

#define HEAP_XMAX_COMMITTED

Definition htup_details.h:207

Definition at line 281 of file htup_details.h.

◆ HEAP_XMAX_COMMITTED

#define HEAP_XMAX_COMMITTED 0x0400 /* t_xmax committed */

Definition at line 207 of file htup_details.h.

◆ HEAP_XMAX_EXCL_LOCK

#define HEAP_XMAX_EXCL_LOCK 0x0040 /* xmax is exclusive locker */

Definition at line 196 of file htup_details.h.

◆ HEAP_XMAX_INVALID

#define HEAP_XMAX_INVALID 0x0800 /* t_xmax invalid/aborted */

Definition at line 208 of file htup_details.h.

◆ HEAP_XMAX_IS_MULTI

#define HEAP_XMAX_IS_MULTI 0x1000 /* t_xmax is a MultiXactId */

Definition at line 209 of file htup_details.h.

◆ HEAP_XMAX_KEYSHR_LOCK

#define HEAP_XMAX_KEYSHR_LOCK 0x0010 /* xmax is a key-shared locker */

Definition at line 194 of file htup_details.h.

◆ HEAP_XMAX_LOCK_ONLY

#define HEAP_XMAX_LOCK_ONLY 0x0080 /* xmax, if valid, is only a locker */

Definition at line 197 of file htup_details.h.

◆ HEAP_XMAX_SHR_LOCK

#define HEAP_XMAX_SHR_LOCK (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)

Definition at line 200 of file htup_details.h.

◆ HEAP_XMIN_COMMITTED

#define HEAP_XMIN_COMMITTED 0x0100 /* t_xmin committed */

Definition at line 204 of file htup_details.h.

◆ HEAP_XMIN_FROZEN

#define HEAP_XMIN_FROZEN (HEAP_XMIN_COMMITTED|HEAP_XMIN_INVALID)

Definition at line 206 of file htup_details.h.

◆ HEAP_XMIN_INVALID

#define HEAP_XMIN_INVALID 0x0200 /* t_xmin invalid/aborted */

Definition at line 205 of file htup_details.h.

◆ HeapTupleHeaderGetNatts

#define HeapTupleHeaderGetNatts ( tup ) ((tup)->t_infomask2 & HEAP_NATTS_MASK)

Definition at line 563 of file htup_details.h.

◆ HeapTupleHeaderHasExternal

#define HeapTupleHeaderHasExternal ( tup ) (((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)

Definition at line 571 of file htup_details.h.

◆ HeapTupleHeaderSetNatts

#define HeapTupleHeaderSetNatts	(	tup,
		natts
	)

Value:

( \
    (tup)->t_infomask2 = ((tup)->t_infomask2 & ~HEAP_NATTS_MASK) | (natts) \
)

Definition at line 566 of file htup_details.h.

◆ MaxAttrSize

#define MaxAttrSize (10 * 1024 * 1024)

Definition at line 621 of file htup_details.h.

◆ MaxHeapAttributeNumber

#define MaxHeapAttributeNumber 1600 /* 8 * 200 */

Definition at line 48 of file htup_details.h.

◆ MaxHeapTupleSize

#define MaxHeapTupleSize (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))

Definition at line 596 of file htup_details.h.

◆ MaxHeapTuplesPerPage

#define MaxHeapTuplesPerPage

Value:

((int) ((BLCKSZ - SizeOfPageHeaderData) / \

(MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))))

SizeOfPageHeaderData

#define SizeOfPageHeaderData

Definition bufpage.h:241

MAXALIGN

#define MAXALIGN(LEN)

Definition c.h:896

SizeofHeapTupleHeader

#define SizeofHeapTupleHeader

Definition htup_details.h:185

ItemIdData

Definition itemid.h:26

Definition at line 610 of file htup_details.h.

       : with HOT, there could theoretically be more line pointers (not actual
 * tuples) than this on a heap page.  However we constrain the number of line
 * pointers to this anyway, to avoid excessive line-pointer bloat and not

◆ MaxTupleAttributeNumber

#define MaxTupleAttributeNumber 1664 /* 8 * 208 */

Definition at line 34 of file htup_details.h.

◆ MinHeapTupleSize

#define MinHeapTupleSize MAXALIGN(SizeofHeapTupleHeader)

Definition at line 597 of file htup_details.h.

◆ MINIMAL_TUPLE_DATA_OFFSET

#define MINIMAL_TUPLE_DATA_OFFSET offsetof(MinimalTupleData, t_infomask2)

Definition at line 659 of file htup_details.h.

◆ MINIMAL_TUPLE_OFFSET

#define MINIMAL_TUPLE_OFFSET ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) / MAXIMUM_ALIGNOF * MAXIMUM_ALIGNOF)

Definition at line 655 of file htup_details.h.

◆ MINIMAL_TUPLE_PADDING

#define MINIMAL_TUPLE_PADDING ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) % MAXIMUM_ALIGNOF)

Definition at line 657 of file htup_details.h.

◆ SizeofHeapTupleHeader

#define SizeofHeapTupleHeader offsetof(HeapTupleHeaderData, t_bits)

Definition at line 185 of file htup_details.h.

◆ SizeofMinimalTupleHeader

#define SizeofMinimalTupleHeader offsetof(MinimalTupleData, t_bits)

Definition at line 685 of file htup_details.h.

Typedef Documentation

◆ DatumTupleFields

typedef struct DatumTupleFields DatumTupleFields

◆ HeapTupleFields

typedef struct HeapTupleFields HeapTupleFields

Function Documentation

◆ BITMAPLEN()

static int BITMAPLEN ( int NATTS )

inlinestatic

Definition at line 580 of file htup_details.h.

References fb().

Referenced by brin_form_placeholder_tuple(), brin_form_tuple(), check_tuple_header(), ER_get_flat_size(), expand_tuple(), heap_form_minimal_tuple(), heap_form_tuple(), heap_page_items(), heap_toast_insert_or_update(), heapam_relation_needs_toast_table(), slot_deform_heap_tuple(), toast_flatten_tuple_to_datum(), and tuple_data_split().

◆ fastgetattr()

static Datum fastgetattr	(	HeapTuple	tup,
		int	attnum,
		TupleDesc	tupleDesc,
		bool *	isnull
	)

inlinestatic

Definition at line 847 of file htup_details.h.

{
    Assert(attnum > 0);
 
    *isnull = false;
    if (HeapTupleNoNulls(tup))
    {
        CompactAttribute *att;
 
        att = TupleDescCompactAttr(tupleDesc, attnum - 1);
        if (att->attcacheoff >= 0)
            return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
                            att->attcacheoff);
        else
            return nocachegetattr(tup, attnum, tupleDesc);
    }
    else
    {
        if (att_isnull(attnum - 1, tup->t_data->t_bits))
        {
            *isnull = true;
            return (Datum) 0;

References Assert, att_isnull(), attnum, fb(), fetchatt, HeapTupleNoNulls(), nocachegetattr(), and TupleDescCompactAttr().

Referenced by AttrDefaultFetch(), CatalogCacheComputeTupleHashValue(), check_toast_tuple(), CheckNNConstraintFetch(), extractRelOptions(), heap_fetch_toast_slice(), heap_getattr(), load_domaintype_info(), MergeWithExistingConstraint(), pg_get_triggerdef_worker(), RelationBuildTriggers(), RelationGetExclusionInfo(), RelationInitIndexAccessInfo(), ReorderBufferToastAppendChunk(), and ReorderBufferToastReplace().

◆ getmissingattr()

Datum getmissingattr	(	TupleDesc	tupleDesc,
		int	attnum,
		bool *	isnull
	)

extern

Definition at line 151 of file heaptuple.c.

{
    CompactAttribute *att;
 
    Assert(attnum <= tupleDesc->natts);
    Assert(attnum > 0);
 
    att = TupleDescCompactAttr(tupleDesc, attnum - 1);
 
    if (att->atthasmissing)
    {
        AttrMissing *attrmiss;
 
        Assert(tupleDesc->constr);
        Assert(tupleDesc->constr->missing);
 
        attrmiss = tupleDesc->constr->missing + (attnum - 1);
 
        if (attrmiss->am_present)
        {
            missing_cache_key key;
            missing_cache_key *entry;
            bool        found;
            MemoryContext oldctx;
 
            *isnull = false;
 
            /* no  need to cache by-value attributes */
            if (att->attbyval)
                return attrmiss->am_value;
 
            /* set up cache if required */
            if (missing_cache == NULL)
                init_missing_cache();
 
            /* check if there's a cache entry */
            Assert(att->attlen > 0 || att->attlen == -1);
            if (att->attlen > 0)
                key.len = att->attlen;
            else
                key.len = VARSIZE_ANY(DatumGetPointer(attrmiss->am_value));
            key.value = attrmiss->am_value;
 
            entry = hash_search(missing_cache, &key, HASH_ENTER, &found);
 
            if (!found)
            {
                /* cache miss, so we need a non-transient copy of the datum */
                oldctx = MemoryContextSwitchTo(TopMemoryContext);
                entry->value =
                    datumCopy(attrmiss->am_value, false, att->attlen);
                MemoryContextSwitchTo(oldctx);
            }
 
            return entry->value;
        }
    }
 
    *isnull = true;
    return PointerGetDatum(NULL);
}

References Assert, attnum, datumCopy(), DatumGetPointer(), fb(), HASH_ENTER, hash_search(), init_missing_cache(), MemoryContextSwitchTo(), missing_cache, PointerGetDatum(), TopMemoryContext, TupleDescCompactAttr(), missing_cache_key::value, and VARSIZE_ANY().

Referenced by heap_deform_tuple(), and heap_getattr().

◆ GETSTRUCT()

static void * GETSTRUCT ( const HeapTupleData * tuple )

inlinestatic

Definition at line 714 of file htup_details.h.

References HeapTupleData::t_data, and HeapTupleHeaderData::t_hoff.

◆ heap_attisnull()

bool heap_attisnull	(	HeapTuple	tup,
		int	attnum,
		TupleDesc	tupleDesc
	)

extern

Definition at line 456 of file heaptuple.c.

{
    /*
     * We allow a NULL tupledesc for relations not expected to have missing
     * values, such as catalog relations and indexes.
     */
    Assert(!tupleDesc || attnum <= tupleDesc->natts);
    if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
    {
        if (tupleDesc &&
            TupleDescCompactAttr(tupleDesc, attnum - 1)->atthasmissing)
            return false;
        else
            return true;
    }
 
    if (attnum > 0)
    {
        if (HeapTupleNoNulls(tup))
            return false;
        return att_isnull(attnum - 1, tup->t_data->t_bits);
    }
 
    switch (attnum)
    {
        case TableOidAttributeNumber:
        case SelfItemPointerAttributeNumber:
        case MinTransactionIdAttributeNumber:
        case MinCommandIdAttributeNumber:
        case MaxTransactionIdAttributeNumber:
        case MaxCommandIdAttributeNumber:
            /* these are never null */
            break;
 
        default:
            elog(ERROR, "invalid attnum: %d", attnum);
    }
 
    return false;
}

References Assert, att_isnull(), attnum, elog, ERROR, fb(), HeapTupleHeaderGetNatts, HeapTupleNoNulls(), MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, SelfItemPointerAttributeNumber, TableOidAttributeNumber, and TupleDescCompactAttr().

Referenced by AlterPublicationOptions(), AlterPublicationSchemas(), build_function_result_tupdesc_t(), check_index_is_clusterable(), check_modified_virtual_generated(), CheckIndexCompatible(), ExecEvalRowNullInt(), ExecuteCallStmt(), fmgr_info_cxt_security(), fmgr_symbol(), get_func_result_name(), index_drop(), inline_function(), inline_function_in_from(), IsIndexUsableForReplicaIdentityFull(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_statisticsobjdef_expressions(), RelationGetDummyIndexExpressions(), RelationGetIndexExpressions(), RelationGetIndexList(), RelationGetIndexPredicate(), statext_is_kind_built(), and transformFkeyCheckAttrs().

◆ heap_compute_data_size()

Size heap_compute_data_size	(	TupleDesc	tupleDesc,
		const Datum *	values,
		const bool *	isnull
	)

extern

Definition at line 219 of file heaptuple.c.

{
    Size        data_length = 0;
    int         i;
    int         numberOfAttributes = tupleDesc->natts;
 
    for (i = 0; i < numberOfAttributes; i++)
    {
        Datum       val;
        CompactAttribute *atti;
 
        if (isnull[i])
            continue;
 
        val = values[i];
        atti = TupleDescCompactAttr(tupleDesc, i);
 
        if (COMPACT_ATTR_IS_PACKABLE(atti) &&
            VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
        {
            /*
             * we're anticipating converting to a short varlena header, so
             * adjust length and don't count any alignment
             */
            data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val));
        }
        else if (atti->attlen == -1 &&
                 VARATT_IS_EXTERNAL_EXPANDED(DatumGetPointer(val)))
        {
            /*
             * we want to flatten the expanded value so that the constructed
             * tuple doesn't depend on it
             */
            data_length = att_nominal_alignby(data_length, atti->attalignby);
            data_length += EOH_get_flat_size(DatumGetEOHP(val));
        }
        else
        {
            data_length = att_datum_alignby(data_length, atti->attalignby,
                                            atti->attlen, val);
            data_length = att_addlength_datum(data_length, atti->attlen,
                                              val);
        }
    }
 
    return data_length;
}

References att_addlength_datum, att_datum_alignby, att_nominal_alignby, COMPACT_ATTR_IS_PACKABLE, DatumGetEOHP(), DatumGetPointer(), EOH_get_flat_size(), fb(), i, TupleDescCompactAttr(), val, values, VARATT_CAN_MAKE_SHORT(), VARATT_CONVERTED_SHORT_SIZE(), and VARATT_IS_EXTERNAL_EXPANDED().

Referenced by brin_form_tuple(), ER_get_flat_size(), heap_form_minimal_tuple(), heap_form_tuple(), heap_toast_insert_or_update(), index_form_tuple_context(), spgFormLeafTuple(), SpGistGetLeafTupleSize(), and toast_flatten_tuple_to_datum().

◆ heap_copy_minimal_tuple()

MinimalTuple heap_copy_minimal_tuple	(	MinimalTuple	mtup,
		Size	extra
	)

extern

Definition at line 1478 of file heaptuple.c.

{
    MinimalTuple result;
    char       *mem;
 
    Assert(extra == MAXALIGN(extra));
    mem = palloc(mtup->t_len + extra);
    memset(mem, 0, extra);
    result = (MinimalTuple) (mem + extra);
    memcpy(result, mtup, mtup->t_len);
    return result;
}

References Assert, fb(), MAXALIGN, memcpy(), palloc(), and result.

Referenced by gm_readnext_tuple(), tts_minimal_copy_minimal_tuple(), tts_minimal_materialize(), tuplesort_gettupleslot(), tuplestore_gettupleslot(), and tuplestore_gettupleslot_force().

◆ heap_copy_tuple_as_datum()

Datum heap_copy_tuple_as_datum	(	HeapTuple	tuple,
		TupleDesc	tupleDesc
	)

extern

Definition at line 989 of file heaptuple.c.

{
    HeapTupleHeader td;
 
    /*
     * If the tuple contains any external TOAST pointers, we have to inline
     * those fields to meet the conventions for composite-type Datums.
     */
    if (HeapTupleHasExternal(tuple))
        return toast_flatten_tuple_to_datum(tuple->t_data,
                                            tuple->t_len,
                                            tupleDesc);
 
    /*
     * Fast path for easy case: just make a palloc'd copy and insert the
     * correct composite-Datum header fields (since those may not be set if
     * the given tuple came from disk, rather than from heap_form_tuple).
     */
    td = (HeapTupleHeader) palloc(tuple->t_len);
    memcpy(td, tuple->t_data, tuple->t_len);
 
    HeapTupleHeaderSetDatumLength(td, tuple->t_len);
    HeapTupleHeaderSetTypeId(td, tupleDesc->tdtypeid);
    HeapTupleHeaderSetTypMod(td, tupleDesc->tdtypmod);
 
    return PointerGetDatum(td);
}

References fb(), HeapTupleHasExternal(), HeapTupleHeaderSetDatumLength(), HeapTupleHeaderSetTypeId(), HeapTupleHeaderSetTypMod(), memcpy(), palloc(), PointerGetDatum(), HeapTupleData::t_data, HeapTupleData::t_len, and toast_flatten_tuple_to_datum().

Referenced by ExecEvalConvertRowtype(), ExecFetchSlotHeapTupleDatum(), import_pg_statistic(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLySequence_ToComposite(), serialize_expr_stats(), and SPI_returntuple().

◆ heap_copytuple()

HeapTuple heap_copytuple ( HeapTuple tuple )

extern

Definition at line 686 of file heaptuple.c.

{
    HeapTuple   newTuple;
 
    if (!HeapTupleIsValid(tuple) || tuple->t_data == NULL)
        return NULL;
 
    newTuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple->t_len);
    newTuple->t_len = tuple->t_len;
    newTuple->t_self = tuple->t_self;
    newTuple->t_tableOid = tuple->t_tableOid;
    newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
    memcpy(newTuple->t_data, tuple->t_data, tuple->t_len);
    return newTuple;
}

References fb(), HeapTupleIsValid, HEAPTUPLESIZE, memcpy(), palloc(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by AlterConstraintNamespaces(), AlterConstrTriggerDeferrability(), AlterConstrUpdateConstraintEntry(), AlterDomainValidateConstraint(), AlterExtensionNamespace(), AlterSequence(), AlterTypeOwner(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), ConstraintSetParentConstraint(), CopyStatistics(), CreateTriggerFiringOn(), DefineIndex(), dropconstraint_internal(), EnableDisableTrigger(), ExecForceStoreHeapTuple(), expanded_record_set_tuple(), findDomainNotNullConstraint(), findNotNullConstraintAttnum(), get_catalog_object_by_oid_extended(), GetDatabaseTuple(), GetDatabaseTupleByOid(), index_concurrently_swap(), make_expanded_record_from_datum(), MarkInheritDetached(), MergeConstraintsIntoExisting(), MergeWithExistingConstraint(), QueueCheckConstraintValidation(), QueueFKConstraintValidation(), QueueNNConstraintValidation(), RelationInitIndexAccessInfo(), RemoveInheritance(), rename_policy(), RenameEnumLabel(), RenameTableSpace(), renametrig_internal(), RenumberEnumType(), ResetSequence(), rewrite_heap_tuple(), ScanPgRelation(), SearchSysCacheCopy(), SearchSysCacheCopyAttName(), SearchSysCacheCopyAttNum(), SearchSysCacheLockedCopy1(), shdepChangeDep(), SPI_copytuple(), statext_expressions_load(), systable_inplace_update_begin(), TriggerSetParentTrigger(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_materialize(), tts_heap_copy_heap_tuple(), tts_heap_materialize(), and tuplesort_putheaptuple().

◆ heap_copytuple_with_tuple()

void heap_copytuple_with_tuple	(	HeapTuple	src,
		HeapTuple	dest
	)

extern

Definition at line 712 of file heaptuple.c.

{
    if (!HeapTupleIsValid(src) || src->t_data == NULL)
    {
        dest->t_data = NULL;
        return;
    }
 
    dest->t_len = src->t_len;
    dest->t_self = src->t_self;
    dest->t_tableOid = src->t_tableOid;
    dest->t_data = (HeapTupleHeader) palloc(src->t_len);
    memcpy(dest->t_data, src->t_data, src->t_len);
}

References fb(), HeapTupleIsValid, memcpy(), palloc(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

◆ heap_deform_tuple()

void heap_deform_tuple	(	HeapTuple	tuple,
		TupleDesc	tupleDesc,
		Datum *	values,
		bool *	isnull
	)

extern

Definition at line 1254 of file heaptuple.c.

{
    HeapTupleHeader tup = tuple->t_data;
    CompactAttribute *cattr;
    bool        hasnulls = HeapTupleHasNulls(tuple);
    int         tdesc_natts = tupleDesc->natts;
    int         natts;          /* number of atts to extract */
    int         attnum;
    char       *tp;             /* ptr to tuple data */
    uint32      off;            /* offset in tuple data */
    uint8      *bp = tup->t_bits;   /* ptr to null bitmap in tuple */
    int         firstNonCacheOffsetAttr;
    int         firstNullAttr;
 
    natts = HeapTupleHeaderGetNatts(tup);
 
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupleDesc->firstNonCachedOffsetAttr >= 0);
 
    /*
     * In inheritance situations, it is possible that the given tuple actually
     * has more fields than the caller is expecting.  Don't run off the end of
     * the caller's arrays.
     */
    natts = Min(natts, tdesc_natts);
    firstNonCacheOffsetAttr = Min(tupleDesc->firstNonCachedOffsetAttr, natts);
 
    if (hasnulls)
    {
        firstNullAttr = first_null_attr(bp, natts);
 
        /*
         * XXX: it'd be nice to use populate_isnull_array() here, but that
         * requires that the isnull array's size is rounded up to the next
         * multiple of 8.  Doing that would require adjusting many locations
         * that allocate the array.
         */
        firstNonCacheOffsetAttr = Min(firstNonCacheOffsetAttr, firstNullAttr);
    }
    else
        firstNullAttr = natts;
 
    tp = (char *) tup + tup->t_hoff;
    attnum = 0;
 
    if (firstNonCacheOffsetAttr > 0)
    {
#ifdef USE_ASSERT_CHECKING
        /* In Assert enabled builds, verify attcacheoff is correct */
        int         offcheck = 0;
#endif
        do
        {
            isnull[attnum] = false;
            cattr = TupleDescCompactAttr(tupleDesc, attnum);
            off = cattr->attcacheoff;
 
#ifdef USE_ASSERT_CHECKING
            offcheck = att_nominal_alignby(offcheck, cattr->attalignby);
            Assert(offcheck == cattr->attcacheoff);
            offcheck += cattr->attlen;
#endif
 
            values[attnum] = fetch_att_noerr(tp + off,
                                             cattr->attbyval,
                                             cattr->attlen);
        } while (++attnum < firstNonCacheOffsetAttr);
        off += cattr->attlen;
    }
    else
        off = 0;
 
    for (; attnum < firstNullAttr; attnum++)
    {
        isnull[attnum] = false;
        cattr = TupleDescCompactAttr(tupleDesc, attnum);
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              cattr->attlen,
                                              cattr->attalignby);
    }
 
    for (; attnum < natts; attnum++)
    {
        Assert(hasnulls);
 
        if (att_isnull(attnum, bp))
        {
            values[attnum] = (Datum) 0;
            isnull[attnum] = true;
            continue;
        }
 
        isnull[attnum] = false;
        cattr = TupleDescCompactAttr(tupleDesc, attnum);
 
        /* align 'off', fetch the attr's value, and increment off beyond it */
        values[attnum] = align_fetch_then_add(tp,
                                              &off,
                                              cattr->attbyval,
                                              cattr->attlen,
                                              cattr->attalignby);
    }
 
    /*
     * If tuple doesn't have all the atts indicated by tupleDesc, read the
     * rest as nulls or missing values as appropriate.
     */
    for (; attnum < tdesc_natts; attnum++)
        values[attnum] = getmissingattr(tupleDesc, attnum + 1, &isnull[attnum]);
}

References align_fetch_then_add(), Assert, att_isnull(), att_nominal_alignby, attnum, fb(), fetch_att_noerr(), first_null_attr(), getmissingattr(), HeapTupleHasNulls(), HeapTupleHeaderGetNatts, Min, HeapTupleData::t_data, TupleDescCompactAttr(), and values.

Referenced by attribute_statistics_update(), deconstruct_expanded_record(), exec_move_row(), ExecEvalFieldStoreDeForm(), ExecForceStoreHeapTuple(), ExecForceStoreMinimalTuple(), ExecStoreHeapTupleDatum(), execute_attr_map_tuple(), ExtractReplicaIdentity(), hash_record(), hash_record_extended(), heap_modify_tuple(), heap_modify_tuple_by_cols(), heap_toast_delete(), heap_toast_insert_or_update(), hstore_from_record(), hstore_populate_record(), make_tuple_indirect(), populate_record(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_out(), record_send(), reform_and_rewrite_tuple(), ReorderBufferToastReplace(), RI_Initial_Check(), RI_PartitionRemove_Check(), SPI_modifytuple(), toast_flatten_tuple(), and toast_flatten_tuple_to_datum().

◆ heap_expand_tuple()

HeapTuple heap_expand_tuple	(	HeapTuple	sourceTuple,
		TupleDesc	tupleDesc
	)

extern

Definition at line 974 of file heaptuple.c.

{
    HeapTuple   heapTuple;
 
    expand_tuple(&heapTuple, NULL, sourceTuple, tupleDesc);
    return heapTuple;
}

References expand_tuple(), and fb().

◆ heap_fill_tuple()

void heap_fill_tuple	(	TupleDesc	tupleDesc,
		const Datum *	values,
		const bool *	isnull,
		char *	data,
		Size	data_size,
		uint16 *	infomask,
		uint8 *	bit
	)

extern

Definition at line 401 of file heaptuple.c.

{
    uint8      *bitP;
    int         bitmask;
    int         i;
    int         numberOfAttributes = tupleDesc->natts;
 
#ifdef USE_ASSERT_CHECKING
    char       *start = data;
#endif
 
    if (bit != NULL)
    {
        bitP = &bit[-1];
        bitmask = HIGHBIT;
    }
    else
    {
        /* just to keep compiler quiet */
        bitP = NULL;
        bitmask = 0;
    }
 
    *infomask &= ~(HEAP_HASNULL | HEAP_HASVARWIDTH | HEAP_HASEXTERNAL);
 
    for (i = 0; i < numberOfAttributes; i++)
    {
        CompactAttribute *attr = TupleDescCompactAttr(tupleDesc, i);
 
        fill_val(attr,
                 bitP ? &bitP : NULL,
                 &bitmask,
                 &data,
                 infomask,
                 values ? values[i] : PointerGetDatum(NULL),
                 isnull ? isnull[i] : true);
    }
 
    Assert((data - start) == data_size);
}

References Assert, bit(), data, fb(), fill_val(), HEAP_HASEXTERNAL, HEAP_HASNULL, HEAP_HASVARWIDTH, HIGHBIT, i, PointerGetDatum(), start, TupleDescCompactAttr(), and values.

Referenced by brin_form_tuple(), ER_flatten_into(), heap_form_minimal_tuple(), heap_form_tuple(), heap_toast_insert_or_update(), index_form_tuple_context(), spgFormLeafTuple(), and toast_flatten_tuple_to_datum().

◆ heap_form_minimal_tuple()

MinimalTuple heap_form_minimal_tuple	(	TupleDesc	tupleDescriptor,
		const Datum *	values,
		const bool *	isnull,
		Size	extra
	)

extern

Definition at line 1390 of file heaptuple.c.

{
    MinimalTuple tuple;         /* return tuple */
    char       *mem;
    Size        len,
                data_len;
    int         hoff;
    bool        hasnull = false;
    int         numberOfAttributes = tupleDescriptor->natts;
    int         i;
 
    Assert(extra == MAXALIGN(extra));
 
    if (numberOfAttributes > MaxTupleAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("number of columns (%d) exceeds limit (%d)",
                        numberOfAttributes, MaxTupleAttributeNumber)));
 
    /*
     * Check for nulls
     */
    for (i = 0; i < numberOfAttributes; i++)
    {
        if (isnull[i])
        {
            hasnull = true;
            break;
        }
    }
 
    /*
     * Determine total space needed
     */
    len = SizeofMinimalTupleHeader;
 
    if (hasnull)
        len += BITMAPLEN(numberOfAttributes);
 
    hoff = len = MAXALIGN(len); /* align user data safely */
 
    data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
 
    len += data_len;
 
    /*
     * Allocate and zero the space needed.
     */
    mem = palloc0(len + extra);
    tuple = (MinimalTuple) (mem + extra);
 
    /*
     * And fill in the information.
     */
    tuple->t_len = len;
    HeapTupleHeaderSetNatts(tuple, numberOfAttributes);
    tuple->t_hoff = hoff + MINIMAL_TUPLE_OFFSET;
 
    heap_fill_tuple(tupleDescriptor,
                    values,
                    isnull,
                    (char *) tuple + hoff,
                    data_len,
                    &tuple->t_infomask,
                    (hasnull ? tuple->t_bits : NULL));
 
    return tuple;
}

References Assert, BITMAPLEN(), ereport, errcode(), errmsg, ERROR, fb(), heap_compute_data_size(), heap_fill_tuple(), HeapTupleHeaderSetNatts, i, len, MAXALIGN, MaxTupleAttributeNumber, MINIMAL_TUPLE_OFFSET, palloc0(), SizeofMinimalTupleHeader, MinimalTupleData::t_bits, MinimalTupleData::t_hoff, MinimalTupleData::t_infomask, MinimalTupleData::t_len, and values.

Referenced by tts_minimal_materialize(), tts_virtual_copy_minimal_tuple(), and tuplestore_putvalues().

◆ heap_form_tuple()

HeapTuple heap_form_tuple	(	TupleDesc	tupleDescriptor,
		const Datum *	values,
		const bool *	isnull
	)

extern

Definition at line 1025 of file heaptuple.c.

{
    HeapTuple   tuple;          /* return tuple */
    HeapTupleHeader td;         /* tuple data */
    Size        len,
                data_len;
    int         hoff;
    bool        hasnull = false;
    int         numberOfAttributes = tupleDescriptor->natts;
    int         i;
 
    if (numberOfAttributes > MaxTupleAttributeNumber)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_COLUMNS),
                 errmsg("number of columns (%d) exceeds limit (%d)",
                        numberOfAttributes, MaxTupleAttributeNumber)));
 
    /*
     * Check for nulls
     */
    for (i = 0; i < numberOfAttributes; i++)
    {
        if (isnull[i])
        {
            hasnull = true;
            break;
        }
    }
 
    /*
     * Determine total space needed
     */
    len = offsetof(HeapTupleHeaderData, t_bits);
 
    if (hasnull)
        len += BITMAPLEN(numberOfAttributes);
 
    hoff = len = MAXALIGN(len); /* align user data safely */
 
    data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
 
    len += data_len;
 
    /*
     * Allocate and zero the space needed.  Note that the tuple body and
     * HeapTupleData management structure are allocated in one chunk.
     */
    tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + len);
    tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
 
    /*
     * And fill in the information.  Note we fill the Datum fields even though
     * this tuple may never become a Datum.  This lets HeapTupleHeaderGetDatum
     * identify the tuple type if needed.
     */
    tuple->t_len = len;
    ItemPointerSetInvalid(&(tuple->t_self));
    tuple->t_tableOid = InvalidOid;
 
    HeapTupleHeaderSetDatumLength(td, len);
    HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
    HeapTupleHeaderSetTypMod(td, tupleDescriptor->tdtypmod);
    /* We also make sure that t_ctid is invalid unless explicitly set */
    ItemPointerSetInvalid(&(td->t_ctid));
 
    HeapTupleHeaderSetNatts(td, numberOfAttributes);
    td->t_hoff = hoff;
 
    heap_fill_tuple(tupleDescriptor,
                    values,
                    isnull,
                    (char *) td + hoff,
                    data_len,
                    &td->t_infomask,
                    (hasnull ? td->t_bits : NULL));
 
    return tuple;
}

References BITMAPLEN(), ereport, errcode(), errmsg, ERROR, fb(), heap_compute_data_size(), heap_fill_tuple(), HeapTupleHeaderSetDatumLength(), HeapTupleHeaderSetNatts, HeapTupleHeaderSetTypeId(), HeapTupleHeaderSetTypMod(), HEAPTUPLESIZE, i, InvalidOid, ItemPointerSetInvalid(), len, MAXALIGN, MaxTupleAttributeNumber, palloc0(), HeapTupleHeaderData::t_bits, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, HeapTupleHeaderData::t_infomask, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and values.

Referenced by aclexplode(), AddEnumLabel(), AddRoleMems(), AddSubscriptionRelState(), AggregateCreate(), AlterSetting(), brin_metapage_info(), bt_page_print_tuples(), BuildTupleFromCStrings(), CastCreate(), CollationCreate(), ConversionCreate(), copy_replication_slot(), CopyToJsonOneRow(), CreateAccessMethod(), CreateComments(), CreateConstraintEntry(), createdb(), CreateForeignDataWrapper(), CreateForeignServer(), CreateForeignTable(), CreateOpFamily(), CreatePolicy(), CreateProceduralLanguage(), CreatePublication(), CreateRole(), CreateSharedComments(), CreateStatistics(), CreateSubscription(), CreateTableSpace(), CreateTransform(), CreateTriggerFiringOn(), CreateUserMapping(), DefineOpClass(), DefineSequence(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), each_object_field_end(), elements_array_element_end(), ExecEvalFieldStoreForm(), ExecEvalRow(), execute_attr_map_tuple(), expanded_record_get_tuple(), ExtractReplicaIdentity(), file_acquire_sample_rows(), fill_hba_line(), fill_ident_line(), gin_leafpage_items(), gin_metapage_info(), gin_page_opaque_info(), gist_page_opaque_info(), gistFetchTuple(), hash_bitmap_info(), hash_metapage_info(), hash_page_items(), hash_page_stats(), heap_modify_tuple(), heap_modify_tuple_by_cols(), heap_page_items(), heap_tuple_infomask_flags(), hstore_each(), hstore_populate_record(), import_pg_statistic(), insert_element_record(), insert_event_trigger_tuple(), insert_label_record(), insert_property_record(), InsertExtensionTuple(), InsertOneTuple(), InsertPgClassTuple(), InsertRule(), inv_truncate(), inv_write(), LargeObjectCreate(), make_tuple_from_result_row(), make_tuple_from_row(), make_tuple_indirect(), NamespaceCreate(), OperatorCreate(), OperatorShellMake(), page_header(), ParameterAclCreate(), pg_available_wal_summaries(), pg_backup_stop(), pg_buffercache_evict(), pg_buffercache_evict_all(), pg_buffercache_evict_relation(), pg_buffercache_mark_dirty(), pg_buffercache_mark_dirty_all(), pg_buffercache_mark_dirty_relation(), pg_buffercache_os_pages_internal(), pg_buffercache_pages(), pg_buffercache_summary(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_create_logical_replication_slot(), pg_create_physical_replication_slot(), pg_get_catalog_foreign_keys(), pg_get_logical_snapshot_info(), pg_get_logical_snapshot_meta(), pg_get_multixact_stats(), pg_get_object_address(), pg_get_publication_tables(), pg_get_sequence_data(), pg_get_wal_record_info(), pg_get_wal_summarizer_state(), pg_identify_object(), pg_identify_object_as_address(), pg_input_error_info(), pg_last_committed_xact(), pg_lock_status(), pg_partition_tree(), pg_prepared_xact(), pg_replication_slot_advance(), pg_sequence_parameters(), pg_split_walfile_name(), pg_stat_file(), pg_stat_get_archiver(), pg_stat_get_backend_subxact(), pg_stat_get_recovery(), pg_stat_get_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal_receiver(), pg_stat_statements_info(), pg_stat_wal_build_tuple(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs_abbrevs(), pg_timezone_abbrevs_zone(), pg_visibility(), pg_visibility_map(), pg_visibility_map_rel(), pg_visibility_map_summary(), pg_visibility_rel(), pg_wal_summary_contents(), pg_walfile_name_offset(), pg_xact_commit_timestamp_origin(), pgstatginindex_internal(), pgstathashindex(), pgstattuple_approx_internal(), plperl_build_tuple_result(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLySequence_ToComposite(), populate_record(), ProcedureCreate(), publication_add_relation(), publication_add_schema(), RangeCreate(), record_in(), record_recv(), recordExtensionInitPrivWorker(), reform_and_rewrite_tuple(), ReorderBufferToastReplace(), replorigin_create(), report_corruption_internal(), serialize_expr_stats(), SetDefaultACL(), SetSecurityLabel(), SetSharedSecurityLabel(), shdepAddDependency(), shdepChangeDep(), SPI_modifytuple(), ssl_extension_info(), statext_store(), StoreAttrDefault(), storeGettuple(), storeOperators(), StorePartitionKey(), storeProcedures(), StoreSingleInheritance(), test_custom_stats_fixed_report(), test_custom_stats_var_report(), test_enc_conversion(), test_predtest(), test_saslprep(), test_saslprep_ranges(), toast_build_flattened_tuple(), toast_flatten_tuple(), toast_save_datum(), tsvector_unnest(), tts_buffer_heap_materialize(), tts_heap_materialize(), tts_virtual_copy_heap_tuple(), TypeCreate(), TypeShellMake(), update_attstats(), UpdateIndexRelation(), upsert_pg_statistic(), and upsert_pg_statistic_ext_data().

◆ heap_free_minimal_tuple()

void heap_free_minimal_tuple ( MinimalTuple mtup )

extern

Definition at line 1466 of file heaptuple.c.

{
    pfree(mtup);
}

References fb(), and pfree().

Referenced by ExecHashJoinImpl(), ExecHashSkewTableInsert(), ExecHashTableInsert(), ExecParallelHashJoinPartitionOuter(), ExecParallelHashTableInsert(), ExecParallelHashTableInsertCurrentBatch(), tts_minimal_clear(), and writetup_heap().

◆ heap_freetuple()

void heap_freetuple ( HeapTuple htup )

extern

Definition at line 1372 of file heaptuple.c.

{
    pfree(htup);
}

References pfree().

Referenced by acquire_inherited_sample_rows(), acquire_sample_rows(), AddEnumLabel(), AddSubscriptionRelState(), AfterTriggerExecute(), AlterCollation(), AlterConstrTriggerDeferrability(), AlterConstrUpdateConstraintEntry(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDomainDefault(), AlterDomainNotNull(), AlterDomainValidateConstraint(), AlterEventTrigger(), AlterEventTriggerOwner(), AlterEventTriggerOwner_oid(), AlterForeignDataWrapper(), AlterForeignDataWrapperOwner(), AlterForeignDataWrapperOwner_oid(), AlterForeignServer(), AlterForeignServerOwner(), AlterForeignServerOwner_oid(), AlterFunction(), AlterObjectRename_internal(), AlterPolicy(), AlterPublication(), AlterPublicationOwner(), AlterPublicationOwner_oid(), AlterRelationNamespaceInternal(), AlterRole(), AlterSchemaOwner_internal(), AlterStatistics(), AlterSubscription(), AlterSubscriptionOwner(), AlterSubscriptionOwner_oid(), AlterTableSpaceOptions(), AlterTSDictionary(), AlterTypeNamespaceInternal(), AlterUserMapping(), analyze_row_processor(), ATExecAddColumn(), ATExecAddIdentity(), ATExecAddOf(), ATExecAlterColumnGenericOptions(), ATExecAlterColumnType(), ATExecAlterConstrInheritability(), ATExecChangeOwner(), ATExecDropColumn(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropNotNull(), ATExecDropOf(), ATExecForceNoForceRowSecurity(), ATExecGenericOptions(), ATExecSetAccessMethodNoStorage(), ATExecSetCompression(), ATExecSetIdentity(), ATExecSetOptions(), ATExecSetRelOptions(), ATExecSetRowSecurity(), ATExecSetStatistics(), ATExecSetStorage(), ATPrepAddPrimaryKey(), build_tuplestore_recursively(), CastCreate(), CatalogCacheCreateEntry(), CatalogTuplesMultiInsertWithInfo(), change_owner_fix_column_acls(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), clear_subscription_skip_lsn(), CollationCreate(), ConversionCreate(), copy_table_data(), CopyStatistics(), create_toast_table(), CreateAccessMethod(), CreateComments(), CreateForeignDataWrapper(), CreateForeignServer(), CreateForeignTable(), CreateOpFamily(), CreatePolicy(), CreatePublication(), CreateSharedComments(), CreateStatistics(), CreateSubscription(), CreateTableSpace(), CreateTransform(), CreateTriggerFiringOn(), CreateUserMapping(), crosstab(), DefineIndex(), DefineOpClass(), DefineSequence(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), DetachPartitionFinalize(), DisableSubscription(), dropconstraint_internal(), dropdb(), EnableDisableRule(), EnableDisableTrigger(), EventTriggerOnLogin(), examine_attribute(), examine_attribute(), examine_expression(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecForPortionOfLeftovers(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecReScanAgg(), ExecReScanIndexScan(), ExecScanSubPlan(), ExecSetParamPlan(), expanded_record_set_tuple(), extended_statistics_update(), ExtractReplicaIdentity(), file_acquire_sample_rows(), heap_delete(), heap_insert(), heap_update(), import_pg_statistic(), index_build(), index_concurrently_swap(), index_constraint_create(), index_update_stats(), insert_element_record(), insert_event_trigger_tuple(), insert_label_record(), insert_property_record(), InsertExtensionTuple(), InsertOneTuple(), InsertPgClassTuple(), InsertRule(), inv_truncate(), inv_write(), LargeObjectCreate(), mark_index_clustered(), MarkInheritDetached(), MergeAttributesIntoExisting(), MergeConstraintsIntoExisting(), OperatorShellMake(), ParameterAclCreate(), pg_clear_extended_stats(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLySequence_ToComposite(), ProcedureCreate(), publication_add_relation(), publication_add_schema(), QueueCheckConstraintValidation(), QueueFKConstraintValidation(), QueueNNConstraintValidation(), RangeCreate(), raw_heap_insert(), record_in(), record_recv(), reform_and_rewrite_tuple(), relation_mark_replica_identity(), relation_statistics_update(), RelationBuildDesc(), RelationClearMissing(), RelationInitPhysicalAddr(), RelationReloadIndexInfo(), RelationReloadNailed(), RelationSetNewRelfilenumber(), RemoveConstraintById(), RemoveInheritance(), RemoveRoleFromObjectPolicy(), renameatt_internal(), RenameConstraintById(), RenameEnumLabel(), RenameRelationInternal(), RenameRewriteRule(), RenameSchema(), RenameTypeInternal(), RenumberEnumType(), replorigin_create(), ResetRelRewrite(), rewrite_heap_dead_tuple(), rewrite_heap_tuple(), set_attnotnull(), SetDatabaseHasLoginEventTriggers(), SetIndexStorageProperties(), SetMatViewPopulatedState(), SetRelationHasSubclass(), SetRelationNumChecks(), SetRelationRuleStatus(), SetRelationTableSpace(), SetSecurityLabel(), SetSharedSecurityLabel(), shdepAddDependency(), shdepChangeDep(), SPI_freetuple(), statext_store(), StoreAttrDefault(), storeOperators(), StorePartitionBound(), storeProcedures(), StoreSingleInheritance(), swap_relation_files(), table_recheck_autovac(), toast_save_datum(), TriggerSetParentTrigger(), tts_buffer_heap_clear(), tts_buffer_heap_store_tuple(), tts_heap_clear(), TypeShellMake(), update_attstats(), update_default_partition_oid(), update_relispartition(), UpdateDeadTupleRetentionStatus(), UpdateIndexRelation(), UpdateTwoPhaseState(), upsert_pg_statistic(), upsert_pg_statistic_ext_data(), vac_update_datfrozenxid(), validatePartitionedIndex(), and xpath_table().

◆ heap_getattr()

static Datum heap_getattr	(	HeapTuple	tup,
		int	attnum,
		TupleDesc	tupleDesc,
		bool *	isnull
	)

inlinestatic

Definition at line 890 of file htup_details.h.

{
    if (attnum > 0)
    {
        if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
            return getmissingattr(tupleDesc, attnum, isnull);
        else

References attnum, fastgetattr(), fb(), getmissingattr(), heap_getsysattr(), and HeapTupleHeaderGetNatts.

Referenced by AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterForeignDataWrapperOwner_internal(), AlterForeignServerOwner_internal(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterPolicy(), AlterSetting(), AlterTableSpaceOptions(), AlterTypeOwnerInternal(), ApplySetting(), ATExecAlterColumnType(), BuildEventTriggerCache(), CatalogCacheCreateEntry(), change_owner_fix_column_acls(), check_element_properties(), CloneRowTriggersToPartition(), comparetup_cluster_tiebreak(), comparetup_heap_tiebreak(), composite_to_json(), composite_to_jsonb(), decompile_conbin(), ExecAlterExtensionStmt(), ExecEvalFieldSelect(), ExecGrant_Largeobject(), ExecScanSubPlan(), ExecSetParamPlan(), extension_config_remove(), GenerateTypeDependencies(), get_primary_key_attnos(), get_relation_constraint_attnos(), GetAttributeByName(), GetAttributeByNum(), GetComment(), GetSecurityLabel(), GetSharedSecurityLabel(), GetSysCacheOid(), HeapDetermineColumnsInfo(), HeapKeyTest(), make_build_data(), make_propgraphdef_elements(), make_propgraphdef_properties(), object_ownercheck(), obtain_object_name_namespace(), pg_event_trigger_ddl_commands(), pg_extension_config_dump(), pg_get_acl(), pg_get_database_ddl_internal(), pg_get_role_ddl_internal(), pg_identify_object(), pg_largeobject_aclmask_snapshot(), plperl_hash_from_tuple(), pltcl_build_tuple_argument(), pltcl_set_tuple_values(), PLyDict_FromTuple(), readtup_cluster(), readtup_heap(), recordExtensionInitPrivWorker(), recordExtObjInitPriv(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTupleDesc(), RelationGetDummyIndexExpressions(), RelationGetIndexAttrBitmap(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), removeabbrev_cluster(), removeabbrev_heap(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectPolicy(), RenameRole(), ReplaceRoleInInitPriv(), sepgsql_relation_setattr_extra(), SPI_getbinval(), SPI_getvalue(), std_fetch_func(), SysCacheGetAttr(), tuple_to_stringinfo(), tuplesort_putheaptuple(), and tuplesort_puttupleslot().

◆ heap_getsysattr()

Datum heap_getsysattr	(	HeapTuple	tup,
		int	attnum,
		TupleDesc	tupleDesc,
		bool *	isnull
	)

extern

Definition at line 633 of file heaptuple.c.

{
    Datum       result;
 
    Assert(tup);
 
    /* Currently, no sys attribute ever reads as NULL. */
    *isnull = false;
 
    switch (attnum)
    {
        case SelfItemPointerAttributeNumber:
            /* pass-by-reference datatype */
            result = PointerGetDatum(&(tup->t_self));
            break;
        case MinTransactionIdAttributeNumber:
            result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmin(tup->t_data));
            break;
        case MaxTransactionIdAttributeNumber:
            result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmax(tup->t_data));
            break;
        case MinCommandIdAttributeNumber:
        case MaxCommandIdAttributeNumber:
 
            /*
             * cmin and cmax are now both aliases for the same field, which
             * can in fact also be a combo command id.  XXX perhaps we should
             * return the "real" cmin or cmax if possible, that is if we are
             * inside the originating transaction?
             */
            result = CommandIdGetDatum(HeapTupleHeaderGetRawCommandId(tup->t_data));
            break;
        case TableOidAttributeNumber:
            result = ObjectIdGetDatum(tup->t_tableOid);
            break;
        default:
            elog(ERROR, "invalid attnum: %d", attnum);
            result = 0;         /* keep compiler quiet */
            break;
    }
    return result;
}

References Assert, attnum, CommandIdGetDatum(), elog, ERROR, fb(), HeapTupleHeaderGetRawCommandId(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, ObjectIdGetDatum(), PointerGetDatum(), result, SelfItemPointerAttributeNumber, TableOidAttributeNumber, and TransactionIdGetDatum().

Referenced by expanded_record_fetch_field(), heap_getattr(), tts_buffer_heap_getsysattr(), and tts_heap_getsysattr().

◆ HEAP_LOCKED_UPGRADED()

static bool HEAP_LOCKED_UPGRADED ( uint16 infomask )

inlinestatic

Definition at line 251 of file htup_details.h.

256{

257 return

References fb(), HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, and HEAP_XMAX_LOCK_ONLY.

Referenced by compute_new_xmax_infomask(), Do_MultiXactIdWait(), DoesMultiXactIdConflict(), FreezeMultiXactId(), heap_lock_updated_tuple_rec(), heap_tuple_should_freeze(), heap_update(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), and pgrowlocks().

◆ heap_modify_tuple()

HeapTuple heap_modify_tuple	(	HeapTuple	tuple,
		TupleDesc	tupleDesc,
		const Datum *	replValues,
		const bool *	replIsnull,
		const bool *	doReplace
	)

extern

Definition at line 1118 of file heaptuple.c.

{
    int         numberOfAttributes = tupleDesc->natts;
    int         attoff;
    Datum      *values;
    bool       *isnull;
    HeapTuple   newTuple;
 
    /*
     * allocate and fill values and isnull arrays from either the tuple or the
     * repl information, as appropriate.
     *
     * NOTE: it's debatable whether to use heap_deform_tuple() here or just
     * heap_getattr() only the non-replaced columns.  The latter could win if
     * there are many replaced columns and few non-replaced ones. However,
     * heap_deform_tuple costs only O(N) while the heap_getattr way would cost
     * O(N^2) if there are many non-replaced columns, so it seems better to
     * err on the side of linear cost.
     */
    values = palloc_array(Datum, numberOfAttributes);
    isnull = palloc_array(bool, numberOfAttributes);
 
    heap_deform_tuple(tuple, tupleDesc, values, isnull);
 
    for (attoff = 0; attoff < numberOfAttributes; attoff++)
    {
        if (doReplace[attoff])
        {
            values[attoff] = replValues[attoff];
            isnull[attoff] = replIsnull[attoff];
        }
    }
 
    /*
     * create a new tuple from the values and isnull arrays
     */
    newTuple = heap_form_tuple(tupleDesc, values, isnull);
 
    pfree(values);
    pfree(isnull);
 
    /*
     * copy the identification info of the old tuple: t_ctid, t_self
     */
    newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
    newTuple->t_self = tuple->t_self;
    newTuple->t_tableOid = tuple->t_tableOid;
 
    return newTuple;
}

References fb(), heap_deform_tuple(), heap_form_tuple(), palloc_array, pfree(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, and values.

Referenced by AddRoleMems(), AggregateCreate(), AlterCollation(), AlterDatabase(), AlterDatabaseOwner(), AlterDatabaseRefreshColl(), AlterDomainDefault(), AlterForeignDataWrapper(), AlterForeignDataWrapperOwner_internal(), AlterForeignServer(), AlterForeignServerOwner_internal(), AlterFunction(), AlterObjectNamespace_internal(), AlterObjectOwner_internal(), AlterObjectRename_internal(), AlterOperator(), AlterPolicy(), AlterPublicationAllFlags(), AlterPublicationOptions(), AlterRole(), AlterSchemaOwner_internal(), AlterSetting(), AlterStatistics(), AlterSubscription(), AlterTableSpaceOptions(), AlterTSDictionary(), AlterTypeOwnerInternal(), AlterTypeRecurse(), AlterUserMapping(), ApplyExtensionUpdates(), ATExecAlterColumnGenericOptions(), ATExecAlterColumnType(), ATExecChangeOwner(), ATExecGenericOptions(), ATExecSetOptions(), ATExecSetRelOptions(), ATExecSetStatistics(), change_owner_fix_column_acls(), clear_subscription_skip_lsn(), CreateComments(), CreateProceduralLanguage(), CreateSharedComments(), CreateTransform(), DelRoleMems(), DetachPartitionFinalize(), DisableSubscription(), ExecGrant_Attribute(), ExecGrant_common(), ExecGrant_Largeobject(), ExecGrant_Parameter(), ExecGrant_Relation(), extension_config_remove(), index_concurrently_swap(), InsertRule(), inv_truncate(), inv_write(), MakeConfigurationMapping(), movedb(), OperatorCreate(), pg_extension_config_dump(), plperl_modify_tuple(), PLy_modify_tuple(), ProcedureCreate(), recordExtensionInitPrivWorker(), RelationClearMissing(), RemoveAttributeById(), RemoveRoleFromInitPriv(), RemoveRoleFromObjectPolicy(), RenameRole(), ReplaceRoleInInitPriv(), SetAttrMissing(), SetDefaultACL(), SetSecurityLabel(), SetSharedSecurityLabel(), StoreAttrDefault(), StoreAttrMissingVal(), StorePartitionBound(), TypeCreate(), update_attstats(), UpdateDeadTupleRetentionStatus(), UpdateSubscriptionRelState(), UpdateTwoPhaseState(), upsert_pg_statistic(), and upsert_pg_statistic_ext_data().

◆ heap_modify_tuple_by_cols()

HeapTuple heap_modify_tuple_by_cols	(	HeapTuple	tuple,
		TupleDesc	tupleDesc,
		int	nCols,
		const int *	replCols,
		const Datum *	replValues,
		const bool *	replIsnull
	)

extern

Definition at line 1186 of file heaptuple.c.

{
    int         numberOfAttributes = tupleDesc->natts;
    Datum      *values;
    bool       *isnull;
    HeapTuple   newTuple;
    int         i;
 
    /*
     * allocate and fill values and isnull arrays from the tuple, then replace
     * selected columns from the input arrays.
     */
    values = palloc_array(Datum, numberOfAttributes);
    isnull = palloc_array(bool, numberOfAttributes);
 
    heap_deform_tuple(tuple, tupleDesc, values, isnull);
 
    for (i = 0; i < nCols; i++)
    {
        int         attnum = replCols[i];
 
        if (attnum <= 0 || attnum > numberOfAttributes)
            elog(ERROR, "invalid column number %d", attnum);
        values[attnum - 1] = replValues[i];
        isnull[attnum - 1] = replIsnull[i];
    }
 
    /*
     * create a new tuple from the values and isnull arrays
     */
    newTuple = heap_form_tuple(tupleDesc, values, isnull);
 
    pfree(values);
    pfree(isnull);
 
    /*
     * copy the identification info of the old tuple: t_ctid, t_self
     */
    newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
    newTuple->t_self = tuple->t_self;
    newTuple->t_tableOid = tuple->t_tableOid;
 
    return newTuple;
}

References attnum, elog, ERROR, fb(), heap_deform_tuple(), heap_form_tuple(), i, palloc_array, pfree(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, and values.

Referenced by autoinc(), check_modified_virtual_generated(), insert_username(), moddatetime(), relation_statistics_update(), and tsvector_update_trigger().

◆ heap_tuple_from_minimal_tuple()

HeapTuple heap_tuple_from_minimal_tuple ( MinimalTuple mtup )

extern

Definition at line 1501 of file heaptuple.c.

{
    HeapTuple   result;
    uint32      len = mtup->t_len + MINIMAL_TUPLE_OFFSET;
 
    result = (HeapTuple) palloc(HEAPTUPLESIZE + len);
    result->t_len = len;
    ItemPointerSetInvalid(&(result->t_self));
    result->t_tableOid = InvalidOid;
    result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
    memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
    memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
    return result;
}

References fb(), HEAPTUPLESIZE, InvalidOid, ItemPointerSetInvalid(), len, memcpy(), MINIMAL_TUPLE_OFFSET, palloc(), result, and HeapTupleData::t_len.

Referenced by tts_minimal_copy_heap_tuple().

◆ HEAP_XMAX_IS_EXCL_LOCKED()

static bool HEAP_XMAX_IS_EXCL_LOCKED ( uint16 infomask )

inlinestatic

Definition at line 269 of file htup_details.h.

Referenced by compute_new_xmax_infomask(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), and pgrowlocks().

◆ HEAP_XMAX_IS_KEYSHR_LOCKED()

static bool HEAP_XMAX_IS_KEYSHR_LOCKED ( uint16 infomask )

inlinestatic

Definition at line 275 of file htup_details.h.

Referenced by compute_new_xmax_infomask(), heap_inplace_lock(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), and pgrowlocks().

◆ HEAP_XMAX_IS_LOCKED_ONLY()

static bool HEAP_XMAX_IS_LOCKED_ONLY ( uint16 infomask )

inlinestatic

◆ HEAP_XMAX_IS_SHR_LOCKED()

static bool HEAP_XMAX_IS_SHR_LOCKED ( uint16 infomask )

inlinestatic

Definition at line 263 of file htup_details.h.

Referenced by compute_new_xmax_infomask(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), and pgrowlocks().

◆ HeapTupleAllFixed()

static bool HeapTupleAllFixed ( const HeapTupleData * tuple )

inlinestatic

Definition at line 742 of file htup_details.h.

{
    return (tuple->t_data->t_infomask & HEAP_HASVARWIDTH) != 0;
}
 

References HEAP_HASVARWIDTH, HeapTupleData::t_data, and HeapTupleHeaderData::t_infomask.

◆ HeapTupleClearHeapOnly()

static void HeapTupleClearHeapOnly ( const HeapTupleData * tuple )

inlinestatic

Definition at line 784 of file htup_details.h.

{
    HeapTupleHeaderSetHeapOnly(tuple->t_data);
}
 

References HeapTupleHeaderSetHeapOnly(), and HeapTupleData::t_data.

Referenced by heap_update().

◆ HeapTupleClearHotUpdated()

static void HeapTupleClearHotUpdated ( const HeapTupleData * tuple )

inlinestatic

Definition at line 766 of file htup_details.h.

{
    HeapTupleHeaderSetHotUpdated(tuple->t_data);
}
 

References HeapTupleHeaderSetHotUpdated(), and HeapTupleData::t_data.

Referenced by heap_update().

◆ HeapTupleHasExternal()

static bool HeapTupleHasExternal ( const HeapTupleData * tuple )

inlinestatic

Definition at line 748 of file htup_details.h.

{
    return !HeapTupleHasVarWidth(tuple);
}
 

References HeapTupleHasVarWidth().

Referenced by CatalogCacheCreateEntry(), check_domain_for_new_tuple(), expanded_record_set_tuple(), ExtractReplicaIdentity(), heap_abort_speculative(), heap_copy_tuple_as_datum(), heap_delete(), heap_prepare_insert(), heap_update(), and raw_heap_insert().

◆ HeapTupleHasNulls()

static bool HeapTupleHasNulls ( const HeapTupleData * tuple )

inlinestatic

Definition at line 724 of file htup_details.h.

Referenced by expand_tuple(), heap_deform_tuple(), HeapTupleHasVarWidth(), inv_getsize(), inv_read(), inv_truncate(), inv_write(), nocachegetattr(), and slot_deform_heap_tuple().

◆ HeapTupleHasVarWidth()

static bool HeapTupleHasVarWidth ( const HeapTupleData * tuple )

inlinestatic

Definition at line 736 of file htup_details.h.

{
    return !HeapTupleHasNulls(tuple);
}
 

References HeapTupleHasNulls().

Referenced by HeapTupleHasExternal(), and nocachegetattr().

◆ HeapTupleHeaderClearHeapOnly()

static void HeapTupleHeaderClearHeapOnly ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 553 of file htup_details.h.

{
    tup->t_infomask2 |= HEAP_ONLY_TUPLE;
}
 

References fb(), and HEAP_ONLY_TUPLE.

◆ HeapTupleHeaderClearHotUpdated()

static void HeapTupleHeaderClearHotUpdated ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 535 of file htup_details.h.

{
    tup->t_infomask2 |= HEAP_HOT_UPDATED;
}
 

References fb(), and HEAP_HOT_UPDATED.

Referenced by heap_delete(), heap_lock_tuple(), heap_xlog_delete(), heap_xlog_lock(), heap_xlog_update(), and HeapTupleIsHeapOnly().

◆ HeapTupleHeaderClearMatch()

static void HeapTupleHeaderClearMatch ( MinimalTupleData * tup )

inlinestatic

Definition at line 704 of file htup_details.h.

{
    tup->t_infomask2 |= HEAP_TUPLE_HAS_MATCH;
}
 

References fb(), HEAP_TUPLE_HAS_MATCH, and MinimalTupleData::t_infomask2.

Referenced by ExecHashSkewTableInsert(), ExecHashTableInsert(), ExecHashTableResetMatchFlags(), ExecParallelHashTableInsert(), and ExecParallelHashTableInsertCurrentBatch().

◆ HeapTupleHeaderGetDatumLength()

static uint32 HeapTupleHeaderGetDatumLength ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 478 of file htup_details.h.

{
    ItemPointerSetMovedPartitions(&tup->t_ctid);
}
 

References fb(), and ItemPointerSetMovedPartitions().

Referenced by composite_to_json(), composite_to_jsonb(), deconstruct_composite_datum(), exec_move_row_from_datum(), ExecEvalConvertRowtype(), ExecEvalFieldSelect(), ExecEvalFieldStoreDeForm(), ExecEvalRowNullInt(), ExecMakeTableFunctionResult(), ExecModifyTable(), ExecStoreHeapTupleDatum(), ExecuteCallStmt(), GetAttributeByName(), GetAttributeByNum(), hash_record(), hash_record_extended(), HeapTupleHeaderGetDatum(), hstore_from_record(), hstore_populate_record(), make_expanded_record_from_datum(), make_tuple_indirect(), plperl_hash_from_datum(), pltcl_func_handler(), PLyDict_FromComposite(), populate_record(), populate_recordset_record(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_out(), record_send(), and statext_expressions_load().

◆ HeapTupleHeaderGetRawCommandId()

static CommandId HeapTupleHeaderGetRawCommandId ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 401 of file htup_details.h.

Referenced by heap_getsysattr(), heap_page_items(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleSatisfiesHistoricMVCC(), and log_heap_new_cid().

◆ HeapTupleHeaderGetRawXmax()

static TransactionId HeapTupleHeaderGetRawXmax ( const HeapTupleHeaderData * tup )

inlinestatic

◆ HeapTupleHeaderGetRawXmin()

static TransactionId HeapTupleHeaderGetRawXmin ( const HeapTupleHeaderData * tup )

inlinestatic

◆ HeapTupleHeaderGetSpeculativeToken()

static BlockNumber HeapTupleHeaderGetSpeculativeToken ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 453 of file htup_details.h.

{
    return ItemPointerGetOffsetNumberNoCheck(&tup->t_ctid) == SpecTokenOffsetNumber;
}
 
static inline BlockNumber

References fb(), ItemPointerGetOffsetNumberNoCheck(), and SpecTokenOffsetNumber.

Referenced by HeapTupleSatisfiesDirty().

◆ HeapTupleHeaderGetTypeId()

static Oid HeapTupleHeaderGetTypeId ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 490 of file htup_details.h.

{
    SET_VARSIZE(tup, len);
}
 

References fb(), len, and SET_VARSIZE().

Referenced by composite_to_json(), composite_to_jsonb(), deconstruct_composite_datum(), exec_move_row_from_datum(), ExecEvalConvertRowtype(), ExecEvalFieldSelect(), ExecEvalRowNullInt(), ExecMakeTableFunctionResult(), ExecuteCallStmt(), get_expr_result_type(), GetAttributeByName(), GetAttributeByNum(), hash_record(), hash_record_extended(), HeapTupleHeaderGetDatum(), hstore_from_record(), hstore_populate_record(), make_expanded_record_from_datum(), make_tuple_indirect(), plperl_hash_from_datum(), pltcl_func_handler(), PLyDict_FromComposite(), populate_record_worker(), populate_recordset_worker(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_out(), and record_send().

◆ HeapTupleHeaderGetTypMod()

static int32 HeapTupleHeaderGetTypMod ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 502 of file htup_details.h.

{
    tup->t_choice.t_datum.datum_typeid = datum_typeid;
}
 

References fb().

Referenced by composite_to_json(), composite_to_jsonb(), deconstruct_composite_datum(), exec_move_row_from_datum(), ExecEvalFieldSelect(), ExecEvalRowNullInt(), ExecMakeTableFunctionResult(), ExecuteCallStmt(), get_expr_result_type(), GetAttributeByName(), GetAttributeByNum(), hash_record(), hash_record_extended(), HeapTupleHeaderGetDatum(), hstore_from_record(), hstore_populate_record(), make_expanded_record_from_datum(), make_tuple_indirect(), plperl_hash_from_datum(), pltcl_func_handler(), PLyDict_FromComposite(), populate_record_worker(), populate_recordset_worker(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_out(), and record_send().

◆ HeapTupleHeaderGetUpdateXid()

static TransactionId HeapTupleHeaderGetUpdateXid ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 383 of file htup_details.h.

{
    if (!((tup)->t_infomask & HEAP_XMAX_INVALID) &&
        ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) &&

References fb(), HEAP_XMAX_INVALID, HEAP_XMAX_IS_MULTI, HEAP_XMAX_LOCK_ONLY, HeapTupleGetUpdateXid(), and HeapTupleHeaderGetRawXmax().

Referenced by check_tuple_header(), heap_delete(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_prune_chain(), heap_prune_record_unchanged_lp_normal(), heap_update(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), heapam_scan_analyze_next_tuple(), heapam_tuple_lock(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetCmax(), HeapTupleSatisfiesVacuumHorizon(), logical_rewrite_heap_tuple(), rewrite_heap_tuple(), update_most_recent_deletion_info(), and verify_heapam().

◆ HeapTupleHeaderGetXmin()

static TransactionId HeapTupleHeaderGetXmin ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 324 of file htup_details.h.

{
    return tup->t_choice.t_heap.t_xmin;
}
 
static inline TransactionId

References fb().

Referenced by BitmapHeapScanNextBlock(), bt_check_every_level(), check_safe_enum_use(), check_tuple_visibility(), find_inheritance_children_extended(), get_relation_info(), heap_fetch(), heap_get_latest_tid(), heap_get_root_tuples(), heap_hot_search_buffer(), heap_index_delete_tuples(), heap_lock_updated_tuple_rec(), heap_page_would_be_all_visible(), heap_prepare_freeze_tuple(), heap_prune_chain(), heap_prune_record_unchanged_lp_normal(), heap_tuple_needs_eventual_freeze(), heap_tuple_should_freeze(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), heapam_scan_analyze_next_tuple(), heapam_tuple_lock(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetCmin(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesToast(), IsIndexUsableForFindingDeletedTuple(), logical_rewrite_heap_tuple(), RelationReloadIndexInfo(), rewrite_heap_dead_tuple(), rewrite_heap_tuple(), tuple_all_visible(), and verify_heapam().

◆ HeapTupleHeaderGetXvac()

static TransactionId HeapTupleHeaderGetXvac ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 428 of file htup_details.h.

434{

Referenced by check_tuple_visibility(), heap_prepare_freeze_tuple(), heap_tuple_needs_eventual_freeze(), heap_tuple_should_freeze(), HeapTupleCleanMoved(), and HeapTupleHeaderAdvanceConflictHorizon().

◆ HeapTupleHeaderHasMatch()

static bool HeapTupleHeaderHasMatch ( const MinimalTupleData * tup )

inlinestatic

Definition at line 692 of file htup_details.h.

Referenced by ExecHashJoinImpl(), ExecParallelScanHashTableForUnmatched(), and ExecScanHashTableForUnmatched().

◆ HeapTupleHeaderIndicatesMovedPartitions()

static bool HeapTupleHeaderIndicatesMovedPartitions ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 466 of file htup_details.h.

{
    ItemPointerSet(&tup->t_ctid, token, SpecTokenOffsetNumber);
}
 

References fb(), ItemPointerSet(), and SpecTokenOffsetNumber.

Referenced by heap_get_latest_tid(), heap_get_root_tuples(), heap_lock_updated_tuple_rec(), heap_prune_chain(), and rewrite_heap_tuple().

◆ HeapTupleHeaderIsHeapOnly()

static bool HeapTupleHeaderIsHeapOnly ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 541 of file htup_details.h.

{
    tup->t_infomask2 &= ~HEAP_HOT_UPDATED;
}
 

References fb().

Referenced by check_tuple_header(), heap_abort_speculative(), heap_get_root_tuples(), heap_page_prune_execute(), HeapTupleSetHeapOnly(), index_delete_check_htid(), page_verify_redirects(), prune_freeze_plan(), and verify_heapam().

◆ HeapTupleHeaderIsHotUpdated()

static bool HeapTupleHeaderIsHotUpdated ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 520 of file htup_details.h.

526{

References fb(), and HEAP_HOT_UPDATED.

Referenced by check_tuple_header(), heap_get_root_tuples(), heap_index_delete_tuples(), heap_prune_chain(), HeapTupleSetHotUpdated(), and prune_freeze_plan().

◆ HeapTupleHeaderIsSpeculative()

static bool HeapTupleHeaderIsSpeculative ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 447 of file htup_details.h.

Referenced by heap_abort_speculative(), heap_finish_speculative(), heap_mask(), heapam_tuple_lock(), HeapTupleSatisfiesDirty(), and RelationPutHeapTuple().

◆ HeapTupleHeaderSetCmax()

static void HeapTupleHeaderSetCmax	(	HeapTupleHeaderData *	tup,
		CommandId	cid,
		bool	iscombo
	)

inlinestatic

Definition at line 417 of file htup_details.h.

{
    Assert(!((tup)->t_infomask & HEAP_MOVED));
    tup->t_choice.t_heap.t_field3.t_cid = cid;

Referenced by heap_delete(), heap_update(), heap_xlog_delete(), heap_xlog_lock(), and heap_xlog_update().

◆ HeapTupleHeaderSetCmin()

static void HeapTupleHeaderSetCmin	(	HeapTupleHeaderData *	tup,
		CommandId	cid
	)

inlinestatic

Definition at line 408 of file htup_details.h.

Referenced by apply_returning_filter(), fill_seq_fork_with_data(), heap_prepare_insert(), heap_update(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), and make_tuple_from_result_row().

◆ HeapTupleHeaderSetDatumLength()

static void HeapTupleHeaderSetDatumLength	(	HeapTupleHeaderData *	tup,
		uint32	len
	)

inlinestatic

Definition at line 484 of file htup_details.h.

{
    return VARSIZE(tup);
}
 

References fb(), and VARSIZE().

Referenced by ER_flatten_into(), expand_tuple(), heap_copy_tuple_as_datum(), heap_form_tuple(), and toast_flatten_tuple_to_datum().

◆ HeapTupleHeaderSetHeapOnly()

static void HeapTupleHeaderSetHeapOnly ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 547 of file htup_details.h.

{
    return (tup->t_infomask2 & HEAP_ONLY_TUPLE) != 0;
}
 

References fb(), and HEAP_ONLY_TUPLE.

Referenced by HeapTupleClearHeapOnly().

◆ HeapTupleHeaderSetHotUpdated()

static void HeapTupleHeaderSetHotUpdated ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 529 of file htup_details.h.

Referenced by heap_xlog_update(), and HeapTupleClearHotUpdated().

◆ HeapTupleHeaderSetMatch()

static void HeapTupleHeaderSetMatch ( MinimalTupleData * tup )

inlinestatic

Definition at line 698 of file htup_details.h.

{
    return (tup->t_infomask2 & HEAP_TUPLE_HAS_MATCH) != 0;
}
 

References fb(), and HEAP_TUPLE_HAS_MATCH.

Referenced by ExecHashJoinImpl().

◆ HeapTupleHeaderSetMovedPartitions()

static void HeapTupleHeaderSetMovedPartitions ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 472 of file htup_details.h.

{
    return ItemPointerIndicatesMovedPartitions(&tup->t_ctid);
}
 

References fb(), and ItemPointerIndicatesMovedPartitions().

Referenced by heap_delete(), and heap_xlog_delete().

◆ HeapTupleHeaderSetSpeculativeToken()

static void HeapTupleHeaderSetSpeculativeToken	(	HeapTupleHeaderData *	tup,
		BlockNumber	token
	)

inlinestatic

Definition at line 460 of file htup_details.h.

Referenced by heapam_tuple_insert_speculative().

◆ HeapTupleHeaderSetTypeId()

static void HeapTupleHeaderSetTypeId	(	HeapTupleHeaderData *	tup,
		Oid	datum_typeid
	)

inlinestatic

Definition at line 496 of file htup_details.h.

{
    return tup->t_choice.t_datum.datum_typeid;
}
 

References fb().

Referenced by coerce_function_result_tuple(), ER_flatten_into(), ExecEvalWholeRowVar(), expand_tuple(), heap_copy_tuple_as_datum(), heap_form_tuple(), and toast_flatten_tuple_to_datum().

◆ HeapTupleHeaderSetTypMod()

static void HeapTupleHeaderSetTypMod	(	HeapTupleHeaderData *	tup,
		int32	typmod
	)

inlinestatic

Definition at line 508 of file htup_details.h.

{
    return tup->t_choice.t_datum.datum_typmod;
}
 

References fb().

Referenced by coerce_function_result_tuple(), ER_flatten_into(), ExecEvalWholeRowVar(), expand_tuple(), heap_copy_tuple_as_datum(), heap_form_tuple(), and toast_flatten_tuple_to_datum().

◆ HeapTupleHeaderSetXmax()

static void HeapTupleHeaderSetXmax	(	HeapTupleHeaderData *	tup,
		TransactionId	xid
	)

inlinestatic

Definition at line 369 of file htup_details.h.

{
    return tup->t_choice.t_heap.t_xmax;
}
 

References fb().

Referenced by apply_returning_filter(), fill_seq_fork_with_data(), heap_delete(), heap_execute_freeze_tuple(), heap_force_common(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_prepare_insert(), heap_update(), heap_xlog_delete(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_update(), make_tuple_from_result_row(), and read_seq_tuple().

◆ HeapTupleHeaderSetXmin()

static void HeapTupleHeaderSetXmin	(	HeapTupleHeaderData *	tup,
		TransactionId	xid
	)

inlinestatic

Definition at line 331 of file htup_details.h.

                            : HeapTupleHeaderGetRawXmin(tup);
}
 

Referenced by apply_returning_filter(), fill_seq_fork_with_data(), heap_abort_speculative(), heap_force_common(), heap_prepare_insert(), heap_update(), heap_xlog_delete(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), make_tuple_from_result_row(), and RelationReloadIndexInfo().

◆ HeapTupleHeaderSetXminFrozen()

static void HeapTupleHeaderSetXminFrozen ( HeapTupleHeaderData * tup )

inlinestatic

Definition at line 356 of file htup_details.h.

{
    return (tup->t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN;
}
 
static inline void

References fb(), and HEAP_XMIN_FROZEN.

Referenced by fill_seq_fork_with_data(), and heap_prepare_insert().

◆ HeapTupleHeaderSetXvac()

static void HeapTupleHeaderSetXvac	(	HeapTupleHeaderData *	tup,
		TransactionId	xid
	)

inlinestatic

Definition at line 437 of file htup_details.h.

Referenced by heap_execute_freeze_tuple(), and heap_force_common().

◆ HeapTupleHeaderXminCommitted()

static bool HeapTupleHeaderXminCommitted ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 337 of file htup_details.h.

{
    tup->t_choice.t_heap.t_xmin = xid;
}
 

References fb().

Referenced by check_safe_enum_use(), check_tuple_visibility(), heap_page_would_be_all_visible(), heap_prune_record_unchanged_lp_normal(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), and HeapTupleSatisfiesVacuumHorizon().

◆ HeapTupleHeaderXminFrozen()

static bool HeapTupleHeaderXminFrozen ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 350 of file htup_details.h.

Referenced by heap_mask(), heap_pre_freeze_checks(), heap_xlog_insert(), and HeapTupleSatisfiesMVCC().

◆ HeapTupleHeaderXminInvalid()

static bool HeapTupleHeaderXminInvalid ( const HeapTupleHeaderData * tup )

inlinestatic

Definition at line 343 of file htup_details.h.

{
    return (tup->t_infomask & HEAP_XMIN_COMMITTED) != 0;
}
 
static inline bool

References fb(), and HEAP_XMIN_COMMITTED.

Referenced by check_tuple_visibility(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVacuumHorizon(), and log_heap_new_cid().

◆ HeapTupleIsHeapOnly()

static bool HeapTupleIsHeapOnly ( const HeapTupleData * tuple )

inlinestatic

Definition at line 772 of file htup_details.h.

{
    HeapTupleHeaderClearHotUpdated(tuple->t_data);
}
 

References HeapTupleHeaderClearHotUpdated(), and HeapTupleData::t_data.

Referenced by CatalogIndexInsert(), heap_hot_search_buffer(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_tuple_update(), and log_heap_update().

◆ HeapTupleIsHotUpdated()

static bool HeapTupleIsHotUpdated ( const HeapTupleData * tuple )

inlinestatic

Definition at line 754 of file htup_details.h.

{
    return (tuple->t_data->t_infomask & HEAP_HASEXTERNAL) != 0;
}
 

References HEAP_HASEXTERNAL, HeapTupleData::t_data, and HeapTupleHeaderData::t_infomask.

Referenced by heap_hot_search_buffer(), and heapam_index_build_range_scan().

◆ HeapTupleNoNulls()

static bool HeapTupleNoNulls ( const HeapTupleData * tuple )

inlinestatic

Definition at line 730 of file htup_details.h.

{
    return (tuple->t_data->t_infomask & HEAP_HASNULL) != 0;
}
 

References HEAP_HASNULL, HeapTupleData::t_data, and HeapTupleHeaderData::t_infomask.

Referenced by fastgetattr(), and heap_attisnull().

◆ HeapTupleSetHeapOnly()

static void HeapTupleSetHeapOnly ( const HeapTupleData * tuple )

inlinestatic

Definition at line 778 of file htup_details.h.

{
    return HeapTupleHeaderIsHeapOnly(tuple->t_data);
}
 

References HeapTupleHeaderIsHeapOnly(), and HeapTupleData::t_data.

Referenced by heap_update().

◆ HeapTupleSetHotUpdated()

static void HeapTupleSetHotUpdated ( const HeapTupleData * tuple )

inlinestatic

Definition at line 760 of file htup_details.h.

{
    return HeapTupleHeaderIsHotUpdated(tuple->t_data);
}
 

References HeapTupleHeaderIsHotUpdated(), and HeapTupleData::t_data.

Referenced by heap_update().

◆ minimal_expand_tuple()

MinimalTuple minimal_expand_tuple	(	HeapTuple	sourceTuple,
		TupleDesc	tupleDesc
	)

extern

Definition at line 962 of file heaptuple.c.

{
    MinimalTuple minimalTuple;
 
    expand_tuple(NULL, &minimalTuple, sourceTuple, tupleDesc);
    return minimalTuple;
}

References expand_tuple(), and fb().

◆ minimal_tuple_from_heap_tuple()

MinimalTuple minimal_tuple_from_heap_tuple	(	HeapTuple	htup,
		Size	extra
	)

extern

Definition at line 1523 of file heaptuple.c.

{
    MinimalTuple result;
    char       *mem;
    uint32      len;
 
    Assert(extra == MAXALIGN(extra));
    Assert(htup->t_len > MINIMAL_TUPLE_OFFSET);
    len = htup->t_len - MINIMAL_TUPLE_OFFSET;
    mem = palloc(len + extra);
    memset(mem, 0, extra);
    result = (MinimalTuple) (mem + extra);
    memcpy(result, (char *) htup->t_data + MINIMAL_TUPLE_OFFSET, len);
 
    result->t_len = len;
    return result;
}

References Assert, fb(), len, MAXALIGN, memcpy(), MINIMAL_TUPLE_OFFSET, palloc(), result, HeapTupleData::t_data, and HeapTupleData::t_len.

Referenced by copytup_heap(), tts_buffer_heap_copy_minimal_tuple(), and tts_heap_copy_minimal_tuple().

◆ nocachegetattr()

Datum nocachegetattr	(	HeapTuple	tup,
		int	attnum,
		TupleDesc	tupleDesc
	)

extern

Definition at line 509 of file heaptuple.c.

{
    CompactAttribute *cattr;
    HeapTupleHeader td = tup->t_data;
    char       *tp;             /* ptr to data part of tuple */
    uint8      *bp = td->t_bits;    /* ptr to null bitmap in tuple */
    int         off;            /* current offset within data */
    int         startAttr;
    int         firstNullAttr;
    int         i;
    bool        hasnulls = HeapTupleHasNulls(tup);
 
    /* Did someone forget to call TupleDescFinalize()? */
    Assert(tupleDesc->firstNonCachedOffsetAttr >= 0);
 
    attnum--;
 
    /*
     * To minimize the number of attributes we need to look at, start walking
     * the tuple at the attribute with the highest attcacheoff prior to attnum
     * or the first NULL attribute prior to attnum, whichever comes first.
     */
    if (hasnulls)
        firstNullAttr = first_null_attr(bp, attnum);
    else
        firstNullAttr = attnum;
 
    if (tupleDesc->firstNonCachedOffsetAttr > 0 && firstNullAttr > 0)
    {
        /*
         * Try to start with the highest attribute with an attcacheoff that's
         * prior to the one we're looking for, or with the attribute prior to
         * the first NULL attribute, if there is one.
         */
        startAttr = Min(tupleDesc->firstNonCachedOffsetAttr - 1, firstNullAttr - 1);
        off = TupleDescCompactAttr(tupleDesc, startAttr)->attcacheoff;
    }
    else
    {
        /* Otherwise, start at the beginning... */
        startAttr = 0;
        off = 0;
    }
 
    tp = (char *) td + td->t_hoff;
 
    /*
     * Calculate 'off' up to the first NULL attr.  We use two cheaper loops
     * when the tuple has no variable-width columns.  When variable-width
     * columns exists, we use att_addlength_pointer() to move the offset
     * beyond the current attribute.
     */
    if (!HeapTupleHasVarWidth(tup))
    {
        for (i = startAttr; i < firstNullAttr; i++)
        {
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            off = att_nominal_alignby(off, cattr->attalignby);
            off += cattr->attlen;
        }
 
        for (; i < attnum; i++)
        {
            if (att_isnull(i, bp))
                continue;
 
            cattr = TupleDescCompactAttr(tupleDesc, i);
 
            off = att_nominal_alignby(off, cattr->attalignby);
            off += cattr->attlen;
        }
    }
    else
    {
        for (i = startAttr; i < firstNullAttr; i++)
        {
            int         attlen;
 
            cattr = TupleDescCompactAttr(tupleDesc, i);
            attlen = cattr->attlen;
            off = att_pointer_alignby(off,
                                      cattr->attalignby,
                                      attlen,
                                      tp + off);
            off = att_addlength_pointer(off, attlen, tp + off);
        }
 
        for (; i < attnum; i++)
        {
            int         attlen;
 
            if (att_isnull(i, bp))
                continue;
 
            cattr = TupleDescCompactAttr(tupleDesc, i);
            attlen = cattr->attlen;
            off = att_pointer_alignby(off, cattr->attalignby, attlen,
                                      tp + off);
            off = att_addlength_pointer(off, attlen, tp + off);
        }
    }
 
    cattr = TupleDescCompactAttr(tupleDesc, attnum);
    off = att_pointer_alignby(off,
                              cattr->attalignby,
                              cattr->attlen,
                              tp + off);
 
    return fetchatt(cattr, tp + off);
}

References Assert, att_addlength_pointer, att_isnull(), att_nominal_alignby, att_pointer_alignby, CompactAttribute::attcacheoff, attlen, attnum, fb(), fetchatt, first_null_attr(), HeapTupleHasNulls(), HeapTupleHasVarWidth(), i, Min, HeapTupleHeaderData::t_bits, HeapTupleHeaderData::t_hoff, and TupleDescCompactAttr().

Referenced by fastgetattr().

◆ StaticAssertDecl()

StaticAssertDecl ( )

References Assert, fb(), and HEAP_MOVED.

◆ varsize_any()

size_t varsize_any ( void * p )

extern

Definition at line 1546 of file heaptuple.c.

{
    return VARSIZE_ANY(p);
}

References VARSIZE_ANY().

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ FIELDNO_HEAPTUPLEHEADERDATA_BITS

◆ FIELDNO_HEAPTUPLEHEADERDATA_HOFF

◆ FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK

◆ FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2

◆ HEAP2_XACT_MASK

◆ HEAP_COMBOCID

◆ HEAP_HASEXTERNAL

◆ HEAP_HASNULL

◆ HEAP_HASOID_OLD

◆ HEAP_HASVARWIDTH

◆ HEAP_HOT_UPDATED

◆ HEAP_KEYS_UPDATED

◆ HEAP_LOCK_MASK

◆ HEAP_MOVED

◆ HEAP_MOVED_IN

◆ HEAP_MOVED_OFF

◆ HEAP_NATTS_MASK

◆ HEAP_ONLY_TUPLE

◆ HEAP_TUPLE_HAS_MATCH

◆ HEAP_UPDATED

◆ HEAP_XACT_MASK

◆ HEAP_XMAX_BITS

◆ HEAP_XMAX_COMMITTED

◆ HEAP_XMAX_EXCL_LOCK

◆ HEAP_XMAX_INVALID

◆ HEAP_XMAX_IS_MULTI

◆ HEAP_XMAX_KEYSHR_LOCK

◆ HEAP_XMAX_LOCK_ONLY

◆ HEAP_XMAX_SHR_LOCK

◆ HEAP_XMIN_COMMITTED

◆ HEAP_XMIN_FROZEN

◆ HEAP_XMIN_INVALID

◆ HeapTupleHeaderGetNatts

◆ HeapTupleHeaderHasExternal

◆ HeapTupleHeaderSetNatts

◆ MaxAttrSize

◆ MaxHeapAttributeNumber

◆ MaxHeapTupleSize

◆ MaxHeapTuplesPerPage

◆ MaxTupleAttributeNumber

◆ MinHeapTupleSize

◆ MINIMAL_TUPLE_DATA_OFFSET

◆ MINIMAL_TUPLE_OFFSET

◆ MINIMAL_TUPLE_PADDING

◆ SizeofHeapTupleHeader

◆ SizeofMinimalTupleHeader

Typedef Documentation

◆ DatumTupleFields

◆ HeapTupleFields

Function Documentation

◆ BITMAPLEN()

◆ fastgetattr()

◆ getmissingattr()

◆ GETSTRUCT()

◆ heap_attisnull()

◆ heap_compute_data_size()

◆ heap_copy_minimal_tuple()

◆ heap_copy_tuple_as_datum()

◆ heap_copytuple()

◆ heap_copytuple_with_tuple()

◆ heap_deform_tuple()

◆ heap_expand_tuple()

◆ heap_fill_tuple()

◆ heap_form_minimal_tuple()

◆ heap_form_tuple()

◆ heap_free_minimal_tuple()

◆ heap_freetuple()

◆ heap_getattr()

◆ heap_getsysattr()

◆ HEAP_LOCKED_UPGRADED()

◆ heap_modify_tuple()

◆ heap_modify_tuple_by_cols()

◆ heap_tuple_from_minimal_tuple()

◆ HEAP_XMAX_IS_EXCL_LOCKED()

◆ HEAP_XMAX_IS_KEYSHR_LOCKED()