LCOV - differential code coverage report
Current view: top level - src/include/access - htup_details.h (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 94.4 % 18 17 1 17
Current Date: 2024-04-14 14:21:10 Functions: 100.0 % 2 2 2
Baseline: 16@8cea358b128 Branches: 83.3 % 12 10 2 10
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 94.4 % 18 17 1 17
Function coverage date bins:
(240..) days: 100.0 % 2 2 2
Branch coverage date bins:
(240..) days: 83.3 % 12 10 2 10

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * htup_details.h
                                  4                 :                :  *    POSTGRES heap tuple header definitions.
                                  5                 :                :  *
                                  6                 :                :  *
                                  7                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  8                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  9                 :                :  *
                                 10                 :                :  * src/include/access/htup_details.h
                                 11                 :                :  *
                                 12                 :                :  *-------------------------------------------------------------------------
                                 13                 :                :  */
                                 14                 :                : #ifndef HTUP_DETAILS_H
                                 15                 :                : #define HTUP_DETAILS_H
                                 16                 :                : 
                                 17                 :                : #include "access/htup.h"
                                 18                 :                : #include "access/transam.h"
                                 19                 :                : #include "access/tupdesc.h"
                                 20                 :                : #include "access/tupmacs.h"
                                 21                 :                : #include "storage/bufpage.h"
                                 22                 :                : #include "varatt.h"
                                 23                 :                : 
                                 24                 :                : /*
                                 25                 :                :  * MaxTupleAttributeNumber limits the number of (user) columns in a tuple.
                                 26                 :                :  * The key limit on this value is that the size of the fixed overhead for
                                 27                 :                :  * a tuple, plus the size of the null-values bitmap (at 1 bit per column),
                                 28                 :                :  * plus MAXALIGN alignment, must fit into t_hoff which is uint8.  On most
                                 29                 :                :  * machines the upper limit without making t_hoff wider would be a little
                                 30                 :                :  * over 1700.  We use round numbers here and for MaxHeapAttributeNumber
                                 31                 :                :  * so that alterations in HeapTupleHeaderData layout won't change the
                                 32                 :                :  * supported max number of columns.
                                 33                 :                :  */
                                 34                 :                : #define MaxTupleAttributeNumber 1664    /* 8 * 208 */
                                 35                 :                : 
                                 36                 :                : /*
                                 37                 :                :  * MaxHeapAttributeNumber limits the number of (user) columns in a table.
                                 38                 :                :  * This should be somewhat less than MaxTupleAttributeNumber.  It must be
                                 39                 :                :  * at least one less, else we will fail to do UPDATEs on a maximal-width
                                 40                 :                :  * table (because UPDATE has to form working tuples that include CTID).
                                 41                 :                :  * In practice we want some additional daylight so that we can gracefully
                                 42                 :                :  * support operations that add hidden "resjunk" columns, for example
                                 43                 :                :  * SELECT * FROM wide_table ORDER BY foo, bar, baz.
                                 44                 :                :  * In any case, depending on column data types you will likely be running
                                 45                 :                :  * into the disk-block-based limit on overall tuple size if you have more
                                 46                 :                :  * than a thousand or so columns.  TOAST won't help.
                                 47                 :                :  */
                                 48                 :                : #define MaxHeapAttributeNumber  1600    /* 8 * 200 */
                                 49                 :                : 
                                 50                 :                : /*
                                 51                 :                :  * Heap tuple header.  To avoid wasting space, the fields should be
                                 52                 :                :  * laid out in such a way as to avoid structure padding.
                                 53                 :                :  *
                                 54                 :                :  * Datums of composite types (row types) share the same general structure
                                 55                 :                :  * as on-disk tuples, so that the same routines can be used to build and
                                 56                 :                :  * examine them.  However the requirements are slightly different: a Datum
                                 57                 :                :  * does not need any transaction visibility information, and it does need
                                 58                 :                :  * a length word and some embedded type information.  We can achieve this
                                 59                 :                :  * by overlaying the xmin/cmin/xmax/cmax/xvac fields of a heap tuple
                                 60                 :                :  * with the fields needed in the Datum case.  Typically, all tuples built
                                 61                 :                :  * in-memory will be initialized with the Datum fields; but when a tuple is
                                 62                 :                :  * about to be inserted in a table, the transaction fields will be filled,
                                 63                 :                :  * overwriting the datum fields.
                                 64                 :                :  *
                                 65                 :                :  * The overall structure of a heap tuple looks like:
                                 66                 :                :  *          fixed fields (HeapTupleHeaderData struct)
                                 67                 :                :  *          nulls bitmap (if HEAP_HASNULL is set in t_infomask)
                                 68                 :                :  *          alignment padding (as needed to make user data MAXALIGN'd)
                                 69                 :                :  *          object ID (if HEAP_HASOID_OLD is set in t_infomask, not created
                                 70                 :                :  *          anymore)
                                 71                 :                :  *          user data fields
                                 72                 :                :  *
                                 73                 :                :  * We store five "virtual" fields Xmin, Cmin, Xmax, Cmax, and Xvac in three
                                 74                 :                :  * physical fields.  Xmin and Xmax are always really stored, but Cmin, Cmax
                                 75                 :                :  * and Xvac share a field.  This works because we know that Cmin and Cmax
                                 76                 :                :  * are only interesting for the lifetime of the inserting and deleting
                                 77                 :                :  * transaction respectively.  If a tuple is inserted and deleted in the same
                                 78                 :                :  * transaction, we store a "combo" command id that can be mapped to the real
                                 79                 :                :  * cmin and cmax, but only by use of local state within the originating
                                 80                 :                :  * backend.  See combocid.c for more details.  Meanwhile, Xvac is only set by
                                 81                 :                :  * old-style VACUUM FULL, which does not have any command sub-structure and so
                                 82                 :                :  * does not need either Cmin or Cmax.  (This requires that old-style VACUUM
                                 83                 :                :  * FULL never try to move a tuple whose Cmin or Cmax is still interesting,
                                 84                 :                :  * ie, an insert-in-progress or delete-in-progress tuple.)
                                 85                 :                :  *
                                 86                 :                :  * A word about t_ctid: whenever a new tuple is stored on disk, its t_ctid
                                 87                 :                :  * is initialized with its own TID (location).  If the tuple is ever updated,
                                 88                 :                :  * its t_ctid is changed to point to the replacement version of the tuple.  Or
                                 89                 :                :  * if the tuple is moved from one partition to another, due to an update of
                                 90                 :                :  * the partition key, t_ctid is set to a special value to indicate that
                                 91                 :                :  * (see ItemPointerSetMovedPartitions).  Thus, a tuple is the latest version
                                 92                 :                :  * of its row iff XMAX is invalid or
                                 93                 :                :  * t_ctid points to itself (in which case, if XMAX is valid, the tuple is
                                 94                 :                :  * either locked or deleted).  One can follow the chain of t_ctid links
                                 95                 :                :  * to find the newest version of the row, unless it was moved to a different
                                 96                 :                :  * partition.  Beware however that VACUUM might
                                 97                 :                :  * erase the pointed-to (newer) tuple before erasing the pointing (older)
                                 98                 :                :  * tuple.  Hence, when following a t_ctid link, it is necessary to check
                                 99                 :                :  * to see if the referenced slot is empty or contains an unrelated tuple.
                                100                 :                :  * Check that the referenced tuple has XMIN equal to the referencing tuple's
                                101                 :                :  * XMAX to verify that it is actually the descendant version and not an
                                102                 :                :  * unrelated tuple stored into a slot recently freed by VACUUM.  If either
                                103                 :                :  * check fails, one may assume that there is no live descendant version.
                                104                 :                :  *
                                105                 :                :  * t_ctid is sometimes used to store a speculative insertion token, instead
                                106                 :                :  * of a real TID.  A speculative token is set on a tuple that's being
                                107                 :                :  * inserted, until the inserter is sure that it wants to go ahead with the
                                108                 :                :  * insertion.  Hence a token should only be seen on a tuple with an XMAX
                                109                 :                :  * that's still in-progress, or invalid/aborted.  The token is replaced with
                                110                 :                :  * the tuple's real TID when the insertion is confirmed.  One should never
                                111                 :                :  * see a speculative insertion token while following a chain of t_ctid links,
                                112                 :                :  * because they are not used on updates, only insertions.
                                113                 :                :  *
                                114                 :                :  * Following the fixed header fields, the nulls bitmap is stored (beginning
                                115                 :                :  * at t_bits).  The bitmap is *not* stored if t_infomask shows that there
                                116                 :                :  * are no nulls in the tuple.  If an OID field is present (as indicated by
                                117                 :                :  * t_infomask), then it is stored just before the user data, which begins at
                                118                 :                :  * the offset shown by t_hoff.  Note that t_hoff must be a multiple of
                                119                 :                :  * MAXALIGN.
                                120                 :                :  */
                                121                 :                : 
                                122                 :                : typedef struct HeapTupleFields
                                123                 :                : {
                                124                 :                :     TransactionId t_xmin;       /* inserting xact ID */
                                125                 :                :     TransactionId t_xmax;       /* deleting or locking xact ID */
                                126                 :                : 
                                127                 :                :     union
                                128                 :                :     {
                                129                 :                :         CommandId   t_cid;      /* inserting or deleting command ID, or both */
                                130                 :                :         TransactionId t_xvac;   /* old-style VACUUM FULL xact ID */
                                131                 :                :     }           t_field3;
                                132                 :                : } HeapTupleFields;
                                133                 :                : 
                                134                 :                : typedef struct DatumTupleFields
                                135                 :                : {
                                136                 :                :     int32       datum_len_;     /* varlena header (do not touch directly!) */
                                137                 :                : 
                                138                 :                :     int32       datum_typmod;   /* -1, or identifier of a record type */
                                139                 :                : 
                                140                 :                :     Oid         datum_typeid;   /* composite type OID, or RECORDOID */
                                141                 :                : 
                                142                 :                :     /*
                                143                 :                :      * datum_typeid cannot be a domain over composite, only plain composite,
                                144                 :                :      * even if the datum is meant as a value of a domain-over-composite type.
                                145                 :                :      * This is in line with the general principle that CoerceToDomain does not
                                146                 :                :      * change the physical representation of the base type value.
                                147                 :                :      *
                                148                 :                :      * Note: field ordering is chosen with thought that Oid might someday
                                149                 :                :      * widen to 64 bits.
                                150                 :                :      */
                                151                 :                : } DatumTupleFields;
                                152                 :                : 
                                153                 :                : struct HeapTupleHeaderData
                                154                 :                : {
                                155                 :                :     union
                                156                 :                :     {
                                157                 :                :         HeapTupleFields t_heap;
                                158                 :                :         DatumTupleFields t_datum;
                                159                 :                :     }           t_choice;
                                160                 :                : 
                                161                 :                :     ItemPointerData t_ctid;     /* current TID of this or newer tuple (or a
                                162                 :                :                                  * speculative insertion token) */
                                163                 :                : 
                                164                 :                :     /* Fields below here must match MinimalTupleData! */
                                165                 :                : 
                                166                 :                : #define FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK2 2
                                167                 :                :     uint16      t_infomask2;    /* number of attributes + various flags */
                                168                 :                : 
                                169                 :                : #define FIELDNO_HEAPTUPLEHEADERDATA_INFOMASK 3
                                170                 :                :     uint16      t_infomask;     /* various flag bits, see below */
                                171                 :                : 
                                172                 :                : #define FIELDNO_HEAPTUPLEHEADERDATA_HOFF 4
                                173                 :                :     uint8       t_hoff;         /* sizeof header incl. bitmap, padding */
                                174                 :                : 
                                175                 :                :     /* ^ - 23 bytes - ^ */
                                176                 :                : 
                                177                 :                : #define FIELDNO_HEAPTUPLEHEADERDATA_BITS 5
                                178                 :                :     bits8       t_bits[FLEXIBLE_ARRAY_MEMBER];  /* bitmap of NULLs */
                                179                 :                : 
                                180                 :                :     /* MORE DATA FOLLOWS AT END OF STRUCT */
                                181                 :                : };
                                182                 :                : 
                                183                 :                : /* typedef appears in htup.h */
                                184                 :                : 
                                185                 :                : #define SizeofHeapTupleHeader offsetof(HeapTupleHeaderData, t_bits)
                                186                 :                : 
                                187                 :                : /*
                                188                 :                :  * information stored in t_infomask:
                                189                 :                :  */
                                190                 :                : #define HEAP_HASNULL            0x0001  /* has null attribute(s) */
                                191                 :                : #define HEAP_HASVARWIDTH        0x0002  /* has variable-width attribute(s) */
                                192                 :                : #define HEAP_HASEXTERNAL        0x0004  /* has external stored attribute(s) */
                                193                 :                : #define HEAP_HASOID_OLD         0x0008  /* has an object-id field */
                                194                 :                : #define HEAP_XMAX_KEYSHR_LOCK   0x0010  /* xmax is a key-shared locker */
                                195                 :                : #define HEAP_COMBOCID           0x0020  /* t_cid is a combo CID */
                                196                 :                : #define HEAP_XMAX_EXCL_LOCK     0x0040  /* xmax is exclusive locker */
                                197                 :                : #define HEAP_XMAX_LOCK_ONLY     0x0080  /* xmax, if valid, is only a locker */
                                198                 :                : 
                                199                 :                :  /* xmax is a shared locker */
                                200                 :                : #define HEAP_XMAX_SHR_LOCK  (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)
                                201                 :                : 
                                202                 :                : #define HEAP_LOCK_MASK  (HEAP_XMAX_SHR_LOCK | HEAP_XMAX_EXCL_LOCK | \
                                203                 :                :                          HEAP_XMAX_KEYSHR_LOCK)
                                204                 :                : #define HEAP_XMIN_COMMITTED     0x0100  /* t_xmin committed */
                                205                 :                : #define HEAP_XMIN_INVALID       0x0200  /* t_xmin invalid/aborted */
                                206                 :                : #define HEAP_XMIN_FROZEN        (HEAP_XMIN_COMMITTED|HEAP_XMIN_INVALID)
                                207                 :                : #define HEAP_XMAX_COMMITTED     0x0400  /* t_xmax committed */
                                208                 :                : #define HEAP_XMAX_INVALID       0x0800  /* t_xmax invalid/aborted */
                                209                 :                : #define HEAP_XMAX_IS_MULTI      0x1000  /* t_xmax is a MultiXactId */
                                210                 :                : #define HEAP_UPDATED            0x2000  /* this is UPDATEd version of row */
                                211                 :                : #define HEAP_MOVED_OFF          0x4000  /* moved to another place by pre-9.0
                                212                 :                :                                          * VACUUM FULL; kept for binary
                                213                 :                :                                          * upgrade support */
                                214                 :                : #define HEAP_MOVED_IN           0x8000  /* moved from another place by pre-9.0
                                215                 :                :                                          * VACUUM FULL; kept for binary
                                216                 :                :                                          * upgrade support */
                                217                 :                : #define HEAP_MOVED (HEAP_MOVED_OFF | HEAP_MOVED_IN)
                                218                 :                : 
                                219                 :                : #define HEAP_XACT_MASK          0xFFF0  /* visibility-related bits */
                                220                 :                : 
                                221                 :                : /*
                                222                 :                :  * A tuple is only locked (i.e. not updated by its Xmax) if the
                                223                 :                :  * HEAP_XMAX_LOCK_ONLY bit is set; or, for pg_upgrade's sake, if the Xmax is
                                224                 :                :  * not a multi and the EXCL_LOCK bit is set.
                                225                 :                :  *
                                226                 :                :  * See also HeapTupleHeaderIsOnlyLocked, which also checks for a possible
                                227                 :                :  * aborted updater transaction.
                                228                 :                :  *
                                229                 :                :  * Beware of multiple evaluations of the argument.
                                230                 :                :  */
                                231                 :                : #define HEAP_XMAX_IS_LOCKED_ONLY(infomask) \
                                232                 :                :     (((infomask) & HEAP_XMAX_LOCK_ONLY) || \
                                233                 :                :      (((infomask) & (HEAP_XMAX_IS_MULTI | HEAP_LOCK_MASK)) == HEAP_XMAX_EXCL_LOCK))
                                234                 :                : 
                                235                 :                : /*
                                236                 :                :  * A tuple that has HEAP_XMAX_IS_MULTI and HEAP_XMAX_LOCK_ONLY but neither of
                                237                 :                :  * HEAP_XMAX_EXCL_LOCK and HEAP_XMAX_KEYSHR_LOCK must come from a tuple that was
                                238                 :                :  * share-locked in 9.2 or earlier and then pg_upgrade'd.
                                239                 :                :  *
                                240                 :                :  * In 9.2 and prior, HEAP_XMAX_IS_MULTI was only set when there were multiple
                                241                 :                :  * FOR SHARE lockers of that tuple.  That set HEAP_XMAX_LOCK_ONLY (with a
                                242                 :                :  * different name back then) but neither of HEAP_XMAX_EXCL_LOCK and
                                243                 :                :  * HEAP_XMAX_KEYSHR_LOCK.  That combination is no longer possible in 9.3 and
                                244                 :                :  * up, so if we see that combination we know for certain that the tuple was
                                245                 :                :  * locked in an earlier release; since all such lockers are gone (they cannot
                                246                 :                :  * survive through pg_upgrade), such tuples can safely be considered not
                                247                 :                :  * locked.
                                248                 :                :  *
                                249                 :                :  * We must not resolve such multixacts locally, because the result would be
                                250                 :                :  * bogus, regardless of where they stand with respect to the current valid
                                251                 :                :  * multixact range.
                                252                 :                :  */
                                253                 :                : #define HEAP_LOCKED_UPGRADED(infomask) \
                                254                 :                : ( \
                                255                 :                :      ((infomask) & HEAP_XMAX_IS_MULTI) != 0 && \
                                256                 :                :      ((infomask) & HEAP_XMAX_LOCK_ONLY) != 0 && \
                                257                 :                :      (((infomask) & (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)) == 0) \
                                258                 :                : )
                                259                 :                : 
                                260                 :                : /*
                                261                 :                :  * Use these to test whether a particular lock is applied to a tuple
                                262                 :                :  */
                                263                 :                : #define HEAP_XMAX_IS_SHR_LOCKED(infomask) \
                                264                 :                :     (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK)
                                265                 :                : #define HEAP_XMAX_IS_EXCL_LOCKED(infomask) \
                                266                 :                :     (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK)
                                267                 :                : #define HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) \
                                268                 :                :     (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK)
                                269                 :                : 
                                270                 :                : /* turn these all off when Xmax is to change */
                                271                 :                : #define HEAP_XMAX_BITS (HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID | \
                                272                 :                :                         HEAP_XMAX_IS_MULTI | HEAP_LOCK_MASK | HEAP_XMAX_LOCK_ONLY)
                                273                 :                : 
                                274                 :                : /*
                                275                 :                :  * information stored in t_infomask2:
                                276                 :                :  */
                                277                 :                : #define HEAP_NATTS_MASK         0x07FF  /* 11 bits for number of attributes */
                                278                 :                : /* bits 0x1800 are available */
                                279                 :                : #define HEAP_KEYS_UPDATED       0x2000  /* tuple was updated and key cols
                                280                 :                :                                          * modified, or tuple deleted */
                                281                 :                : #define HEAP_HOT_UPDATED        0x4000  /* tuple was HOT-updated */
                                282                 :                : #define HEAP_ONLY_TUPLE         0x8000  /* this is heap-only tuple */
                                283                 :                : 
                                284                 :                : #define HEAP2_XACT_MASK         0xE000  /* visibility-related bits */
                                285                 :                : 
                                286                 :                : /*
                                287                 :                :  * HEAP_TUPLE_HAS_MATCH is a temporary flag used during hash joins.  It is
                                288                 :                :  * only used in tuples that are in the hash table, and those don't need
                                289                 :                :  * any visibility information, so we can overlay it on a visibility flag
                                290                 :                :  * instead of using up a dedicated bit.
                                291                 :                :  */
                                292                 :                : #define HEAP_TUPLE_HAS_MATCH    HEAP_ONLY_TUPLE /* tuple has a join match */
                                293                 :                : 
                                294                 :                : /*
                                295                 :                :  * HeapTupleHeader accessor macros
                                296                 :                :  *
                                297                 :                :  * Note: beware of multiple evaluations of "tup" argument.  But the Set
                                298                 :                :  * macros evaluate their other argument only once.
                                299                 :                :  */
                                300                 :                : 
                                301                 :                : /*
                                302                 :                :  * HeapTupleHeaderGetRawXmin returns the "raw" xmin field, which is the xid
                                303                 :                :  * originally used to insert the tuple.  However, the tuple might actually
                                304                 :                :  * be frozen (via HeapTupleHeaderSetXminFrozen) in which case the tuple's xmin
                                305                 :                :  * is visible to every snapshot.  Prior to PostgreSQL 9.4, we actually changed
                                306                 :                :  * the xmin to FrozenTransactionId, and that value may still be encountered
                                307                 :                :  * on disk.
                                308                 :                :  */
                                309                 :                : #define HeapTupleHeaderGetRawXmin(tup) \
                                310                 :                : ( \
                                311                 :                :     (tup)->t_choice.t_heap.t_xmin \
                                312                 :                : )
                                313                 :                : 
                                314                 :                : #define HeapTupleHeaderGetXmin(tup) \
                                315                 :                : ( \
                                316                 :                :     HeapTupleHeaderXminFrozen(tup) ? \
                                317                 :                :         FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup) \
                                318                 :                : )
                                319                 :                : 
                                320                 :                : #define HeapTupleHeaderSetXmin(tup, xid) \
                                321                 :                : ( \
                                322                 :                :     (tup)->t_choice.t_heap.t_xmin = (xid) \
                                323                 :                : )
                                324                 :                : 
                                325                 :                : #define HeapTupleHeaderXminCommitted(tup) \
                                326                 :                : ( \
                                327                 :                :     ((tup)->t_infomask & HEAP_XMIN_COMMITTED) != 0 \
                                328                 :                : )
                                329                 :                : 
                                330                 :                : #define HeapTupleHeaderXminInvalid(tup) \
                                331                 :                : ( \
                                332                 :                :     ((tup)->t_infomask & (HEAP_XMIN_COMMITTED|HEAP_XMIN_INVALID)) == \
                                333                 :                :         HEAP_XMIN_INVALID \
                                334                 :                : )
                                335                 :                : 
                                336                 :                : #define HeapTupleHeaderXminFrozen(tup) \
                                337                 :                : ( \
                                338                 :                :     ((tup)->t_infomask & (HEAP_XMIN_FROZEN)) == HEAP_XMIN_FROZEN \
                                339                 :                : )
                                340                 :                : 
                                341                 :                : #define HeapTupleHeaderSetXminCommitted(tup) \
                                342                 :                : ( \
                                343                 :                :     AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
                                344                 :                :     ((tup)->t_infomask |= HEAP_XMIN_COMMITTED) \
                                345                 :                : )
                                346                 :                : 
                                347                 :                : #define HeapTupleHeaderSetXminInvalid(tup) \
                                348                 :                : ( \
                                349                 :                :     AssertMacro(!HeapTupleHeaderXminCommitted(tup)), \
                                350                 :                :     ((tup)->t_infomask |= HEAP_XMIN_INVALID) \
                                351                 :                : )
                                352                 :                : 
                                353                 :                : #define HeapTupleHeaderSetXminFrozen(tup) \
                                354                 :                : ( \
                                355                 :                :     AssertMacro(!HeapTupleHeaderXminInvalid(tup)), \
                                356                 :                :     ((tup)->t_infomask |= HEAP_XMIN_FROZEN) \
                                357                 :                : )
                                358                 :                : 
                                359                 :                : /*
                                360                 :                :  * HeapTupleHeaderGetRawXmax gets you the raw Xmax field.  To find out the Xid
                                361                 :                :  * that updated a tuple, you might need to resolve the MultiXactId if certain
                                362                 :                :  * bits are set.  HeapTupleHeaderGetUpdateXid checks those bits and takes care
                                363                 :                :  * to resolve the MultiXactId if necessary.  This might involve multixact I/O,
                                364                 :                :  * so it should only be used if absolutely necessary.
                                365                 :                :  */
                                366                 :                : #define HeapTupleHeaderGetUpdateXid(tup) \
                                367                 :                : ( \
                                368                 :                :     (!((tup)->t_infomask & HEAP_XMAX_INVALID) && \
                                369                 :                :      ((tup)->t_infomask & HEAP_XMAX_IS_MULTI) && \
                                370                 :                :      !((tup)->t_infomask & HEAP_XMAX_LOCK_ONLY)) ? \
                                371                 :                :         HeapTupleGetUpdateXid(tup) \
                                372                 :                :     : \
                                373                 :                :         HeapTupleHeaderGetRawXmax(tup) \
                                374                 :                : )
                                375                 :                : 
                                376                 :                : #define HeapTupleHeaderGetRawXmax(tup) \
                                377                 :                : ( \
                                378                 :                :     (tup)->t_choice.t_heap.t_xmax \
                                379                 :                : )
                                380                 :                : 
                                381                 :                : #define HeapTupleHeaderSetXmax(tup, xid) \
                                382                 :                : ( \
                                383                 :                :     (tup)->t_choice.t_heap.t_xmax = (xid) \
                                384                 :                : )
                                385                 :                : 
                                386                 :                : /*
                                387                 :                :  * HeapTupleHeaderGetRawCommandId will give you what's in the header whether
                                388                 :                :  * it is useful or not.  Most code should use HeapTupleHeaderGetCmin or
                                389                 :                :  * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
                                390                 :                :  * get a legitimate result, ie you are in the originating transaction!
                                391                 :                :  */
                                392                 :                : #define HeapTupleHeaderGetRawCommandId(tup) \
                                393                 :                : ( \
                                394                 :                :     (tup)->t_choice.t_heap.t_field3.t_cid \
                                395                 :                : )
                                396                 :                : 
                                397                 :                : /* SetCmin is reasonably simple since we never need a combo CID */
                                398                 :                : #define HeapTupleHeaderSetCmin(tup, cid) \
                                399                 :                : do { \
                                400                 :                :     Assert(!((tup)->t_infomask & HEAP_MOVED)); \
                                401                 :                :     (tup)->t_choice.t_heap.t_field3.t_cid = (cid); \
                                402                 :                :     (tup)->t_infomask &= ~HEAP_COMBOCID; \
                                403                 :                : } while (0)
                                404                 :                : 
                                405                 :                : /* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
                                406                 :                : #define HeapTupleHeaderSetCmax(tup, cid, iscombo) \
                                407                 :                : do { \
                                408                 :                :     Assert(!((tup)->t_infomask & HEAP_MOVED)); \
                                409                 :                :     (tup)->t_choice.t_heap.t_field3.t_cid = (cid); \
                                410                 :                :     if (iscombo) \
                                411                 :                :         (tup)->t_infomask |= HEAP_COMBOCID; \
                                412                 :                :     else \
                                413                 :                :         (tup)->t_infomask &= ~HEAP_COMBOCID; \
                                414                 :                : } while (0)
                                415                 :                : 
                                416                 :                : #define HeapTupleHeaderGetXvac(tup) \
                                417                 :                : ( \
                                418                 :                :     ((tup)->t_infomask & HEAP_MOVED) ? \
                                419                 :                :         (tup)->t_choice.t_heap.t_field3.t_xvac \
                                420                 :                :     : \
                                421                 :                :         InvalidTransactionId \
                                422                 :                : )
                                423                 :                : 
                                424                 :                : #define HeapTupleHeaderSetXvac(tup, xid) \
                                425                 :                : do { \
                                426                 :                :     Assert((tup)->t_infomask & HEAP_MOVED); \
                                427                 :                :     (tup)->t_choice.t_heap.t_field3.t_xvac = (xid); \
                                428                 :                : } while (0)
                                429                 :                : 
                                430                 :                : StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
                                431                 :                :                  "invalid speculative token constant");
                                432                 :                : 
                                433                 :                : #define HeapTupleHeaderIsSpeculative(tup) \
                                434                 :                : ( \
                                435                 :                :     (ItemPointerGetOffsetNumberNoCheck(&(tup)->t_ctid) == SpecTokenOffsetNumber) \
                                436                 :                : )
                                437                 :                : 
                                438                 :                : #define HeapTupleHeaderGetSpeculativeToken(tup) \
                                439                 :                : ( \
                                440                 :                :     AssertMacro(HeapTupleHeaderIsSpeculative(tup)), \
                                441                 :                :     ItemPointerGetBlockNumber(&(tup)->t_ctid) \
                                442                 :                : )
                                443                 :                : 
                                444                 :                : #define HeapTupleHeaderSetSpeculativeToken(tup, token)  \
                                445                 :                : ( \
                                446                 :                :     ItemPointerSet(&(tup)->t_ctid, token, SpecTokenOffsetNumber) \
                                447                 :                : )
                                448                 :                : 
                                449                 :                : #define HeapTupleHeaderIndicatesMovedPartitions(tup) \
                                450                 :                :     ItemPointerIndicatesMovedPartitions(&(tup)->t_ctid)
                                451                 :                : 
                                452                 :                : #define HeapTupleHeaderSetMovedPartitions(tup) \
                                453                 :                :     ItemPointerSetMovedPartitions(&(tup)->t_ctid)
                                454                 :                : 
                                455                 :                : #define HeapTupleHeaderGetDatumLength(tup) \
                                456                 :                :     VARSIZE(tup)
                                457                 :                : 
                                458                 :                : #define HeapTupleHeaderSetDatumLength(tup, len) \
                                459                 :                :     SET_VARSIZE(tup, len)
                                460                 :                : 
                                461                 :                : #define HeapTupleHeaderGetTypeId(tup) \
                                462                 :                : ( \
                                463                 :                :     (tup)->t_choice.t_datum.datum_typeid \
                                464                 :                : )
                                465                 :                : 
                                466                 :                : #define HeapTupleHeaderSetTypeId(tup, typeid) \
                                467                 :                : ( \
                                468                 :                :     (tup)->t_choice.t_datum.datum_typeid = (typeid) \
                                469                 :                : )
                                470                 :                : 
                                471                 :                : #define HeapTupleHeaderGetTypMod(tup) \
                                472                 :                : ( \
                                473                 :                :     (tup)->t_choice.t_datum.datum_typmod \
                                474                 :                : )
                                475                 :                : 
                                476                 :                : #define HeapTupleHeaderSetTypMod(tup, typmod) \
                                477                 :                : ( \
                                478                 :                :     (tup)->t_choice.t_datum.datum_typmod = (typmod) \
                                479                 :                : )
                                480                 :                : 
                                481                 :                : /*
                                482                 :                :  * Note that we stop considering a tuple HOT-updated as soon as it is known
                                483                 :                :  * aborted or the would-be updating transaction is known aborted.  For best
                                484                 :                :  * efficiency, check tuple visibility before using this macro, so that the
                                485                 :                :  * INVALID bits will be as up to date as possible.
                                486                 :                :  */
                                487                 :                : #define HeapTupleHeaderIsHotUpdated(tup) \
                                488                 :                : ( \
                                489                 :                :     ((tup)->t_infomask2 & HEAP_HOT_UPDATED) != 0 && \
                                490                 :                :     ((tup)->t_infomask & HEAP_XMAX_INVALID) == 0 && \
                                491                 :                :     !HeapTupleHeaderXminInvalid(tup) \
                                492                 :                : )
                                493                 :                : 
                                494                 :                : #define HeapTupleHeaderSetHotUpdated(tup) \
                                495                 :                : ( \
                                496                 :                :     (tup)->t_infomask2 |= HEAP_HOT_UPDATED \
                                497                 :                : )
                                498                 :                : 
                                499                 :                : #define HeapTupleHeaderClearHotUpdated(tup) \
                                500                 :                : ( \
                                501                 :                :     (tup)->t_infomask2 &= ~HEAP_HOT_UPDATED \
                                502                 :                : )
                                503                 :                : 
                                504                 :                : #define HeapTupleHeaderIsHeapOnly(tup) \
                                505                 :                : ( \
                                506                 :                :   ((tup)->t_infomask2 & HEAP_ONLY_TUPLE) != 0 \
                                507                 :                : )
                                508                 :                : 
                                509                 :                : #define HeapTupleHeaderSetHeapOnly(tup) \
                                510                 :                : ( \
                                511                 :                :   (tup)->t_infomask2 |= HEAP_ONLY_TUPLE \
                                512                 :                : )
                                513                 :                : 
                                514                 :                : #define HeapTupleHeaderClearHeapOnly(tup) \
                                515                 :                : ( \
                                516                 :                :   (tup)->t_infomask2 &= ~HEAP_ONLY_TUPLE \
                                517                 :                : )
                                518                 :                : 
                                519                 :                : #define HeapTupleHeaderHasMatch(tup) \
                                520                 :                : ( \
                                521                 :                :   ((tup)->t_infomask2 & HEAP_TUPLE_HAS_MATCH) != 0 \
                                522                 :                : )
                                523                 :                : 
                                524                 :                : #define HeapTupleHeaderSetMatch(tup) \
                                525                 :                : ( \
                                526                 :                :   (tup)->t_infomask2 |= HEAP_TUPLE_HAS_MATCH \
                                527                 :                : )
                                528                 :                : 
                                529                 :                : #define HeapTupleHeaderClearMatch(tup) \
                                530                 :                : ( \
                                531                 :                :   (tup)->t_infomask2 &= ~HEAP_TUPLE_HAS_MATCH \
                                532                 :                : )
                                533                 :                : 
                                534                 :                : #define HeapTupleHeaderGetNatts(tup) \
                                535                 :                :     ((tup)->t_infomask2 & HEAP_NATTS_MASK)
                                536                 :                : 
                                537                 :                : #define HeapTupleHeaderSetNatts(tup, natts) \
                                538                 :                : ( \
                                539                 :                :     (tup)->t_infomask2 = ((tup)->t_infomask2 & ~HEAP_NATTS_MASK) | (natts) \
                                540                 :                : )
                                541                 :                : 
                                542                 :                : #define HeapTupleHeaderHasExternal(tup) \
                                543                 :                :         (((tup)->t_infomask & HEAP_HASEXTERNAL) != 0)
                                544                 :                : 
                                545                 :                : 
                                546                 :                : /*
                                547                 :                :  * BITMAPLEN(NATTS) -
                                548                 :                :  *      Computes size of null bitmap given number of data columns.
                                549                 :                :  */
                                550                 :                : #define BITMAPLEN(NATTS)    (((int)(NATTS) + 7) / 8)
                                551                 :                : 
                                552                 :                : /*
                                553                 :                :  * MaxHeapTupleSize is the maximum allowed size of a heap tuple, including
                                554                 :                :  * header and MAXALIGN alignment padding.  Basically it's BLCKSZ minus the
                                555                 :                :  * other stuff that has to be on a disk page.  Since heap pages use no
                                556                 :                :  * "special space", there's no deduction for that.
                                557                 :                :  *
                                558                 :                :  * NOTE: we allow for the ItemId that must point to the tuple, ensuring that
                                559                 :                :  * an otherwise-empty page can indeed hold a tuple of this size.  Because
                                560                 :                :  * ItemIds and tuples have different alignment requirements, don't assume that
                                561                 :                :  * you can, say, fit 2 tuples of size MaxHeapTupleSize/2 on the same page.
                                562                 :                :  */
                                563                 :                : #define MaxHeapTupleSize  (BLCKSZ - MAXALIGN(SizeOfPageHeaderData + sizeof(ItemIdData)))
                                564                 :                : #define MinHeapTupleSize  MAXALIGN(SizeofHeapTupleHeader)
                                565                 :                : 
                                566                 :                : /*
                                567                 :                :  * MaxHeapTuplesPerPage is an upper bound on the number of tuples that can
                                568                 :                :  * fit on one heap page.  (Note that indexes could have more, because they
                                569                 :                :  * use a smaller tuple header.)  We arrive at the divisor because each tuple
                                570                 :                :  * must be maxaligned, and it must have an associated line pointer.
                                571                 :                :  *
                                572                 :                :  * Note: with HOT, there could theoretically be more line pointers (not actual
                                573                 :                :  * tuples) than this on a heap page.  However we constrain the number of line
                                574                 :                :  * pointers to this anyway, to avoid excessive line-pointer bloat and not
                                575                 :                :  * require increases in the size of work arrays.
                                576                 :                :  */
                                577                 :                : #define MaxHeapTuplesPerPage    \
                                578                 :                :     ((int) ((BLCKSZ - SizeOfPageHeaderData) / \
                                579                 :                :             (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))))
                                580                 :                : 
                                581                 :                : /*
                                582                 :                :  * MaxAttrSize is a somewhat arbitrary upper limit on the declared size of
                                583                 :                :  * data fields of char(n) and similar types.  It need not have anything
                                584                 :                :  * directly to do with the *actual* upper limit of varlena values, which
                                585                 :                :  * is currently 1Gb (see TOAST structures in postgres.h).  I've set it
                                586                 :                :  * at 10Mb which seems like a reasonable number --- tgl 8/6/00.
                                587                 :                :  */
                                588                 :                : #define MaxAttrSize     (10 * 1024 * 1024)
                                589                 :                : 
                                590                 :                : 
                                591                 :                : /*
                                592                 :                :  * MinimalTuple is an alternative representation that is used for transient
                                593                 :                :  * tuples inside the executor, in places where transaction status information
                                594                 :                :  * is not required, the tuple rowtype is known, and shaving off a few bytes
                                595                 :                :  * is worthwhile because we need to store many tuples.  The representation
                                596                 :                :  * is chosen so that tuple access routines can work with either full or
                                597                 :                :  * minimal tuples via a HeapTupleData pointer structure.  The access routines
                                598                 :                :  * see no difference, except that they must not access the transaction status
                                599                 :                :  * or t_ctid fields because those aren't there.
                                600                 :                :  *
                                601                 :                :  * For the most part, MinimalTuples should be accessed via TupleTableSlot
                                602                 :                :  * routines.  These routines will prevent access to the "system columns"
                                603                 :                :  * and thereby prevent accidental use of the nonexistent fields.
                                604                 :                :  *
                                605                 :                :  * MinimalTupleData contains a length word, some padding, and fields matching
                                606                 :                :  * HeapTupleHeaderData beginning with t_infomask2. The padding is chosen so
                                607                 :                :  * that offsetof(t_infomask2) is the same modulo MAXIMUM_ALIGNOF in both
                                608                 :                :  * structs.   This makes data alignment rules equivalent in both cases.
                                609                 :                :  *
                                610                 :                :  * When a minimal tuple is accessed via a HeapTupleData pointer, t_data is
                                611                 :                :  * set to point MINIMAL_TUPLE_OFFSET bytes before the actual start of the
                                612                 :                :  * minimal tuple --- that is, where a full tuple matching the minimal tuple's
                                613                 :                :  * data would start.  This trick is what makes the structs seem equivalent.
                                614                 :                :  *
                                615                 :                :  * Note that t_hoff is computed the same as in a full tuple, hence it includes
                                616                 :                :  * the MINIMAL_TUPLE_OFFSET distance.  t_len does not include that, however.
                                617                 :                :  *
                                618                 :                :  * MINIMAL_TUPLE_DATA_OFFSET is the offset to the first useful (non-pad) data
                                619                 :                :  * other than the length word.  tuplesort.c and tuplestore.c use this to avoid
                                620                 :                :  * writing the padding to disk.
                                621                 :                :  */
                                622                 :                : #define MINIMAL_TUPLE_OFFSET \
                                623                 :                :     ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) / MAXIMUM_ALIGNOF * MAXIMUM_ALIGNOF)
                                624                 :                : #define MINIMAL_TUPLE_PADDING \
                                625                 :                :     ((offsetof(HeapTupleHeaderData, t_infomask2) - sizeof(uint32)) % MAXIMUM_ALIGNOF)
                                626                 :                : #define MINIMAL_TUPLE_DATA_OFFSET \
                                627                 :                :     offsetof(MinimalTupleData, t_infomask2)
                                628                 :                : 
                                629                 :                : struct MinimalTupleData
                                630                 :                : {
                                631                 :                :     uint32      t_len;          /* actual length of minimal tuple */
                                632                 :                : 
                                633                 :                :     char        mt_padding[MINIMAL_TUPLE_PADDING];
                                634                 :                : 
                                635                 :                :     /* Fields below here must match HeapTupleHeaderData! */
                                636                 :                : 
                                637                 :                :     uint16      t_infomask2;    /* number of attributes + various flags */
                                638                 :                : 
                                639                 :                :     uint16      t_infomask;     /* various flag bits, see below */
                                640                 :                : 
                                641                 :                :     uint8       t_hoff;         /* sizeof header incl. bitmap, padding */
                                642                 :                : 
                                643                 :                :     /* ^ - 23 bytes - ^ */
                                644                 :                : 
                                645                 :                :     bits8       t_bits[FLEXIBLE_ARRAY_MEMBER];  /* bitmap of NULLs */
                                646                 :                : 
                                647                 :                :     /* MORE DATA FOLLOWS AT END OF STRUCT */
                                648                 :                : };
                                649                 :                : 
                                650                 :                : /* typedef appears in htup.h */
                                651                 :                : 
                                652                 :                : #define SizeofMinimalTupleHeader offsetof(MinimalTupleData, t_bits)
                                653                 :                : 
                                654                 :                : 
                                655                 :                : /*
                                656                 :                :  * GETSTRUCT - given a HeapTuple pointer, return address of the user data
                                657                 :                :  */
                                658                 :                : #define GETSTRUCT(TUP) ((char *) ((TUP)->t_data) + (TUP)->t_data->t_hoff)
                                659                 :                : 
                                660                 :                : /*
                                661                 :                :  * Accessor macros to be used with HeapTuple pointers.
                                662                 :                :  */
                                663                 :                : 
                                664                 :                : #define HeapTupleHasNulls(tuple) \
                                665                 :                :         (((tuple)->t_data->t_infomask & HEAP_HASNULL) != 0)
                                666                 :                : 
                                667                 :                : #define HeapTupleNoNulls(tuple) \
                                668                 :                :         (!((tuple)->t_data->t_infomask & HEAP_HASNULL))
                                669                 :                : 
                                670                 :                : #define HeapTupleHasVarWidth(tuple) \
                                671                 :                :         (((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH) != 0)
                                672                 :                : 
                                673                 :                : #define HeapTupleAllFixed(tuple) \
                                674                 :                :         (!((tuple)->t_data->t_infomask & HEAP_HASVARWIDTH))
                                675                 :                : 
                                676                 :                : #define HeapTupleHasExternal(tuple) \
                                677                 :                :         (((tuple)->t_data->t_infomask & HEAP_HASEXTERNAL) != 0)
                                678                 :                : 
                                679                 :                : #define HeapTupleIsHotUpdated(tuple) \
                                680                 :                :         HeapTupleHeaderIsHotUpdated((tuple)->t_data)
                                681                 :                : 
                                682                 :                : #define HeapTupleSetHotUpdated(tuple) \
                                683                 :                :         HeapTupleHeaderSetHotUpdated((tuple)->t_data)
                                684                 :                : 
                                685                 :                : #define HeapTupleClearHotUpdated(tuple) \
                                686                 :                :         HeapTupleHeaderClearHotUpdated((tuple)->t_data)
                                687                 :                : 
                                688                 :                : #define HeapTupleIsHeapOnly(tuple) \
                                689                 :                :         HeapTupleHeaderIsHeapOnly((tuple)->t_data)
                                690                 :                : 
                                691                 :                : #define HeapTupleSetHeapOnly(tuple) \
                                692                 :                :         HeapTupleHeaderSetHeapOnly((tuple)->t_data)
                                693                 :                : 
                                694                 :                : #define HeapTupleClearHeapOnly(tuple) \
                                695                 :                :         HeapTupleHeaderClearHeapOnly((tuple)->t_data)
                                696                 :                : 
                                697                 :                : /* prototypes for functions in common/heaptuple.c */
                                698                 :                : extern Size heap_compute_data_size(TupleDesc tupleDesc,
                                699                 :                :                                    const Datum *values, const bool *isnull);
                                700                 :                : extern void heap_fill_tuple(TupleDesc tupleDesc,
                                701                 :                :                             const Datum *values, const bool *isnull,
                                702                 :                :                             char *data, Size data_size,
                                703                 :                :                             uint16 *infomask, bits8 *bit);
                                704                 :                : extern bool heap_attisnull(HeapTuple tup, int attnum, TupleDesc tupleDesc);
                                705                 :                : extern Datum nocachegetattr(HeapTuple tup, int attnum,
                                706                 :                :                             TupleDesc tupleDesc);
                                707                 :                : extern Datum heap_getsysattr(HeapTuple tup, int attnum, TupleDesc tupleDesc,
                                708                 :                :                              bool *isnull);
                                709                 :                : extern Datum getmissingattr(TupleDesc tupleDesc,
                                710                 :                :                             int attnum, bool *isnull);
                                711                 :                : extern HeapTuple heap_copytuple(HeapTuple tuple);
                                712                 :                : extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest);
                                713                 :                : extern Datum heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc);
                                714                 :                : extern HeapTuple heap_form_tuple(TupleDesc tupleDescriptor,
                                715                 :                :                                  const Datum *values, const bool *isnull);
                                716                 :                : extern HeapTuple heap_modify_tuple(HeapTuple tuple,
                                717                 :                :                                    TupleDesc tupleDesc,
                                718                 :                :                                    const Datum *replValues,
                                719                 :                :                                    const bool *replIsnull,
                                720                 :                :                                    const bool *doReplace);
                                721                 :                : extern HeapTuple heap_modify_tuple_by_cols(HeapTuple tuple,
                                722                 :                :                                            TupleDesc tupleDesc,
                                723                 :                :                                            int nCols,
                                724                 :                :                                            const int *replCols,
                                725                 :                :                                            const Datum *replValues,
                                726                 :                :                                            const bool *replIsnull);
                                727                 :                : extern void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
                                728                 :                :                               Datum *values, bool *isnull);
                                729                 :                : extern void heap_freetuple(HeapTuple htup);
                                730                 :                : extern MinimalTuple heap_form_minimal_tuple(TupleDesc tupleDescriptor,
                                731                 :                :                                             const Datum *values, const bool *isnull);
                                732                 :                : extern void heap_free_minimal_tuple(MinimalTuple mtup);
                                733                 :                : extern MinimalTuple heap_copy_minimal_tuple(MinimalTuple mtup);
                                734                 :                : extern HeapTuple heap_tuple_from_minimal_tuple(MinimalTuple mtup);
                                735                 :                : extern MinimalTuple minimal_tuple_from_heap_tuple(HeapTuple htup);
                                736                 :                : extern size_t varsize_any(void *p);
                                737                 :                : extern HeapTuple heap_expand_tuple(HeapTuple sourceTuple, TupleDesc tupleDesc);
                                738                 :                : extern MinimalTuple minimal_expand_tuple(HeapTuple sourceTuple, TupleDesc tupleDesc);
                                739                 :                : 
                                740                 :                : #ifndef FRONTEND
                                741                 :                : /*
                                742                 :                :  *  fastgetattr
                                743                 :                :  *      Fetch a user attribute's value as a Datum (might be either a
                                744                 :                :  *      value, or a pointer into the data area of the tuple).
                                745                 :                :  *
                                746                 :                :  *      This must not be used when a system attribute might be requested.
                                747                 :                :  *      Furthermore, the passed attnum MUST be valid.  Use heap_getattr()
                                748                 :                :  *      instead, if in doubt.
                                749                 :                :  *
                                750                 :                :  *      This gets called many times, so we macro the cacheable and NULL
                                751                 :                :  *      lookups, and call nocachegetattr() for the rest.
                                752                 :                :  */
                                753                 :                : static inline Datum
  752 alvherre@alvh.no-ip.      754                 :CBC   126699860 : fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
                                755                 :                : {
  739 peter@eisentraut.org      756         [ -  + ]:      126699860 :     Assert(attnum > 0);
                                757                 :                : 
  752 alvherre@alvh.no-ip.      758                 :      126699860 :     *isnull = false;
                                759         [ +  + ]:      126699860 :     if (HeapTupleNoNulls(tup))
                                760                 :                :     {
                                761                 :                :         Form_pg_attribute att;
                                762                 :                : 
                                763                 :       55199875 :         att = TupleDescAttr(tupleDesc, attnum - 1);
                                764         [ +  + ]:       55199875 :         if (att->attcacheoff >= 0)
                                765                 :       33844234 :             return fetchatt(att, (char *) tup->t_data + tup->t_data->t_hoff +
                                766                 :                :                             att->attcacheoff);
                                767                 :                :         else
                                768                 :       21355641 :             return nocachegetattr(tup, attnum, tupleDesc);
                                769                 :                :     }
                                770                 :                :     else
                                771                 :                :     {
                                772         [ +  + ]:       71499985 :         if (att_isnull(attnum - 1, tup->t_data->t_bits))
                                773                 :                :         {
                                774                 :        8392627 :             *isnull = true;
                                775                 :        8392627 :             return (Datum) NULL;
                                776                 :                :         }
                                777                 :                :         else
                                778                 :       63107358 :             return nocachegetattr(tup, attnum, tupleDesc);
                                779                 :                :     }
                                780                 :                : }
                                781                 :                : 
                                782                 :                : /*
                                783                 :                :  *  heap_getattr
                                784                 :                :  *      Extract an attribute of a heap tuple and return it as a Datum.
                                785                 :                :  *      This works for either system or user attributes.  The given attnum
                                786                 :                :  *      is properly range-checked.
                                787                 :                :  *
                                788                 :                :  *      If the field in question has a NULL value, we return a zero Datum
                                789                 :                :  *      and set *isnull == true.  Otherwise, we set *isnull == false.
                                790                 :                :  *
                                791                 :                :  *      <tup> is the pointer to the heap tuple.  <attnum> is the attribute
                                792                 :                :  *      number of the column (field) caller wants.  <tupleDesc> is a
                                793                 :                :  *      pointer to the structure describing the row and all its fields.
                                794                 :                :  *
                                795                 :                :  */
                                796                 :                : static inline Datum
                                797                 :      118643842 : heap_getattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
                                798                 :                : {
                                799         [ +  - ]:      118643842 :     if (attnum > 0)
                                800                 :                :     {
                                801         [ +  + ]:      118643842 :         if (attnum > (int) HeapTupleHeaderGetNatts(tup->t_data))
                                802                 :            166 :             return getmissingattr(tupleDesc, attnum, isnull);
                                803                 :                :         else
                                804                 :      118643676 :             return fastgetattr(tup, attnum, tupleDesc, isnull);
                                805                 :                :     }
                                806                 :                :     else
  752 alvherre@alvh.no-ip.      807                 :UBC           0 :         return heap_getsysattr(tup, attnum, tupleDesc, isnull);
                                808                 :                : }
                                809                 :                : #endif                          /* FRONTEND */
                                810                 :                : 
                                811                 :                : #endif                          /* HTUP_DETAILS_H */
        

Generated by: LCOV version 2.1-beta2-3-g6141622