PostgreSQL Source Code  git master
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_KEYSHR_LOCK)
#define HEAP_XMAX_SHR_LOCK
Definition: htup_details.h:200
#define HEAP_XMAX_EXCL_LOCK
Definition: htup_details.h:196

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) \
)
#define HEAP_XMAX_LOCK_ONLY
Definition: htup_details.h:197
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:209
#define HEAP_XMAX_KEYSHR_LOCK
Definition: htup_details.h:194

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_IS_MULTI | HEAP_LOCK_MASK | HEAP_XMAX_LOCK_ONLY)
#define HEAP_LOCK_MASK
Definition: htup_details.h:202
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:207
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208

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) || \

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 \
)
#define HEAP_ONLY_TUPLE
Definition: htup_details.h:277

Definition at line 509 of file htup_details.h.

◆ HeapTupleHeaderClearHotUpdated

#define HeapTupleHeaderClearHotUpdated (   tup)
Value:
( \
(tup)->t_infomask2 &= ~HEAP_HOT_UPDATED \
)
#define HEAP_HOT_UPDATED
Definition: htup_details.h:276

Definition at line 494 of file htup_details.h.

◆ HeapTupleHeaderClearMatch

#define HeapTupleHeaderClearMatch (   tup)
Value:
( \
(tup)->t_infomask2 &= ~HEAP_TUPLE_HAS_MATCH \
)
#define HEAP_TUPLE_HAS_MATCH
Definition: htup_details.h:287

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) \
)
#define HeapTupleHeaderIsSpeculative(tup)
Definition: htup_details.h:428

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)) ? \
: \
HeapTupleHeaderGetRawXmax(tup) \
)
TransactionId HeapTupleGetUpdateXid(HeapTupleHeader tuple)
Definition: heapam.c:7097

Definition at line 361 of file htup_details.h.

◆ HeapTupleHeaderGetXmin

#define HeapTupleHeaderGetXmin (   tup)
Value:
( \
HeapTupleHeaderXminFrozen(tup) ? \
FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
)
#define HeapTupleHeaderGetRawXmin(tup)
Definition: htup_details.h:304

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 \
: \
)
#define HEAP_MOVED
Definition: htup_details.h:213
#define InvalidTransactionId
Definition: transam.h:31

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 && \
)
#define HeapTupleHeaderXminInvalid(tup)
Definition: htup_details.h:325

Definition at line 482 of file htup_details.h.

◆ HeapTupleHeaderIsSpeculative

#define HeapTupleHeaderIsSpeculative (   tup)
Value:
( \
)
static OffsetNumber ItemPointerGetOffsetNumberNoCheck(const ItemPointerData *pointer)
Definition: itemptr.h:114
#define SpecTokenOffsetNumber
Definition: itemptr.h:63

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)
#define HEAP_COMBOCID
Definition: htup_details.h:195

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) \
)
#define HEAP_NATTS_MASK
Definition: htup_details.h:273

Definition at line 532 of file htup_details.h.

◆ HeapTupleHeaderSetSpeculativeToken

#define HeapTupleHeaderSetSpeculativeToken (   tup,
  token 
)
Value:
( \
ItemPointerSet(&(tup)->t_ctid, token, SpecTokenOffsetNumber) \
)
#define token
Definition: indent_globs.h:126

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) \
)
#define HEAP_XMIN_COMMITTED
Definition: htup_details.h:204

Definition at line 336 of file htup_details.h.

◆ HeapTupleHeaderSetXminFrozen

#define HeapTupleHeaderSetXminFrozen (   tup)
Value:
( \
AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
)
#define HEAP_XMIN_FROZEN
Definition: htup_details.h:206

Definition at line 348 of file htup_details.h.

◆ HeapTupleHeaderSetXminInvalid

#define HeapTupleHeaderSetXminInvalid (   tup)
Value:
( \
AssertMacro(!HeapTupleHeaderXminCommitted(tup)), \
((tup)->t_infomask |= HEAP_XMIN_INVALID) \
)
#define HEAP_XMIN_INVALID
Definition: htup_details.h:205
#define HeapTupleHeaderXminCommitted(tup)
Definition: htup_details.h:320

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)) == \
)

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) / \
#define SizeOfPageHeaderData
Definition: bufpage.h:213
#define MAXALIGN(LEN)
Definition: c.h:811
#define SizeofHeapTupleHeader
Definition: htup_details.h:185
struct ItemIdData 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

◆ 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.

755 {
756  Assert(attnum > 0);
757 
758  *isnull = false;
759  if (HeapTupleNoNulls(tup))
760  {
761  Form_pg_attribute att;
762 
763  att = TupleDescAttr(tupleDesc, attnum - 1);
764  if (att->attcacheoff >= 0)
765  return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
766  att->attcacheoff);
767  else
768  return nocachegetattr(tup, attnum, tupleDesc);
769  }
770  else
771  {
772  if (att_isnull(attnum - 1, tup->t_data->t_bits))
773  {
774  *isnull = true;
775  return (Datum) NULL;
#define Assert(condition)
Definition: c.h:858
Datum nocachegetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc)
Definition: heaptuple.c:519
#define HeapTupleNoNulls(tuple)
Definition: htup_details.h:662
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
uintptr_t Datum
Definition: postgres.h:64
HeapTupleHeader t_data
Definition: htup.h:68
bits8 t_bits[FLEXIBLE_ARRAY_MEMBER]
Definition: htup_details.h:178
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
static bool att_isnull(int ATT, const bits8 *BITS)
Definition: tupmacs.h:26
#define fetchatt(A, T)
Definition: tupmacs.h:46

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 147 of file heaptuple.c.

149 {
150  Form_pg_attribute att;
151 
152  Assert(attnum <= tupleDesc->natts);
153  Assert(attnum > 0);
154 
155  att = TupleDescAttr(tupleDesc, attnum - 1);
156 
157  if (att->atthasmissing)
158  {
159  AttrMissing *attrmiss;
160 
161  Assert(tupleDesc->constr);
162  Assert(tupleDesc->constr->missing);
163 
164  attrmiss = tupleDesc->constr->missing + (attnum - 1);
165 
166  if (attrmiss->am_present)
167  {
169  missing_cache_key *entry;
170  bool found;
171  MemoryContext oldctx;
172 
173  *isnull = false;
174 
175  /* no need to cache by-value attributes */
176  if (att->attbyval)
177  return attrmiss->am_value;
178 
179  /* set up cache if required */
180  if (missing_cache == NULL)
182 
183  /* check if there's a cache entry */
184  Assert(att->attlen > 0 || att->attlen == -1);
185  if (att->attlen > 0)
186  key.len = att->attlen;
187  else
188  key.len = VARSIZE_ANY(attrmiss->am_value);
189  key.value = attrmiss->am_value;
190 
191  entry = hash_search(missing_cache, &key, HASH_ENTER, &found);
192 
193  if (!found)
194  {
195  /* cache miss, so we need a non-transient copy of the datum */
197  entry->value =
198  datumCopy(attrmiss->am_value, false, att->attlen);
199  MemoryContextSwitchTo(oldctx);
200  }
201 
202  return entry->value;
203  }
204  }
205 
206  *isnull = true;
207  return PointerGetDatum(NULL);
208 }
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
static void init_missing_cache()
Definition: heaptuple.c:122
static HTAB * missing_cache
Definition: heaptuple.c:97
@ HASH_ENTER
Definition: hsearch.h:114
MemoryContext TopMemoryContext
Definition: mcxt.c:149
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
MemoryContextSwitchTo(old_ctx)
struct AttrMissing * missing
Definition: tupdesc.h:41
TupleConstr * constr
Definition: tupdesc.h:85
#define VARSIZE_ANY(PTR)
Definition: varatt.h:311

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 455 of file heaptuple.c.

456 {
457  /*
458  * We allow a NULL tupledesc for relations not expected to have missing
459  * values, such as catalog relations and indexes.
460  */
461  Assert(!tupleDesc || attnum <= tupleDesc->natts);
462  if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
463  {
464  if (tupleDesc && TupleDescAttr(tupleDesc, attnum - 1)->atthasmissing)
465  return false;
466  else
467  return true;
468  }
469 
470  if (attnum > 0)
471  {
472  if (HeapTupleNoNulls(tup))
473  return false;
474  return att_isnull(attnum - 1, tup->t_data->t_bits);
475  }
476 
477  switch (attnum)
478  {
485  /* these are never null */
486  break;
487 
488  default:
489  elog(ERROR, "invalid attnum: %d", attnum);
490  }
491 
492  return false;
493 }
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define HeapTupleHeaderGetNatts(tup)
Definition: htup_details.h:529
#define MinTransactionIdAttributeNumber
Definition: sysattr.h:22
#define MaxCommandIdAttributeNumber
Definition: sysattr.h:25
#define MaxTransactionIdAttributeNumber
Definition: sysattr.h:24
#define TableOidAttributeNumber
Definition: sysattr.h:26
#define SelfItemPointerAttributeNumber
Definition: sysattr.h:21
#define MinCommandIdAttributeNumber
Definition: sysattr.h:23

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 215 of file heaptuple.c.

218 {
219  Size data_length = 0;
220  int i;
221  int numberOfAttributes = tupleDesc->natts;
222 
223  for (i = 0; i < numberOfAttributes; i++)
224  {
225  Datum val;
226  Form_pg_attribute atti;
227 
228  if (isnull[i])
229  continue;
230 
231  val = values[i];
232  atti = TupleDescAttr(tupleDesc, i);
233 
234  if (ATT_IS_PACKABLE(atti) &&
236  {
237  /*
238  * we're anticipating converting to a short varlena header, so
239  * adjust length and don't count any alignment
240  */
242  }
243  else if (atti->attlen == -1 &&
245  {
246  /*
247  * we want to flatten the expanded value so that the constructed
248  * tuple doesn't depend on it
249  */
250  data_length = att_align_nominal(data_length, atti->attalign);
251  data_length += EOH_get_flat_size(DatumGetEOHP(val));
252  }
253  else
254  {
255  data_length = att_align_datum(data_length, atti->attalign,
256  atti->attlen, val);
257  data_length = att_addlength_datum(data_length, atti->attlen,
258  val);
259  }
260  }
261 
262  return data_length;
263 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
size_t Size
Definition: c.h:605
ExpandedObjectHeader * DatumGetEOHP(Datum d)
Definition: expandeddatum.c:29
Size EOH_get_flat_size(ExpandedObjectHeader *eohptr)
Definition: expandeddatum.c:75
#define ATT_IS_PACKABLE(att)
Definition: heaptuple.c:80
long val
Definition: informix.c:670
int i
Definition: isn.c:73
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
#define att_align_nominal(cur_offset, attalign)
Definition: tupmacs.h:129
#define att_align_datum(cur_offset, attalign, attlen, attdatum)
Definition: tupmacs.h:86
#define att_addlength_datum(cur_offset, attlen, attdatum)
Definition: tupmacs.h:145
#define VARATT_CAN_MAKE_SHORT(PTR)
Definition: varatt.h:258
#define VARATT_IS_EXTERNAL_EXPANDED(PTR)
Definition: varatt.h:298
#define VARATT_CONVERTED_SHORT_SIZE(PTR)
Definition: varatt.h:261

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 1535 of file heaptuple.c.

1536 {
1537  MinimalTuple result;
1538 
1539  result = (MinimalTuple) palloc(mtup->t_len);
1540  memcpy(result, mtup, mtup->t_len);
1541  return result;
1542 }
MinimalTupleData * MinimalTuple
Definition: htup.h:27
void * palloc(Size size)
Definition: mcxt.c:1316

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 1080 of file heaptuple.c.

1081 {
1082  HeapTupleHeader td;
1083 
1084  /*
1085  * If the tuple contains any external TOAST pointers, we have to inline
1086  * those fields to meet the conventions for composite-type Datums.
1087  */
1088  if (HeapTupleHasExternal(tuple))
1089  return toast_flatten_tuple_to_datum(tuple->t_data,
1090  tuple->t_len,
1091  tupleDesc);
1092 
1093  /*
1094  * Fast path for easy case: just make a palloc'd copy and insert the
1095  * correct composite-Datum header fields (since those may not be set if
1096  * the given tuple came from disk, rather than from heap_form_tuple).
1097  */
1098  td = (HeapTupleHeader) palloc(tuple->t_len);
1099  memcpy((char *) td, (char *) tuple->t_data, tuple->t_len);
1100 
1102  HeapTupleHeaderSetTypeId(td, tupleDesc->tdtypeid);
1103  HeapTupleHeaderSetTypMod(td, tupleDesc->tdtypmod);
1104 
1105  return PointerGetDatum(td);
1106 }
Datum toast_flatten_tuple_to_datum(HeapTupleHeader tup, uint32 tup_len, TupleDesc tupleDesc)
Definition: heaptoast.c:449
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HeapTupleHeaderSetTypMod(tup, typmod)
Definition: htup_details.h:471
#define HeapTupleHasExternal(tuple)
Definition: htup_details.h:671
#define HeapTupleHeaderSetDatumLength(tup, len)
Definition: htup_details.h:453
#define HeapTupleHeaderSetTypeId(tup, typeid)
Definition: htup_details.h:461
uint32 t_len
Definition: htup.h:64
int32 tdtypmod
Definition: tupdesc.h:83
Oid tdtypeid
Definition: tupdesc.h:82

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 776 of file heaptuple.c.

777 {
778  HeapTuple newTuple;
779 
780  if (!HeapTupleIsValid(tuple) || tuple->t_data == NULL)
781  return NULL;
782 
783  newTuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple->t_len);
784  newTuple->t_len = tuple->t_len;
785  newTuple->t_self = tuple->t_self;
786  newTuple->t_tableOid = tuple->t_tableOid;
787  newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
788  memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
789  return newTuple;
790 }
#define HEAPTUPLESIZE
Definition: htup.h:73
HeapTupleData * HeapTuple
Definition: htup.h:71
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
ItemPointerData t_self
Definition: htup.h:65
Oid t_tableOid
Definition: htup.h:66

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(), ATExecDropConstraint(), ATExecValidateConstraint(), changeDependenciesOf(), changeDependenciesOn(), changeDependencyFor(), ConstraintSetParentConstraint(), CopyStatistics(), CreateTriggerFiringOn(), DefineIndex(), EnableDisableTrigger(), EventTriggerOnLogin(), ExecForceStoreHeapTuple(), expanded_record_set_tuple(), findDomainNotNullConstraint(), 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 802 of file heaptuple.c.

803 {
804  if (!HeapTupleIsValid(src) || src->t_data == NULL)
805  {
806  dest->t_data = NULL;
807  return;
808  }
809 
810  dest->t_len = src->t_len;
811  dest->t_self = src->t_self;
812  dest->t_tableOid = src->t_tableOid;
813  dest->t_data = (HeapTupleHeader) palloc(src->t_len);
814  memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
815 }

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 1345 of file heaptuple.c.

1347 {
1348  HeapTupleHeader tup = tuple->t_data;
1349  bool hasnulls = HeapTupleHasNulls(tuple);
1350  int tdesc_natts = tupleDesc->natts;
1351  int natts; /* number of atts to extract */
1352  int attnum;
1353  char *tp; /* ptr to tuple data */
1354  uint32 off; /* offset in tuple data */
1355  bits8 *bp = tup->t_bits; /* ptr to null bitmap in tuple */
1356  bool slow = false; /* can we use/set attcacheoff? */
1357 
1358  natts = HeapTupleHeaderGetNatts(tup);
1359 
1360  /*
1361  * In inheritance situations, it is possible that the given tuple actually
1362  * has more fields than the caller is expecting. Don't run off the end of
1363  * the caller's arrays.
1364  */
1365  natts = Min(natts, tdesc_natts);
1366 
1367  tp = (char *) tup + tup->t_hoff;
1368 
1369  off = 0;
1370 
1371  for (attnum = 0; attnum < natts; attnum++)
1372  {
1373  Form_pg_attribute thisatt = TupleDescAttr(tupleDesc, attnum);
1374 
1375  if (hasnulls && att_isnull(attnum, bp))
1376  {
1377  values[attnum] = (Datum) 0;
1378  isnull[attnum] = true;
1379  slow = true; /* can't use attcacheoff anymore */
1380  continue;
1381  }
1382 
1383  isnull[attnum] = false;
1384 
1385  if (!slow && thisatt->attcacheoff >= 0)
1386  off = thisatt->attcacheoff;
1387  else if (thisatt->attlen == -1)
1388  {
1389  /*
1390  * We can only cache the offset for a varlena attribute if the
1391  * offset is already suitably aligned, so that there would be no
1392  * pad bytes in any case: then the offset will be valid for either
1393  * an aligned or unaligned value.
1394  */
1395  if (!slow &&
1396  off == att_align_nominal(off, thisatt->attalign))
1397  thisatt->attcacheoff = off;
1398  else
1399  {
1400  off = att_align_pointer(off, thisatt->attalign, -1,
1401  tp + off);
1402  slow = true;
1403  }
1404  }
1405  else
1406  {
1407  /* not varlena, so safe to use att_align_nominal */
1408  off = att_align_nominal(off, thisatt->attalign);
1409 
1410  if (!slow)
1411  thisatt->attcacheoff = off;
1412  }
1413 
1414  values[attnum] = fetchatt(thisatt, tp + off);
1415 
1416  off = att_addlength_pointer(off, thisatt->attlen, tp + off);
1417 
1418  if (thisatt->attlen <= 0)
1419  slow = true; /* can't use attcacheoff anymore */
1420  }
1421 
1422  /*
1423  * If tuple doesn't have all the atts indicated by tupleDesc, read the
1424  * rest as nulls or missing values as appropriate.
1425  */
1426  for (; attnum < tdesc_natts; attnum++)
1427  values[attnum] = getmissingattr(tupleDesc, attnum + 1, &isnull[attnum]);
1428 }
unsigned int uint32
Definition: c.h:506
#define Min(x, y)
Definition: c.h:1004
uint8 bits8
Definition: c.h:513
for(;;)
Datum getmissingattr(TupleDesc tupleDesc, int attnum, bool *isnull)
Definition: heaptuple.c:147
#define HeapTupleHasNulls(tuple)
Definition: htup_details.h:659
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition: tupmacs.h:107
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition: tupmacs.h:157

References att_addlength_pointer, att_align_nominal, att_align_pointer, att_isnull(), attnum, fetchatt, for(), 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 1065 of file heaptuple.c.

1066 {
1067  HeapTuple heapTuple;
1068 
1069  expand_tuple(&heapTuple, NULL, sourceTuple, tupleDesc);
1070  return heapTuple;
1071 }
static void expand_tuple(HeapTuple *targetHeapTuple, MinimalTuple *targetMinimalTuple, HeapTuple sourceTuple, TupleDesc tupleDesc)
Definition: heaptuple.c:828

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 400 of file heaptuple.c.

404 {
405  bits8 *bitP;
406  int bitmask;
407  int i;
408  int numberOfAttributes = tupleDesc->natts;
409 
410 #ifdef USE_ASSERT_CHECKING
411  char *start = data;
412 #endif
413 
414  if (bit != NULL)
415  {
416  bitP = &bit[-1];
417  bitmask = HIGHBIT;
418  }
419  else
420  {
421  /* just to keep compiler quiet */
422  bitP = NULL;
423  bitmask = 0;
424  }
425 
426  *infomask &= ~(HEAP_HASNULL | HEAP_HASVARWIDTH | HEAP_HASEXTERNAL);
427 
428  for (i = 0; i < numberOfAttributes; i++)
429  {
430  Form_pg_attribute attr = TupleDescAttr(tupleDesc, i);
431 
432  fill_val(attr,
433  bitP ? &bitP : NULL,
434  &bitmask,
435  &data,
436  infomask,
437  values ? values[i] : PointerGetDatum(NULL),
438  isnull ? isnull[i] : true);
439  }
440 
441  Assert((data - start) == data_size);
442 }
#define HIGHBIT
Definition: c.h:1154
return str start
static void fill_val(Form_pg_attribute att, bits8 **bit, int *bitmask, char **dataP, uint16 *infomask, Datum datum, bool isnull)
Definition: heaptuple.c:271
#define HEAP_HASVARWIDTH
Definition: htup_details.h:191
#define HEAP_HASNULL
Definition: htup_details.h:190
#define HEAP_HASEXTERNAL
Definition: htup_details.h:192
const void * data
Datum bit(PG_FUNCTION_ARGS)
Definition: varbit.c:391

References Assert, bit(), data, fill_val(), HEAP_HASEXTERNAL, HEAP_HASNULL, HEAP_HASVARWIDTH, HIGHBIT, i, TupleDescData::natts, PointerGetDatum(), start, 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 1452 of file heaptuple.c.

1455 {
1456  MinimalTuple tuple; /* return tuple */
1457  Size len,
1458  data_len;
1459  int hoff;
1460  bool hasnull = false;
1461  int numberOfAttributes = tupleDescriptor->natts;
1462  int i;
1463 
1464  if (numberOfAttributes > MaxTupleAttributeNumber)
1465  ereport(ERROR,
1466  (errcode(ERRCODE_TOO_MANY_COLUMNS),
1467  errmsg("number of columns (%d) exceeds limit (%d)",
1468  numberOfAttributes, MaxTupleAttributeNumber)));
1469 
1470  /*
1471  * Check for nulls
1472  */
1473  for (i = 0; i < numberOfAttributes; i++)
1474  {
1475  if (isnull[i])
1476  {
1477  hasnull = true;
1478  break;
1479  }
1480  }
1481 
1482  /*
1483  * Determine total space needed
1484  */
1486 
1487  if (hasnull)
1488  len += BITMAPLEN(numberOfAttributes);
1489 
1490  hoff = len = MAXALIGN(len); /* align user data safely */
1491 
1492  data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
1493 
1494  len += data_len;
1495 
1496  /*
1497  * Allocate and zero the space needed.
1498  */
1499  tuple = (MinimalTuple) palloc0(len);
1500 
1501  /*
1502  * And fill in the information.
1503  */
1504  tuple->t_len = len;
1505  HeapTupleHeaderSetNatts(tuple, numberOfAttributes);
1506  tuple->t_hoff = hoff + MINIMAL_TUPLE_OFFSET;
1507 
1508  heap_fill_tuple(tupleDescriptor,
1509  values,
1510  isnull,
1511  (char *) tuple + hoff,
1512  data_len,
1513  &tuple->t_infomask,
1514  (hasnull ? tuple->t_bits : NULL));
1515 
1516  return tuple;
1517 }
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ereport(elevel,...)
Definition: elog.h:149
Size heap_compute_data_size(TupleDesc tupleDesc, const Datum *values, const bool *isnull)
Definition: heaptuple.c:215
void heap_fill_tuple(TupleDesc tupleDesc, const Datum *values, const bool *isnull, char *data, Size data_size, uint16 *infomask, bits8 *bit)
Definition: heaptuple.c:400
#define MINIMAL_TUPLE_OFFSET
Definition: htup_details.h:617
#define SizeofMinimalTupleHeader
Definition: htup_details.h:647
#define BITMAPLEN(NATTS)
Definition: htup_details.h:545
#define MaxTupleAttributeNumber
Definition: htup_details.h:34
#define HeapTupleHeaderSetNatts(tup, natts)
Definition: htup_details.h:532
void * palloc0(Size size)
Definition: mcxt.c:1346
const void size_t len
bits8 t_bits[FLEXIBLE_ARRAY_MEMBER]
Definition: htup_details.h:640

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 1116 of file heaptuple.c.

1119 {
1120  HeapTuple tuple; /* return tuple */
1121  HeapTupleHeader td; /* tuple data */
1122  Size len,
1123  data_len;
1124  int hoff;
1125  bool hasnull = false;
1126  int numberOfAttributes = tupleDescriptor->natts;
1127  int i;
1128 
1129  if (numberOfAttributes > MaxTupleAttributeNumber)
1130  ereport(ERROR,
1131  (errcode(ERRCODE_TOO_MANY_COLUMNS),
1132  errmsg("number of columns (%d) exceeds limit (%d)",
1133  numberOfAttributes, MaxTupleAttributeNumber)));
1134 
1135  /*
1136  * Check for nulls
1137  */
1138  for (i = 0; i < numberOfAttributes; i++)
1139  {
1140  if (isnull[i])
1141  {
1142  hasnull = true;
1143  break;
1144  }
1145  }
1146 
1147  /*
1148  * Determine total space needed
1149  */
1150  len = offsetof(HeapTupleHeaderData, t_bits);
1151 
1152  if (hasnull)
1153  len += BITMAPLEN(numberOfAttributes);
1154 
1155  hoff = len = MAXALIGN(len); /* align user data safely */
1156 
1157  data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
1158 
1159  len += data_len;
1160 
1161  /*
1162  * Allocate and zero the space needed. Note that the tuple body and
1163  * HeapTupleData management structure are allocated in one chunk.
1164  */
1165  tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + len);
1166  tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
1167 
1168  /*
1169  * And fill in the information. Note we fill the Datum fields even though
1170  * this tuple may never become a Datum. This lets HeapTupleHeaderGetDatum
1171  * identify the tuple type if needed.
1172  */
1173  tuple->t_len = len;
1174  ItemPointerSetInvalid(&(tuple->t_self));
1175  tuple->t_tableOid = InvalidOid;
1176 
1178  HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
1179  HeapTupleHeaderSetTypMod(td, tupleDescriptor->tdtypmod);
1180  /* We also make sure that t_ctid is invalid unless explicitly set */
1181  ItemPointerSetInvalid(&(td->t_ctid));
1182 
1183  HeapTupleHeaderSetNatts(td, numberOfAttributes);
1184  td->t_hoff = hoff;
1185 
1186  heap_fill_tuple(tupleDescriptor,
1187  values,
1188  isnull,
1189  (char *) td + hoff,
1190  data_len,
1191  &td->t_infomask,
1192  (hasnull ? td->t_bits : NULL));
1193 
1194  return tuple;
1195 }
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
#define InvalidOid
Definition: postgres_ext.h:36
ItemPointerData t_ctid
Definition: htup_details.h:161

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_available_wal_summaries(), 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_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_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_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_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)

◆ heap_freetuple()

void heap_freetuple ( HeapTuple  htup)

Definition at line 1434 of file heaptuple.c.

1435 {
1436  pfree(htup);
1437 }

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(), ATExecDropConstraint(), ATExecDropExpression(), ATExecDropIdentity(), ATExecDropOf(), ATExecForceNoForceRowSecurity(), ATExecGenericOptions(), ATExecSetAccessMethodNoStorage(), 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(), 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(), 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(), 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.

798 {
799  if (attnum > 0)
800  {
801  if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
802  return getmissingattr(tupleDesc, attnum, isnull);
803  else
Datum getmissingattr(TupleDesc tupleDesc, int attnum, bool *isnull)
Definition: heaptuple.c:147

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(), 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(), recordExtensionInitPrivWorker(), recordExtObjInitPriv(), RelationBuildPartitionDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTupleDesc(), RelationGetDummyIndexExpressions(), RelationGetIndexAttrBitmap(), RelationGetIndexExpressions(), RelationGetIndexPredicate(), removeabbrev_cluster(), removeabbrev_heap(), RemoveRoleFromInitPriv(), 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 723 of file heaptuple.c.

724 {
725  Datum result;
726 
727  Assert(tup);
728 
729  /* Currently, no sys attribute ever reads as NULL. */
730  *isnull = false;
731 
732  switch (attnum)
733  {
735  /* pass-by-reference datatype */
736  result = PointerGetDatum(&(tup->t_self));
737  break;
740  break;
743  break;
746 
747  /*
748  * cmin and cmax are now both aliases for the same field, which
749  * can in fact also be a combo command id. XXX perhaps we should
750  * return the "real" cmin or cmax if possible, that is if we are
751  * inside the originating transaction?
752  */
754  break;
756  result = ObjectIdGetDatum(tup->t_tableOid);
757  break;
758  default:
759  elog(ERROR, "invalid attnum: %d", attnum);
760  result = 0; /* keep compiler quiet */
761  break;
762  }
763  return result;
764 }
#define HeapTupleHeaderGetRawXmax(tup)
Definition: htup_details.h:371
#define HeapTupleHeaderGetRawCommandId(tup)
Definition: htup_details.h:387
static Datum TransactionIdGetDatum(TransactionId X)
Definition: postgres.h:272
static Datum CommandIdGetDatum(CommandId X)
Definition: postgres.h:302
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252

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 1209 of file heaptuple.c.

1214 {
1215  int numberOfAttributes = tupleDesc->natts;
1216  int attoff;
1217  Datum *values;
1218  bool *isnull;
1219  HeapTuple newTuple;
1220 
1221  /*
1222  * allocate and fill values and isnull arrays from either the tuple or the
1223  * repl information, as appropriate.
1224  *
1225  * NOTE: it's debatable whether to use heap_deform_tuple() here or just
1226  * heap_getattr() only the non-replaced columns. The latter could win if
1227  * there are many replaced columns and few non-replaced ones. However,
1228  * heap_deform_tuple costs only O(N) while the heap_getattr way would cost
1229  * O(N^2) if there are many non-replaced columns, so it seems better to
1230  * err on the side of linear cost.
1231  */
1232  values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
1233  isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
1234 
1235  heap_deform_tuple(tuple, tupleDesc, values, isnull);
1236 
1237  for (attoff = 0; attoff < numberOfAttributes; attoff++)
1238  {
1239  if (doReplace[attoff])
1240  {
1241  values[attoff] = replValues[attoff];
1242  isnull[attoff] = replIsnull[attoff];
1243  }
1244  }
1245 
1246  /*
1247  * create a new tuple from the values and isnull arrays
1248  */
1249  newTuple = heap_form_tuple(tupleDesc, values, isnull);
1250 
1251  pfree(values);
1252  pfree(isnull);
1253 
1254  /*
1255  * copy the identification info of the old tuple: t_ctid, t_self
1256  */
1257  newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
1258  newTuple->t_self = tuple->t_self;
1259  newTuple->t_tableOid = tuple->t_tableOid;
1260 
1261  return newTuple;
1262 }
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1345

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(), 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(), 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 1277 of file heaptuple.c.

1283 {
1284  int numberOfAttributes = tupleDesc->natts;
1285  Datum *values;
1286  bool *isnull;
1287  HeapTuple newTuple;
1288  int i;
1289 
1290  /*
1291  * allocate and fill values and isnull arrays from the tuple, then replace
1292  * selected columns from the input arrays.
1293  */
1294  values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
1295  isnull = (bool *) palloc(numberOfAttributes * sizeof(bool));
1296 
1297  heap_deform_tuple(tuple, tupleDesc, values, isnull);
1298 
1299  for (i = 0; i < nCols; i++)
1300  {
1301  int attnum = replCols[i];
1302 
1303  if (attnum <= 0 || attnum > numberOfAttributes)
1304  elog(ERROR, "invalid column number %d", attnum);
1305  values[attnum - 1] = replValues[i];
1306  isnull[attnum - 1] = replIsnull[i];
1307  }
1308 
1309  /*
1310  * create a new tuple from the values and isnull arrays
1311  */
1312  newTuple = heap_form_tuple(tupleDesc, values, isnull);
1313 
1314  pfree(values);
1315  pfree(isnull);
1316 
1317  /*
1318  * copy the identification info of the old tuple: t_ctid, t_self
1319  */
1320  newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
1321  newTuple->t_self = tuple->t_self;
1322  newTuple->t_tableOid = tuple->t_tableOid;
1323 
1324  return newTuple;
1325 }

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 1554 of file heaptuple.c.

1555 {
1556  HeapTuple result;
1558 
1559  result = (HeapTuple) palloc(HEAPTUPLESIZE + len);
1560  result->t_len = len;
1561  ItemPointerSetInvalid(&(result->t_self));
1562  result->t_tableOid = InvalidOid;
1563  result->t_data = (HeapTupleHeader) ((char *) result + HEAPTUPLESIZE);
1564  memcpy((char *) result->t_data + MINIMAL_TUPLE_OFFSET, mtup, mtup->t_len);
1565  memset(result->t_data, 0, offsetof(HeapTupleHeaderData, t_infomask2));
1566  return result;
1567 }

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 1053 of file heaptuple.c.

1054 {
1055  MinimalTuple minimalTuple;
1056 
1057  expand_tuple(NULL, &minimalTuple, sourceTuple, tupleDesc);
1058  return minimalTuple;
1059 }

References expand_tuple().

◆ minimal_tuple_from_heap_tuple()

MinimalTuple minimal_tuple_from_heap_tuple ( HeapTuple  htup)

Definition at line 1576 of file heaptuple.c.

1577 {
1578  MinimalTuple result;
1579  uint32 len;
1580 
1582  len = htup->t_len - MINIMAL_TUPLE_OFFSET;
1583  result = (MinimalTuple) palloc(len);
1584  memcpy(result, (char *) htup->t_data + MINIMAL_TUPLE_OFFSET, len);
1585  result->t_len = len;
1586  return result;
1587 }

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 519 of file heaptuple.c.

522 {
523  HeapTupleHeader td = tup->t_data;
524  char *tp; /* ptr to data part of tuple */
525  bits8 *bp = td->t_bits; /* ptr to null bitmap in tuple */
526  bool slow = false; /* do we have to walk attrs? */
527  int off; /* current offset within data */
528 
529  /* ----------------
530  * Three cases:
531  *
532  * 1: No nulls and no variable-width attributes.
533  * 2: Has a null or a var-width AFTER att.
534  * 3: Has nulls or var-widths BEFORE att.
535  * ----------------
536  */
537 
538  attnum--;
539 
540  if (!HeapTupleNoNulls(tup))
541  {
542  /*
543  * there's a null somewhere in the tuple
544  *
545  * check to see if any preceding bits are null...
546  */
547  int byte = attnum >> 3;
548  int finalbit = attnum & 0x07;
549 
550  /* check for nulls "before" final bit of last byte */
551  if ((~bp[byte]) & ((1 << finalbit) - 1))
552  slow = true;
553  else
554  {
555  /* check for nulls in any "earlier" bytes */
556  int i;
557 
558  for (i = 0; i < byte; i++)
559  {
560  if (bp[i] != 0xFF)
561  {
562  slow = true;
563  break;
564  }
565  }
566  }
567  }
568 
569  tp = (char *) td + td->t_hoff;
570 
571  if (!slow)
572  {
573  Form_pg_attribute att;
574 
575  /*
576  * If we get here, there are no nulls up to and including the target
577  * attribute. If we have a cached offset, we can use it.
578  */
579  att = TupleDescAttr(tupleDesc, attnum);
580  if (att->attcacheoff >= 0)
581  return fetchatt(att, tp + att->attcacheoff);
582 
583  /*
584  * Otherwise, check for non-fixed-length attrs up to and including
585  * target. If there aren't any, it's safe to cheaply initialize the
586  * cached offsets for these attrs.
587  */
588  if (HeapTupleHasVarWidth(tup))
589  {
590  int j;
591 
592  for (j = 0; j <= attnum; j++)
593  {
594  if (TupleDescAttr(tupleDesc, j)->attlen <= 0)
595  {
596  slow = true;
597  break;
598  }
599  }
600  }
601  }
602 
603  if (!slow)
604  {
605  int natts = tupleDesc->natts;
606  int j = 1;
607 
608  /*
609  * If we get here, we have a tuple with no nulls or var-widths up to
610  * and including the target attribute, so we can use the cached offset
611  * ... only we don't have it yet, or we'd not have got here. Since
612  * it's cheap to compute offsets for fixed-width columns, we take the
613  * opportunity to initialize the cached offsets for *all* the leading
614  * fixed-width columns, in hope of avoiding future visits to this
615  * routine.
616  */
617  TupleDescAttr(tupleDesc, 0)->attcacheoff = 0;
618 
619  /* we might have set some offsets in the slow path previously */
620  while (j < natts && TupleDescAttr(tupleDesc, j)->attcacheoff > 0)
621  j++;
622 
623  off = TupleDescAttr(tupleDesc, j - 1)->attcacheoff +
624  TupleDescAttr(tupleDesc, j - 1)->attlen;
625 
626  for (; j < natts; j++)
627  {
628  Form_pg_attribute att = TupleDescAttr(tupleDesc, j);
629 
630  if (att->attlen <= 0)
631  break;
632 
633  off = att_align_nominal(off, att->attalign);
634 
635  att->attcacheoff = off;
636 
637  off += att->attlen;
638  }
639 
640  Assert(j > attnum);
641 
642  off = TupleDescAttr(tupleDesc, attnum)->attcacheoff;
643  }
644  else
645  {
646  bool usecache = true;
647  int i;
648 
649  /*
650  * Now we know that we have to walk the tuple CAREFULLY. But we still
651  * might be able to cache some offsets for next time.
652  *
653  * Note - This loop is a little tricky. For each non-null attribute,
654  * we have to first account for alignment padding before the attr,
655  * then advance over the attr based on its length. Nulls have no
656  * storage and no alignment padding either. We can use/set
657  * attcacheoff until we reach either a null or a var-width attribute.
658  */
659  off = 0;
660  for (i = 0;; i++) /* loop exit is at "break" */
661  {
662  Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
663 
664  if (HeapTupleHasNulls(tup) && att_isnull(i, bp))
665  {
666  usecache = false;
667  continue; /* this cannot be the target att */
668  }
669 
670  /* If we know the next offset, we can skip the rest */
671  if (usecache && att->attcacheoff >= 0)
672  off = att->attcacheoff;
673  else if (att->attlen == -1)
674  {
675  /*
676  * We can only cache the offset for a varlena attribute if the
677  * offset is already suitably aligned, so that there would be
678  * no pad bytes in any case: then the offset will be valid for
679  * either an aligned or unaligned value.
680  */
681  if (usecache &&
682  off == att_align_nominal(off, att->attalign))
683  att->attcacheoff = off;
684  else
685  {
686  off = att_align_pointer(off, att->attalign, -1,
687  tp + off);
688  usecache = false;
689  }
690  }
691  else
692  {
693  /* not varlena, so safe to use att_align_nominal */
694  off = att_align_nominal(off, att->attalign);
695 
696  if (usecache)
697  att->attcacheoff = off;
698  }
699 
700  if (i == attnum)
701  break;
702 
703  off = att_addlength_pointer(off, att->attlen, tp + off);
704 
705  if (usecache && att->attlen <= 0)
706  usecache = false;
707  }
708  }
709 
710  return fetchatt(TupleDescAttr(tupleDesc, attnum), tp + off);
711 }
#define HeapTupleHasVarWidth(tuple)
Definition: htup_details.h:665
int j
Definition: isn.c:74
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
int16 attlen
Definition: pg_attribute.h:59

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 1594 of file heaptuple.c.

1595 {
1596  return VARSIZE_ANY(p);
1597 }

References VARSIZE_ANY.