All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a069.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, t_natts bits altogether). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a069.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a069.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a069.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a069.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a069.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a069.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a069.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a069.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a070.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a070.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a070.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a073.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a073.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a073.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a073.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a073.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a073.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a065.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a065.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a065.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a066.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a066.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a066.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a066.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a066.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a066.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a066.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a066.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a066.2).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on most machines), followed by an optional null bitmap, an optional object ID field, and the user data. The header is detailed in Table\u00a066.4. The actual user data (columns of the row) begins at the offset indicated by t_hoff, which must always be a multiple of the MAXALIGN distance for the platform. The null bitmap is only present if the HEAP_HASNULL bit is set in t_infomask. If it is present it begins just after the fixed header and occupies enough bytes to have one bit per data column (that is, the number of bits that equals the attribute count in t_infomask2). In this list of bits, a 1 bit indicates not-null, a 0 bit is a null. When the bitmap is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID_OLD bit is set in t_infomask. If present, it appears just before the t_hoff boundary. Any padding needed to make t_hoff a MAXALIGN multiple will appear between the null bitmap and the object ID. (This in turn ensures that the object ID is suitably aligned.)
Table\u00a066.4.\u00a0HeapTupleHeaderData Layout
\n| Field | \nType | \nLength | \nDescription | \n
|---|---|---|---|
| t_xmin | \nTransactionId | \n4 bytes | \ninsert XID stamp | \n
| t_xmax | \nTransactionId | \n4 bytes | \ndelete XID stamp | \n
| t_cid | \nCommandId | \n4 bytes | \ninsert and/or delete CID stamp (overlays with t_xvac) | \n
| t_xvac | \nTransactionId | \n4 bytes | \nXID for VACUUM operation moving a row version | \n
| t_ctid | \nItemPointerData | \n6 bytes | \ncurrent TID of this or newer row version | \n
| t_infomask2 | \nuint16 | \n2 bytes | \nnumber of attributes, plus various flag bits | \n
| t_infomask | \nuint16 | \n2 bytes | \nvarious flag bits | \n
| t_hoff | \nuint8 | \n1 byte | \noffset to user data | \n
All the details can be found in src/include/access/htup_details.h.
Interpreting the actual data can only be done with information obtained from other tables, mostly pg_attribute. The key values needed to identify field locations are attlen and attalign. There is no way to directly get a particular attribute, except when there are only fixed width fields and no null values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment. If the field is a fixed width field, then all the bytes are simply placed. If it's a variable length field (attlen = -1) then it's a bit more complicated. All variable-length data types share the common header structure struct varlena, which includes the total length of the stored value and some flag bits. Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed, too (see Section\u00a066.2).