htup_details.h File Reference

#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_IS_LOCKED_ONLY(infomask)
#define	HEAP_LOCKED_UPGRADED(infomask)
#define	HEAP_XMAX_IS_SHR_LOCKED(infomask)    (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK)
#define	HEAP_XMAX_IS_EXCL_LOCKED(infomask)    (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK)
#define	HEAP_XMAX_IS_KEYSHR_LOCKED(infomask)    (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK)
#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	HeapTupleHeaderGetRawXmin(tup)
#define	HeapTupleHeaderGetXmin(tup)
#define	HeapTupleHeaderSetXmin(tup, xid)
#define	HeapTupleHeaderXminCommitted(tup)
#define	HeapTupleHeaderXminInvalid(tup)
#define	HeapTupleHeaderXminFrozen(tup)
#define	HeapTupleHeaderSetXminCommitted(tup)
#define	HeapTupleHeaderSetXminInvalid(tup)
#define	HeapTupleHeaderSetXminFrozen(tup)
#define	HeapTupleHeaderGetUpdateXid(tup)
#define	HeapTupleHeaderGetRawXmax(tup)
#define	HeapTupleHeaderSetXmax(tup, xid)
#define	HeapTupleHeaderGetRawCommandId(tup)
#define	HeapTupleHeaderSetCmin(tup, cid)
#define	HeapTupleHeaderSetCmax(tup, cid, iscombo)
#define	HeapTupleHeaderGetXvac(tup)
#define	HeapTupleHeaderSetXvac(tup, xid)
#define	HeapTupleHeaderIsSpeculative(tup)
#define	HeapTupleHeaderGetSpeculativeToken(tup)
#define	HeapTupleHeaderSetSpeculativeToken(tup, token)
#define	HeapTupleHeaderIndicatesMovedPartitions(tup)    ItemPointerIndicatesMovedPartitions(&(tup)->t_ctid)
#define	HeapTupleHeaderSetMovedPartitions(tup)    ItemPointerSetMovedPartitions(&(tup)->t_ctid)
#define	HeapTupleHeaderGetDatumLength(tup)    VARSIZE(tup)
#define	HeapTupleHeaderSetDatumLength(tup, len)    SET_VARSIZE(tup, len)
#define	HeapTupleHeaderGetTypeId(tup)
#define	HeapTupleHeaderSetTypeId(tup, typeid)
#define	HeapTupleHeaderGetTypMod(tup)
#define	HeapTupleHeaderSetTypMod(tup, typmod)
#define	HeapTupleHeaderIsHotUpdated(tup)
#define	HeapTupleHeaderSetHotUpdated(tup)
#define	HeapTupleHeaderClearHotUpdated(tup)
#define	HeapTupleHeaderIsHeapOnly(tup)
#define	HeapTupleHeaderSetHeapOnly(tup)
#define	HeapTupleHeaderClearHeapOnly(tup)
#define	HeapTupleHeaderHasMatch(tup)
#define	HeapTupleHeaderSetMatch(tup)
#define	HeapTupleHeaderClearMatch(tup)
#define	HeapTupleHeaderGetNatts(tup)    ((tup)->t_infomask2 & HEAP_NATTS_MASK)
#define	HeapTupleHeaderSetNatts(tup, natts)
#define	HeapTupleHeaderHasExternal(tup)    (((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)
#define	BITMAPLEN(NATTS)   (((int)(NATTS) + 7) / 8)
#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)
#define	GETSTRUCT(TUP)   ((char *) ((TUP)->t_data) + (TUP)->t_data->t_hoff)
#define	HeapTupleHasNulls(tuple)    (((tuple)->t_data->t_infomask & HEAP_HASNULL) != 0)
#define	HeapTupleNoNulls(tuple)    (!((tuple)->t_data->t_infomask & HEAP_HASNULL))
#define	HeapTupleHasVarWidth(tuple)    (((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH) != 0)
#define	HeapTupleAllFixed(tuple)    (!((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH))
#define	HeapTupleHasExternal(tuple)    (((tuple)->t_data->t_infomask & HEAP_HASEXTERNAL) != 0)
#define	HeapTupleIsHotUpdated(tuple)    HeapTupleHeaderIsHotUpdated((tuple)->t_data)
#define	HeapTupleSetHotUpdated(tuple)    HeapTupleHeaderSetHotUpdated((tuple)->t_data)
#define	HeapTupleClearHotUpdated(tuple)    HeapTupleHeaderClearHotUpdated((tuple)->t_data)
#define	HeapTupleIsHeapOnly(tuple)    HeapTupleHeaderIsHeapOnly((tuple)->t_data)
#define	HeapTupleSetHeapOnly(tuple)    HeapTupleHeaderSetHeapOnly((tuple)->t_data)
#define	HeapTupleClearHeapOnly(tuple)    HeapTupleHeaderClearHeapOnly((tuple)->t_data)

Typedefs
typedef struct HeapTupleFields	HeapTupleFields
typedef struct DatumTupleFields	DatumTupleFields

Functions
	StaticAssertDecl (MaxOffsetNumber< SpecTokenOffsetNumber, "invalid speculative token constant")
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, bits8 *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)
void	heap_free_minimal_tuple (MinimalTuple mtup)
MinimalTuple	heap_copy_minimal_tuple (MinimalTuple mtup)
HeapTuple	heap_tuple_from_minimal_tuple (MinimalTuple mtup)
MinimalTuple	minimal_tuple_from_heap_tuple (HeapTuple htup)
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

BITMAPLEN

#define BITMAPLEN

(

NATTS

)

(((int)(NATTS) + 7) / 8)

Definition at line 545 of file htup_details.h.

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.

GETSTRUCT

#define GETSTRUCT

(

TUP

)

((char *) ((TUP)->t_data) + (TUP)->t_data->t_hoff)

Definition at line 653 of file htup_details.h.

HEAP2_XACT_MASK

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

Definition at line 279 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 276 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 275 of file htup_details.h.

HEAP_LOCK_MASK

#define HEAP_LOCK_MASK

Value:

                         (HEAP_XMAX_SHR_LOCK | HEAP_XMAX_EXCL_LOCK | \
                         HEAP_XMAX_KEYSHR_LOCK)

Definition at line 202 of file htup_details.h.

HEAP_LOCKED_UPGRADED

#define HEAP_LOCKED_UPGRADED

(

infomask

)

Value:

( \
     ((infomask) & HEAP_XMAX_IS_MULTI) != 0 && \
     ((infomask) & HEAP_XMAX_LOCK_ONLY) != 0 && \
     (((infomask) & (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)) == 0) \
)

Definition at line 249 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 273 of file htup_details.h.

HEAP_ONLY_TUPLE

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

Definition at line 277 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 287 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)

Definition at line 267 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_EXCL_LOCKED

#define HEAP_XMAX_IS_EXCL_LOCKED

(

infomask

)

(((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK)

Definition at line 261 of file htup_details.h.

HEAP_XMAX_IS_KEYSHR_LOCKED

#define HEAP_XMAX_IS_KEYSHR_LOCKED

(

infomask

)

(((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK)

Definition at line 263 of file htup_details.h.

HEAP_XMAX_IS_LOCKED_ONLY

#define HEAP_XMAX_IS_LOCKED_ONLY

(

infomask

)

Value:

    (((infomask) & HEAP_XMAX_LOCK_ONLY) || \
     (((infomask) & (HEAP_XMAX_IS_MULTI | HEAP_LOCK_MASK)) == HEAP_XMAX_EXCL_LOCK))

Definition at line 227 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_IS_SHR_LOCKED

#define HEAP_XMAX_IS_SHR_LOCKED

(

infomask

)

(((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK)

Definition at line 259 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.

HeapTupleAllFixed

#define HeapTupleAllFixed

(

tuple

)

(!((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH))

Definition at line 668 of file htup_details.h.

HeapTupleClearHeapOnly

#define HeapTupleClearHeapOnly

(

tuple

)

HeapTupleHeaderClearHeapOnly((tuple)->t_data)

Definition at line 689 of file htup_details.h.

HeapTupleClearHotUpdated

#define HeapTupleClearHotUpdated

(

tuple

)

HeapTupleHeaderClearHotUpdated((tuple)->t_data)

Definition at line 680 of file htup_details.h.

HeapTupleHasExternal

#define HeapTupleHasExternal

(

tuple

)

(((tuple)->t_data->t_infomask & HEAP_HASEXTERNAL) != 0)

Definition at line 671 of file htup_details.h.

HeapTupleHasNulls

#define HeapTupleHasNulls

(

tuple

)

(((tuple)->t_data->t_infomask & HEAP_HASNULL) != 0)

Definition at line 659 of file htup_details.h.

HeapTupleHasVarWidth

#define HeapTupleHasVarWidth

(

tuple

)

(((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH) != 0)

Definition at line 665 of file htup_details.h.

HeapTupleHeaderClearHeapOnly

#define HeapTupleHeaderClearHeapOnly

(

tup

)

Value:

( \
  (tup)->t_infomask2 &= ~HEAP_ONLY_TUPLE \
)

Definition at line 509 of file htup_details.h.

HeapTupleHeaderClearHotUpdated

#define HeapTupleHeaderClearHotUpdated

(

tup

)

Value:

( \
    (tup)->t_infomask2 &= ~HEAP_HOT_UPDATED \
)

Definition at line 494 of file htup_details.h.

HeapTupleHeaderClearMatch

#define HeapTupleHeaderClearMatch

(

tup

)

Value:

( \
  (tup)->t_infomask2 &= ~HEAP_TUPLE_HAS_MATCH \
)

Definition at line 524 of file htup_details.h.

HeapTupleHeaderGetDatumLength

#define HeapTupleHeaderGetDatumLength

(

tup

)

VARSIZE(tup)

Definition at line 450 of file htup_details.h.

HeapTupleHeaderGetNatts

#define HeapTupleHeaderGetNatts

(

tup

)

((tup)->t_infomask2 & HEAP_NATTS_MASK)

Definition at line 529 of file htup_details.h.

HeapTupleHeaderGetRawCommandId

#define HeapTupleHeaderGetRawCommandId

(

tup

)

Value:

( \
    (tup)->t_choice.t_heap.t_field3.t_cid \
)

Definition at line 387 of file htup_details.h.

HeapTupleHeaderGetRawXmax

#define HeapTupleHeaderGetRawXmax

(

tup

)

Value:

( \
    (tup)->t_choice.t_heap.t_xmax \
)

Definition at line 371 of file htup_details.h.

HeapTupleHeaderGetRawXmin

#define HeapTupleHeaderGetRawXmin

(

tup

)

Value:

( \
    (tup)->t_choice.t_heap.t_xmin \
)

Definition at line 304 of file htup_details.h.

HeapTupleHeaderGetSpeculativeToken

#define HeapTupleHeaderGetSpeculativeToken

(

tup

)

Value:

( \
    AssertMacro(HeapTupleHeaderIsSpeculative(tup)), \
    ItemPointerGetBlockNumber(&(tup)->t_ctid) \
)

Definition at line 433 of file htup_details.h.

HeapTupleHeaderGetTypeId

#define HeapTupleHeaderGetTypeId

(

tup

)

Value:

( \
    (tup)->t_choice.t_datum.datum_typeid \
)

Definition at line 456 of file htup_details.h.

HeapTupleHeaderGetTypMod

#define HeapTupleHeaderGetTypMod

(

tup

)

Value:

( \
    (tup)->t_choice.t_datum.datum_typmod \
)

Definition at line 466 of file htup_details.h.

HeapTupleHeaderGetUpdateXid

#define HeapTupleHeaderGetUpdateXid

(

tup

)

Value:

( \
    (!((tup)->t_infomask & HEAP_XMAX_INVALID) && \
     ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) && \
     !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
        HeapTupleGetUpdateXid(tup) \
    : \
        HeapTupleHeaderGetRawXmax(tup) \
)

Definition at line 361 of file htup_details.h.

HeapTupleHeaderGetXmin

#define HeapTupleHeaderGetXmin

(

tup

)

Value:

( \
    HeapTupleHeaderXminFrozen(tup) ? \
        FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
)

Definition at line 309 of file htup_details.h.

HeapTupleHeaderGetXvac

#define HeapTupleHeaderGetXvac

(

tup

)

Value:

( \
    ((tup)->t_infomask & HEAP_MOVED) ? \
        (tup)->t_choice.t_heap.t_field3.t_xvac \
    : \
        InvalidTransactionId \
)

Definition at line 411 of file htup_details.h.

HeapTupleHeaderHasExternal

#define HeapTupleHeaderHasExternal

(

tup

)

(((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)

Definition at line 537 of file htup_details.h.

HeapTupleHeaderHasMatch

#define HeapTupleHeaderHasMatch

(

tup

)

Value:

( \
  ((tup)->t_infomask2 & HEAP_TUPLE_HAS_MATCH) != 0 \
)

Definition at line 514 of file htup_details.h.

HeapTupleHeaderIndicatesMovedPartitions

#define HeapTupleHeaderIndicatesMovedPartitions

(

tup

)

ItemPointerIndicatesMovedPartitions(&(tup)->t_ctid)

Definition at line 444 of file htup_details.h.

HeapTupleHeaderIsHeapOnly

#define HeapTupleHeaderIsHeapOnly

(

tup

)

Value:

( \
  ((tup)->t_infomask2 & HEAP_ONLY_TUPLE) != 0 \
)

Definition at line 499 of file htup_details.h.

HeapTupleHeaderIsHotUpdated

#define HeapTupleHeaderIsHotUpdated

(

tup

)

Value:

( \
    ((tup)->t_infomask2 & HEAP_HOT_UPDATED) != 0 && \
    ((tup)->t_infomask & HEAP_XMAX_INVALID) == 0 && \
    !HeapTupleHeaderXminInvalid(tup) \
)

Definition at line 482 of file htup_details.h.

HeapTupleHeaderIsSpeculative

#define HeapTupleHeaderIsSpeculative

(

tup

)

Value:

( \
    (ItemPointerGetOffsetNumberNoCheck(&(tup)->t_ctid) == SpecTokenOffsetNumber) \
)

Definition at line 428 of file htup_details.h.

HeapTupleHeaderSetCmax

#define HeapTupleHeaderSetCmax	(		tup,
			cid,
			iscombo
	)

Value:

do { \
    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; \
} while (0)

Definition at line 401 of file htup_details.h.

HeapTupleHeaderSetCmin

#define HeapTupleHeaderSetCmin	(		tup,
			cid
	)

Value:

do { \
    Assert(!((tup)->t_infomask & HEAP_MOVED)); \
    (tup)->t_choice.t_heap.t_field3.t_cid = (cid); \
    (tup)->t_infomask &= ~HEAP_COMBOCID; \
} while (0)

Definition at line 393 of file htup_details.h.

HeapTupleHeaderSetDatumLength

#define HeapTupleHeaderSetDatumLength	(		tup,
			len
	)		SET_VARSIZE(tup, len)

Definition at line 453 of file htup_details.h.

HeapTupleHeaderSetHeapOnly

#define HeapTupleHeaderSetHeapOnly

(

tup

)

Value:

( \
  (tup)->t_infomask2 |= HEAP_ONLY_TUPLE \
)

Definition at line 504 of file htup_details.h.

HeapTupleHeaderSetHotUpdated

#define HeapTupleHeaderSetHotUpdated

(

tup

)

Value:

( \
    (tup)->t_infomask2 |= HEAP_HOT_UPDATED \
)

Definition at line 489 of file htup_details.h.

HeapTupleHeaderSetMatch

#define HeapTupleHeaderSetMatch

(

tup

)

Value:

( \
  (tup)->t_infomask2 |= HEAP_TUPLE_HAS_MATCH \
)

Definition at line 519 of file htup_details.h.

HeapTupleHeaderSetMovedPartitions

#define HeapTupleHeaderSetMovedPartitions

(

tup

)

ItemPointerSetMovedPartitions(&(tup)->t_ctid)

Definition at line 447 of file htup_details.h.

HeapTupleHeaderSetNatts

#define HeapTupleHeaderSetNatts	(		tup,
			natts
	)

Value:

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

Definition at line 532 of file htup_details.h.

HeapTupleHeaderSetSpeculativeToken

#define HeapTupleHeaderSetSpeculativeToken	(		tup,
			token
	)

Value:

( \
    ItemPointerSet(&(tup)->t_ctid, token, SpecTokenOffsetNumber) \
)

Definition at line 439 of file htup_details.h.

HeapTupleHeaderSetTypeId

#define HeapTupleHeaderSetTypeId	(		tup,
			typeid
	)

Value:

( \
    (tup)->t_choice.t_datum.datum_typeid = (typeid) \
)

Definition at line 461 of file htup_details.h.

HeapTupleHeaderSetTypMod

#define HeapTupleHeaderSetTypMod	(		tup,
			typmod
	)

Value:

( \
    (tup)->t_choice.t_datum.datum_typmod = (typmod) \
)

Definition at line 471 of file htup_details.h.

HeapTupleHeaderSetXmax

#define HeapTupleHeaderSetXmax	(		tup,
			xid
	)

Value:

( \
    (tup)->t_choice.t_heap.t_xmax = (xid) \
)

Definition at line 376 of file htup_details.h.

HeapTupleHeaderSetXmin

#define HeapTupleHeaderSetXmin	(		tup,
			xid
	)

Value:

( \
    (tup)->t_choice.t_heap.t_xmin = (xid) \
)

Definition at line 315 of file htup_details.h.

HeapTupleHeaderSetXminCommitted

#define HeapTupleHeaderSetXminCommitted

(

tup

)

Value:

( \
    AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
    ((tup)->t_infomask |= HEAP_XMIN_COMMITTED) \
)

Definition at line 336 of file htup_details.h.

HeapTupleHeaderSetXminFrozen

#define HeapTupleHeaderSetXminFrozen

(

tup

)

Value:

( \
    AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
    ((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
)

Definition at line 348 of file htup_details.h.

HeapTupleHeaderSetXminInvalid

#define HeapTupleHeaderSetXminInvalid

(

tup

)

Value:

( \
    AssertMacro(!HeapTupleHeaderXminCommitted(tup)), \
    ((tup)->t_infomask |= HEAP_XMIN_INVALID) \
)

Definition at line 342 of file htup_details.h.

HeapTupleHeaderSetXvac

#define HeapTupleHeaderSetXvac	(		tup,
			xid
	)

Value:

do { \
    Assert((tup)->t_infomask & HEAP_MOVED); \
    (tup)->t_choice.t_heap.t_field3.t_xvac = (xid); \
} while (0)

Definition at line 419 of file htup_details.h.

HeapTupleHeaderXminCommitted

#define HeapTupleHeaderXminCommitted

(

tup

)

Value:

( \
    ((tup)->t_infomask & HEAP_XMIN_COMMITTED) != 0 \
)

Definition at line 320 of file htup_details.h.

HeapTupleHeaderXminFrozen

#define HeapTupleHeaderXminFrozen

(

tup

)

Value:

( \
    ((tup)->t_infomask & (HEAP_XMIN_FROZEN)) == HEAP_XMIN_FROZEN \
)

Definition at line 331 of file htup_details.h.

HeapTupleHeaderXminInvalid

#define HeapTupleHeaderXminInvalid

(

tup

)

Value:

( \
    ((tup)->t_infomask & (HEAP_XMIN_COMMITTED|HEAP_XMIN_INVALID)) == \
        HEAP_XMIN_INVALID \
)

Definition at line 325 of file htup_details.h.

HeapTupleIsHeapOnly

#define HeapTupleIsHeapOnly

(

tuple

)

HeapTupleHeaderIsHeapOnly((tuple)->t_data)

Definition at line 683 of file htup_details.h.

HeapTupleIsHotUpdated

#define HeapTupleIsHotUpdated

(

tuple

)

HeapTupleHeaderIsHotUpdated((tuple)->t_data)

Definition at line 674 of file htup_details.h.

HeapTupleNoNulls

#define HeapTupleNoNulls

(

tuple

)

(!((tuple)->t_data->t_infomask & HEAP_HASNULL))

Definition at line 662 of file htup_details.h.

HeapTupleSetHeapOnly

#define HeapTupleSetHeapOnly

(

tuple

)

HeapTupleHeaderSetHeapOnly((tuple)->t_data)

Definition at line 686 of file htup_details.h.

HeapTupleSetHotUpdated

#define HeapTupleSetHotUpdated

(

tuple

)

HeapTupleHeaderSetHotUpdated((tuple)->t_data)

Definition at line 677 of file htup_details.h.

MaxAttrSize

#define MaxAttrSize   (10 * 1024 * 1024)

Definition at line 583 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 558 of file htup_details.h.

MaxHeapTuplesPerPage

#define MaxHeapTuplesPerPage

Value:

    ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
            (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))))

Definition at line 572 of file htup_details.h.

MaxTupleAttributeNumber

#define MaxTupleAttributeNumber   1664 /* 8 * 208 */

Definition at line 34 of file htup_details.h.

MinHeapTupleSize

#define MinHeapTupleSize   MAXALIGN(SizeofHeapTupleHeader)

Definition at line 559 of file htup_details.h.

MINIMAL_TUPLE_DATA_OFFSET

#define MINIMAL_TUPLE_DATA_OFFSET    offsetof(MinimalTupleData, t_infomask2)

Definition at line 621 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 617 of file htup_details.h.

MINIMAL_TUPLE_PADDING

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

Definition at line 619 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 647 of file htup_details.h.

Typedef Documentation

DatumTupleFields

typedef struct DatumTupleFields DatumTupleFields

HeapTupleFields

typedef struct HeapTupleFields HeapTupleFields

Function Documentation

fastgetattr()

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

inlinestatic

Definition at line 749 of file htup_details.h.

{
    Assert(attnum > 0);
 
    *isnull = false;
    if (HeapTupleNoNulls(tup))
    {
        Form_pg_attribute att;
 
        att = TupleDescAttr(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) NULL;

References Assert(), att_isnull(), attnum, fetchatt, HeapTupleNoNulls, nocachegetattr(), HeapTupleHeaderData::t_bits, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, and TupleDescAttr.

Referenced by AttrDefaultFetch(), CatalogCacheComputeTupleHashValue(), check_toast_tuple(), CheckConstraintFetch(), 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
	)

Definition at line 148 of file heaptuple.c.

{
    Form_pg_attribute att;
 
    Assert(attnum <= tupleDesc->natts);
    Assert(attnum > 0);
 
    att = TupleDescAttr(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(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 AttrMissing::am_present, AttrMissing::am_value, Assert(), attnum, TupleDescData::constr, datumCopy(), HASH_ENTER, hash_search(), init_missing_cache(), sort-test::key, MemoryContextSwitchTo(), TupleConstr::missing, missing_cache, PointerGetDatum(), TopMemoryContext, TupleDescAttr, missing_cache_key::value, and VARSIZE_ANY.

Referenced by heap_getattr().

heap_attisnull()

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

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 && TupleDescAttr(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, HeapTupleHeaderGetNatts, HeapTupleNoNulls, MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, SelfItemPointerAttributeNumber, HeapTupleHeaderData::t_bits, HeapTupleData::t_data, TableOidAttributeNumber, and TupleDescAttr.

Referenced by AlterPublicationOptions(), AlterPublicationSchemas(), build_function_result_tupdesc_t(), check_index_is_clusterable(), CheckIndexCompatible(), ExecEvalRowNullInt(), ExecuteCallStmt(), fmgr_info_cxt_security(), fmgr_symbol(), get_func_result_name(), index_drop(), inline_function(), inline_set_returning_function(), 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
	)

Definition at line 216 of file heaptuple.c.

{
    Size        data_length = 0;
    int         i;
    int         numberOfAttributes = tupleDesc->natts;
 
    for (i = 0; i < numberOfAttributes; i++)
    {
        Datum       val;
        Form_pg_attribute atti;
 
        if (isnull[i])
            continue;
 
        val = values[i];
        atti = TupleDescAttr(tupleDesc, i);
 
        if (ATT_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_align_nominal(data_length, atti->attalign);
            data_length += EOH_get_flat_size(DatumGetEOHP(val));
        }
        else
        {
            data_length = att_align_datum(data_length, atti->attalign,
                                          atti->attlen, val);
            data_length = att_addlength_datum(data_length, atti->attlen,
                                              val);
        }
    }
 
    return data_length;
}

References att_addlength_datum, att_align_datum, att_align_nominal, ATT_IS_PACKABLE, DatumGetEOHP(), DatumGetPointer(), EOH_get_flat_size(), i, TupleDescData::natts, TupleDescAttr, 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

)

Definition at line 1536 of file heaptuple.c.

{
    MinimalTuple result;
 
    result = (MinimalTuple) palloc(mtup->t_len);
    memcpy(result, mtup, mtup->t_len);
    return result;
}

References palloc(), and MinimalTupleData::t_len.

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

heap_copy_tuple_as_datum()

Datum heap_copy_tuple_as_datum	(	HeapTuple	tuple,
		TupleDesc	tupleDesc
	)

Definition at line 1081 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((char *) td, (char *) tuple->t_data, tuple->t_len);
 
    HeapTupleHeaderSetDatumLength(td, tuple->t_len);
    HeapTupleHeaderSetTypeId(td, tupleDesc->tdtypeid);
    HeapTupleHeaderSetTypMod(td, tupleDesc->tdtypmod);
 
    return PointerGetDatum(td);
}

References HeapTupleHasExternal, HeapTupleHeaderSetDatumLength, HeapTupleHeaderSetTypeId, HeapTupleHeaderSetTypMod, palloc(), PointerGetDatum(), HeapTupleData::t_data, HeapTupleData::t_len, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and toast_flatten_tuple_to_datum().

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

heap_copytuple()

HeapTuple heap_copytuple

(

HeapTuple

tuple

)

Definition at line 777 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((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
    return newTuple;
}

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

Referenced by AlterConstraintNamespaces(), AlterDomainValidateConstraint(), AlterExtensionNamespace(), AlterSequence(), AlterTypeOwner(), ATExecAlterConstrRecurse(), ATExecSetNotNull(), ATExecValidateConstraint(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), ConstraintSetParentConstraint(), CopyStatistics(), CreateTriggerFiringOn(), DefineIndex(), dropconstraint_internal(), EnableDisableTrigger(), ExecForceStoreHeapTuple(), expanded_record_set_tuple(), findNotNullConstraintAttnum(), get_catalog_object_by_oid(), GetDatabaseTuple(), GetDatabaseTupleByOid(), index_concurrently_swap(), index_update_stats(), make_expanded_record_from_datum(), MarkInheritDetached(), MergeConstraintsIntoExisting(), MergeWithExistingConstraint(), RelationInitIndexAccessInfo(), RemoveInheritance(), rename_policy(), RenameEnumLabel(), RenameTableSpace(), renametrig_internal(), RenumberEnumType(), ResetSequence(), rewrite_heap_tuple(), ScanPgRelation(), SearchSysCacheCopy(), SearchSysCacheCopyAttName(), SearchSysCacheCopyAttNum(), shdepChangeDep(), SPI_copytuple(), statext_expressions_load(), TriggerSetParentTrigger(), tts_buffer_heap_copy_heap_tuple(), tts_buffer_heap_materialize(), tts_heap_copy_heap_tuple(), tts_heap_materialize(), tuplesort_putheaptuple(), and vac_update_datfrozenxid().

heap_copytuple_with_tuple()

void heap_copytuple_with_tuple	(	HeapTuple	src,
		HeapTuple	dest
	)

Definition at line 803 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((char *) dest->t_data, (char *) src->t_data, src->t_len);
}

References generate_unaccent_rules::dest, HeapTupleIsValid, 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
	)

Definition at line 1346 of file heaptuple.c.

{
    HeapTupleHeader tup = tuple->t_data;
    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 */
    bits8      *bp = tup->t_bits;   /* ptr to null bitmap in tuple */
    bool        slow = false;   /* can we use/set attcacheoff? */
 
    natts = HeapTupleHeaderGetNatts(tup);
 
    /*
     * 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);
 
    tp = (char *) tup + tup->t_hoff;
 
    off = 0;
 
    for (attnum = 0; attnum < natts; attnum++)
    {
        Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
 
        if (hasnulls && att_isnull(attnum, bp))
        {
            values[attnum] = (Datum) 0;
            isnull[attnum] = true;
            slow = true;        /* can't use attcacheoff anymore */
            continue;
        }
 
        isnull[attnum] = false;
 
        if (!slow && thisatt->attcacheoff >= 0)
            off = thisatt->attcacheoff;
        else if (thisatt->attlen == -1)
        {
            /*
             * We can only cache the offset for a varlena attribute if the
             * offset is already suitably aligned, so that there would be no
             * pad bytes in any case: then the offset will be valid for either
             * an aligned or unaligned value.
             */
            if (!slow &&
                off == att_align_nominal(off, thisatt->attalign))
                thisatt->attcacheoff = off;
            else
            {
                off = att_align_pointer(off, thisatt->attalign, -1,
                                        tp + off);
                slow = true;
            }
        }
        else
        {
            /* not varlena, so safe to use att_align_nominal */
            off = att_align_nominal(off, thisatt->attalign);
 
            if (!slow)
                thisatt->attcacheoff = off;
        }
 
        values[attnum] = fetchatt(thisatt, tp + off);
 
        off = att_addlength_pointer(off, thisatt->attlen, tp + off);
 
        if (thisatt->attlen <= 0)
            slow = true;        /* can't use attcacheoff anymore */
    }
 
    /*
     * 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 att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull(), attnum, fetchatt, HeapTupleHasNulls, HeapTupleHeaderGetNatts, Min, TupleDescData::natts, HeapTupleHeaderData::t_bits, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, TupleDescAttr, and values.

Referenced by 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
	)

Definition at line 1066 of file heaptuple.c.

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

References expand_tuple().

heap_fill_tuple()

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

Definition at line 401 of file heaptuple.c.

{
    bits8      *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++)
    {
        Form_pg_attribute attr = TupleDescAttr(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, fill_val(), HEAP_HASEXTERNAL, HEAP_HASNULL, HEAP_HASVARWIDTH, HIGHBIT, i, TupleDescData::natts, PointerGetDatum(), TupleDescAttr, 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
	)

Definition at line 1453 of file heaptuple.c.

{
    MinimalTuple tuple;         /* return tuple */
    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 = 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.
     */
    tuple = (MinimalTuple) palloc0(len);
 
    /*
     * 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 BITMAPLEN, ereport, errcode(), errmsg(), ERROR, heap_compute_data_size(), heap_fill_tuple(), HeapTupleHeaderSetNatts, i, len, MAXALIGN, MaxTupleAttributeNumber, MINIMAL_TUPLE_OFFSET, TupleDescData::natts, 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
	)

Definition at line 1117 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, heap_compute_data_size(), heap_fill_tuple(), HeapTupleHeaderSetDatumLength, HeapTupleHeaderSetNatts, HeapTupleHeaderSetTypeId, HeapTupleHeaderSetTypMod, HEAPTUPLESIZE, i, InvalidOid, ItemPointerSetInvalid(), len, MAXALIGN, MaxTupleAttributeNumber, TupleDescData::natts, 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, TupleDescData::tdtypeid, TupleDescData::tdtypmod, and values.

Referenced by aclexplode(), AddEnumLabel(), AddRoleMems(), AddSubscriptionRelState(), AggregateCreate(), AlterSetting(), brin_metapage_info(), bt_page_print_tuples(), BuildTupleFromCStrings(), CastCreate(), CollationCreate(), ConversionCreate(), copy_replication_slot(), 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(), insert_event_trigger_tuple(), 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_backup_stop(), 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_object_address(), pg_get_publication_tables(), pg_get_wal_record_info(), 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_replication_slot(), pg_stat_get_subscription_stats(), pg_stat_get_wal(), pg_stat_get_wal_receiver(), pg_stat_statements_info(), pg_stats_ext_mcvlist_items(), pg_timezone_abbrevs(), pg_visibility(), pg_visibility_map(), pg_visibility_map_rel(), pg_visibility_map_summary(), pg_visibility_rel(), 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_enc_conversion(), test_predtest(), 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(), and UpdateIndexRelation().

heap_free_minimal_tuple()

void heap_free_minimal_tuple

(

MinimalTuple

mtup

)

Definition at line 1524 of file heaptuple.c.

{
    pfree(mtup);
}

References pfree().

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

heap_freetuple()

void heap_freetuple

(

HeapTuple

htup

)

Definition at line 1435 of file heaptuple.c.

{
    pfree(htup);
}

References pfree().

Referenced by acquire_inherited_sample_rows(), acquire_sample_rows(), AddEnumLabel(), AddSubscriptionRelState(), AfterTriggerExecute(), AlterCollation(), 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(), ATExecAlterConstrRecurse(), ATExecChangeOwner(), ATExecDropColumn(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropNotNull(), ATExecDropOf(), ATExecForceNoForceRowSecurity(), ATExecGenericOptions(), ATExecSetCompression(), ATExecSetIdentity(), ATExecSetOptions(), ATExecSetRelOptions(), ATExecSetRowSecurity(), ATExecSetStatistics(), ATExecSetStorage(), ATExecValidateConstraint(), 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(), EnableDisableRule(), EnableDisableTrigger(), EventTriggerOnLogin(), examine_attribute(), examine_expression(), ExecBRDeleteTriggers(), ExecBRInsertTriggers(), ExecBRUpdateTriggers(), ExecIRDeleteTriggers(), ExecIRInsertTriggers(), ExecIRUpdateTriggers(), ExecReScanAgg(), ExecReScanIndexScan(), ExecReScanSetOp(), ExecScanSubPlan(), ExecSetParamPlan(), expanded_record_set_tuple(), ExtractReplicaIdentity(), file_acquire_sample_rows(), heap_delete(), heap_insert(), heap_update(), index_build(), index_concurrently_swap(), index_constraint_create(), index_update_stats(), insert_event_trigger_tuple(), InsertExtensionTuple(), InsertOneTuple(), InsertPgClassTuple(), InsertRule(), inv_truncate(), inv_write(), LargeObjectCreate(), mark_index_clustered(), MarkInheritDetached(), MergeAttributesIntoExisting(), MergeConstraintsIntoExisting(), OperatorShellMake(), ParameterAclCreate(), PLyGenericObject_ToComposite(), PLyMapping_ToComposite(), PLySequence_ToComposite(), ProcedureCreate(), publication_add_relation(), publication_add_schema(), RangeCreate(), raw_heap_insert(), record_in(), record_recv(), reform_and_rewrite_tuple(), relation_mark_replica_identity(), 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(), SetDatatabaseHasLoginEventTriggers(), 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(), UpdateIndexRelation(), UpdateTwoPhaseState(), 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 792 of file htup_details.h.

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

References attnum, fastgetattr(), getmissingattr(), heap_getsysattr(), HeapTupleHeaderGetNatts, and HeapTupleData::t_data.

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(), CloneRowTriggersToPartition(), comparetup_cluster_tiebreak(), comparetup_heap_tiebreak(), composite_to_json(), composite_to_jsonb(), decompile_conbin(), dropconstraint_internal(), EventTriggerSQLDropAddObject(), 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(), object_ownercheck(), pg_event_trigger_ddl_commands(), pg_extension_config_dump(), 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(), recordExtObjInitPriv(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTupleDesc(), RelationGetDummyIndexExpressions(), RelationGetIndexAttrBitmap(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), removeabbrev_cluster(), removeabbrev_heap(), RemoveRoleFromObjectPolicy(), RenameRole(), 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
	)

Definition at line 724 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, HeapTupleHeaderGetRawCommandId, HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetRawXmin, MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, ObjectIdGetDatum(), PointerGetDatum(), SelfItemPointerAttributeNumber, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, TableOidAttributeNumber, and TransactionIdGetDatum().

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

heap_modify_tuple()

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

Definition at line 1210 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 = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
    isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
 
    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 heap_deform_tuple(), heap_form_tuple(), TupleDescData::natts, palloc(), 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(), AlterPublicationOptions(), AlterRole(), AlterSchemaOwner_internal(), AlterSetting(), AlterStatistics(), AlterSubscription(), AlterTableSpaceOptions(), AlterTSDictionary(), AlterTypeOwnerInternal(), AlterTypeRecurse(), AlterUserMapping(), ApplyExtensionUpdates(), ATExecAlterColumnGenericOptions(), ATExecAlterColumnType(), ATExecChangeOwner(), ATExecGenericOptions(), ATExecSetOptions(), ATExecSetRelOptions(), 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(), RemoveRoleFromObjectPolicy(), RenameRole(), SetAttrMissing(), SetDefaultACL(), SetSecurityLabel(), SetSharedSecurityLabel(), StoreAttrDefault(), StorePartitionBound(), TypeCreate(), update_attstats(), UpdateSubscriptionRelState(), and UpdateTwoPhaseState().

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
	)

Definition at line 1278 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 = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
    isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
 
    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, heap_deform_tuple(), heap_form_tuple(), i, TupleDescData::natts, palloc(), pfree(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, and values.

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

heap_tuple_from_minimal_tuple()

HeapTuple heap_tuple_from_minimal_tuple

(

MinimalTuple

mtup

)

Definition at line 1555 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 HEAPTUPLESIZE, InvalidOid, ItemPointerSetInvalid(), len, MINIMAL_TUPLE_OFFSET, palloc(), HeapTupleData::t_data, HeapTupleData::t_len, MinimalTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by tts_minimal_copy_heap_tuple().

minimal_expand_tuple()

MinimalTuple minimal_expand_tuple	(	HeapTuple	sourceTuple,
		TupleDesc	tupleDesc
	)

Definition at line 1054 of file heaptuple.c.

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

References expand_tuple().

minimal_tuple_from_heap_tuple()

MinimalTuple minimal_tuple_from_heap_tuple

(

HeapTuple

htup

)

Definition at line 1577 of file heaptuple.c.

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

References Assert(), len, MINIMAL_TUPLE_OFFSET, palloc(), HeapTupleData::t_data, HeapTupleData::t_len, and MinimalTupleData::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
	)

Definition at line 520 of file heaptuple.c.

{
    HeapTupleHeader td = tup->t_data;
    char       *tp;             /* ptr to data part of tuple */
    bits8      *bp = td->t_bits;    /* ptr to null bitmap in tuple */
    bool        slow = false;   /* do we have to walk attrs? */
    int         off;            /* current offset within data */
 
    /* ----------------
     *   Three cases:
     *
     *   1: No nulls and no variable-width attributes.
     *   2: Has a null or a var-width AFTER att.
     *   3: Has nulls or var-widths BEFORE att.
     * ----------------
     */
 
    attnum--;
 
    if (!HeapTupleNoNulls(tup))
    {
        /*
         * there's a null somewhere in the tuple
         *
         * check to see if any preceding bits are null...
         */
        int         byte = attnum >> 3;
        int         finalbit = attnum & 0x07;
 
        /* check for nulls "before" final bit of last byte */
        if ((~bp[byte]) & ((1 << finalbit) - 1))
            slow = true;
        else
        {
            /* check for nulls in any "earlier" bytes */
            int         i;
 
            for (i = 0; i < byte; i++)
            {
                if (bp[i] != 0xFF)
                {
                    slow = true;
                    break;
                }
            }
        }
    }
 
    tp = (char *) td + td->t_hoff;
 
    if (!slow)
    {
        Form_pg_attribute att;
 
        /*
         * If we get here, there are no nulls up to and including the target
         * attribute.  If we have a cached offset, we can use it.
         */
        att = TupleDescAttr(tupleDesc, attnum);
        if (att->attcacheoff >= 0)
            return fetchatt(att, tp + att->attcacheoff);
 
        /*
         * Otherwise, check for non-fixed-length attrs up to and including
         * target.  If there aren't any, it's safe to cheaply initialize the
         * cached offsets for these attrs.
         */
        if (HeapTupleHasVarWidth(tup))
        {
            int         j;
 
            for (j = 0; j <= attnum; j++)
            {
                if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
                {
                    slow = true;
                    break;
                }
            }
        }
    }
 
    if (!slow)
    {
        int         natts = tupleDesc->natts;
        int         j = 1;
 
        /*
         * If we get here, we have a tuple with no nulls or var-widths up to
         * and including the target attribute, so we can use the cached offset
         * ... only we don't have it yet, or we'd not have got here.  Since
         * it's cheap to compute offsets for fixed-width columns, we take the
         * opportunity to initialize the cached offsets for *all* the leading
         * fixed-width columns, in hope of avoiding future visits to this
         * routine.
         */
        TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
 
        /* we might have set some offsets in the slow path previously */
        while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
            j++;
 
        off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
            TupleDescAttr(tupleDesc, j - 1)->attlen;
 
        for (; j < natts; j++)
        {
            Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
 
            if (att->attlen <= 0)
                break;
 
            off = att_align_nominal(off, att->attalign);
 
            att->attcacheoff = off;
 
            off += att->attlen;
        }
 
        Assert(j > attnum);
 
        off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
    }
    else
    {
        bool        usecache = true;
        int         i;
 
        /*
         * Now we know that we have to walk the tuple CAREFULLY.  But we still
         * might be able to cache some offsets for next time.
         *
         * Note - This loop is a little tricky.  For each non-null attribute,
         * we have to first account for alignment padding before the attr,
         * then advance over the attr based on its length.  Nulls have no
         * storage and no alignment padding either.  We can use/set
         * attcacheoff until we reach either a null or a var-width attribute.
         */
        off = 0;
        for (i = 0;; i++)       /* loop exit is at "break" */
        {
            Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
 
            if (HeapTupleHasNulls(tup) && att_isnull(i, bp))
            {
                usecache = false;
                continue;       /* this cannot be the target att */
            }
 
            /* If we know the next offset, we can skip the rest */
            if (usecache && att->attcacheoff >= 0)
                off = att->attcacheoff;
            else if (att->attlen == -1)
            {
                /*
                 * We can only cache the offset for a varlena attribute if the
                 * offset is already suitably aligned, so that there would be
                 * no pad bytes in any case: then the offset will be valid for
                 * either an aligned or unaligned value.
                 */
                if (usecache &&
                    off == att_align_nominal(off, att->attalign))
                    att->attcacheoff = off;
                else
                {
                    off = att_align_pointer(off, att->attalign, -1,
                                            tp + off);
                    usecache = false;
                }
            }
            else
            {
                /* not varlena, so safe to use att_align_nominal */
                off = att_align_nominal(off, att->attalign);
 
                if (usecache)
                    att->attcacheoff = off;
            }
 
            if (i == attnum)
                break;
 
            off = att_addlength_pointer(off, att->attlen, tp + off);
 
            if (usecache && att->attlen <= 0)
                usecache = false;
        }
    }
 
    return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
}

References Assert(), att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull(), attlen, attnum, fetchatt, HeapTupleHasNulls, HeapTupleHasVarWidth, HeapTupleNoNulls, i, if(), j, TupleDescData::natts, HeapTupleHeaderData::t_bits, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, and TupleDescAttr.

Referenced by fastgetattr().

StaticAssertDecl()

StaticAssertDecl

(

)

varsize_any()

size_t varsize_any

(

void *

p

)

Definition at line 1595 of file heaptuple.c.

{
    return VARSIZE_ANY(p);
}

References VARSIZE_ANY.