PostgreSQL Source Code  git master
heapam_xlog.h File Reference
#include "access/htup.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/buf.h"
#include "storage/bufpage.h"
#include "storage/relfilenode.h"
#include "utils/relcache.h"
Include dependency graph for heapam_xlog.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  xl_heap_delete
 
struct  xl_heap_truncate
 
struct  xl_heap_header
 
struct  xl_heap_insert
 
struct  xl_heap_multi_insert
 
struct  xl_multi_insert_tuple
 
struct  xl_heap_update
 
struct  xl_heap_clean
 
struct  xl_heap_cleanup_info
 
struct  xl_heap_lock
 
struct  xl_heap_lock_updated
 
struct  xl_heap_confirm
 
struct  xl_heap_inplace
 
struct  xl_heap_freeze_tuple
 
struct  xl_heap_freeze_page
 
struct  xl_heap_visible
 
struct  xl_heap_new_cid
 
struct  xl_heap_rewrite_mapping
 

Macros

#define XLOG_HEAP_INSERT   0x00
 
#define XLOG_HEAP_DELETE   0x10
 
#define XLOG_HEAP_UPDATE   0x20
 
#define XLOG_HEAP_TRUNCATE   0x30
 
#define XLOG_HEAP_HOT_UPDATE   0x40
 
#define XLOG_HEAP_CONFIRM   0x50
 
#define XLOG_HEAP_LOCK   0x60
 
#define XLOG_HEAP_INPLACE   0x70
 
#define XLOG_HEAP_OPMASK   0x70
 
#define XLOG_HEAP_INIT_PAGE   0x80
 
#define XLOG_HEAP2_REWRITE   0x00
 
#define XLOG_HEAP2_CLEAN   0x10
 
#define XLOG_HEAP2_FREEZE_PAGE   0x20
 
#define XLOG_HEAP2_CLEANUP_INFO   0x30
 
#define XLOG_HEAP2_VISIBLE   0x40
 
#define XLOG_HEAP2_MULTI_INSERT   0x50
 
#define XLOG_HEAP2_LOCK_UPDATED   0x60
 
#define XLOG_HEAP2_NEW_CID   0x70
 
#define XLH_INSERT_ALL_VISIBLE_CLEARED   (1<<0)
 
#define XLH_INSERT_LAST_IN_MULTI   (1<<1)
 
#define XLH_INSERT_IS_SPECULATIVE   (1<<2)
 
#define XLH_INSERT_CONTAINS_NEW_TUPLE   (1<<3)
 
#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED   (1<<0)
 
#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED   (1<<1)
 
#define XLH_UPDATE_CONTAINS_OLD_TUPLE   (1<<2)
 
#define XLH_UPDATE_CONTAINS_OLD_KEY   (1<<3)
 
#define XLH_UPDATE_CONTAINS_NEW_TUPLE   (1<<4)
 
#define XLH_UPDATE_PREFIX_FROM_OLD   (1<<5)
 
#define XLH_UPDATE_SUFFIX_FROM_OLD   (1<<6)
 
#define XLH_UPDATE_CONTAINS_OLD   (XLH_UPDATE_CONTAINS_OLD_TUPLE | XLH_UPDATE_CONTAINS_OLD_KEY)
 
#define XLH_DELETE_ALL_VISIBLE_CLEARED   (1<<0)
 
#define XLH_DELETE_CONTAINS_OLD_TUPLE   (1<<1)
 
#define XLH_DELETE_CONTAINS_OLD_KEY   (1<<2)
 
#define XLH_DELETE_IS_SUPER   (1<<3)
 
#define XLH_DELETE_IS_PARTITION_MOVE   (1<<4)
 
#define XLH_DELETE_CONTAINS_OLD   (XLH_DELETE_CONTAINS_OLD_TUPLE | XLH_DELETE_CONTAINS_OLD_KEY)
 
#define SizeOfHeapDelete   (offsetof(xl_heap_delete, flags) + sizeof(uint8))
 
#define XLH_TRUNCATE_CASCADE   (1<<0)
 
#define XLH_TRUNCATE_RESTART_SEQS   (1<<1)
 
#define SizeOfHeapTruncate   (offsetof(xl_heap_truncate, relids))
 
#define SizeOfHeapHeader   (offsetof(xl_heap_header, t_hoff) + sizeof(uint8))
 
#define SizeOfHeapInsert   (offsetof(xl_heap_insert, flags) + sizeof(uint8))
 
#define SizeOfHeapMultiInsert   offsetof(xl_heap_multi_insert, offsets)
 
#define SizeOfMultiInsertTuple   (offsetof(xl_multi_insert_tuple, t_hoff) + sizeof(uint8))
 
#define SizeOfHeapUpdate   (offsetof(xl_heap_update, new_offnum) + sizeof(OffsetNumber))
 
#define SizeOfHeapClean   (offsetof(xl_heap_clean, ndead) + sizeof(uint16))
 
#define SizeOfHeapCleanupInfo   (sizeof(xl_heap_cleanup_info))
 
#define XLHL_XMAX_IS_MULTI   0x01
 
#define XLHL_XMAX_LOCK_ONLY   0x02
 
#define XLHL_XMAX_EXCL_LOCK   0x04
 
#define XLHL_XMAX_KEYSHR_LOCK   0x08
 
#define XLHL_KEYS_UPDATED   0x10
 
#define XLH_LOCK_ALL_FROZEN_CLEARED   0x01
 
#define SizeOfHeapLock   (offsetof(xl_heap_lock, flags) + sizeof(int8))
 
#define SizeOfHeapLockUpdated   (offsetof(xl_heap_lock_updated, flags) + sizeof(uint8))
 
#define SizeOfHeapConfirm   (offsetof(xl_heap_confirm, offnum) + sizeof(OffsetNumber))
 
#define SizeOfHeapInplace   (offsetof(xl_heap_inplace, offnum) + sizeof(OffsetNumber))
 
#define XLH_FREEZE_XVAC   0x02
 
#define XLH_INVALID_XVAC   0x04
 
#define SizeOfHeapFreezePage   (offsetof(xl_heap_freeze_page, ntuples) + sizeof(uint16))
 
#define SizeOfHeapVisible   (offsetof(xl_heap_visible, flags) + sizeof(uint8))
 
#define SizeOfHeapNewCid   (offsetof(xl_heap_new_cid, target_tid) + sizeof(ItemPointerData))
 

Typedefs

typedef struct xl_heap_delete xl_heap_delete
 
typedef struct xl_heap_truncate xl_heap_truncate
 
typedef struct xl_heap_header xl_heap_header
 
typedef struct xl_heap_insert xl_heap_insert
 
typedef struct xl_heap_multi_insert xl_heap_multi_insert
 
typedef struct xl_multi_insert_tuple xl_multi_insert_tuple
 
typedef struct xl_heap_update xl_heap_update
 
typedef struct xl_heap_clean xl_heap_clean
 
typedef struct xl_heap_cleanup_info xl_heap_cleanup_info
 
typedef struct xl_heap_lock xl_heap_lock
 
typedef struct xl_heap_lock_updated xl_heap_lock_updated
 
typedef struct xl_heap_confirm xl_heap_confirm
 
typedef struct xl_heap_inplace xl_heap_inplace
 
typedef struct xl_heap_freeze_tuple xl_heap_freeze_tuple
 
typedef struct xl_heap_freeze_page xl_heap_freeze_page
 
typedef struct xl_heap_visible xl_heap_visible
 
typedef struct xl_heap_new_cid xl_heap_new_cid
 
typedef struct xl_heap_rewrite_mapping xl_heap_rewrite_mapping
 

Functions

void HeapTupleHeaderAdvanceLatestRemovedXid (HeapTupleHeader tuple, TransactionId *latestRemovedXid)
 
void heap_redo (XLogReaderState *record)
 
void heap_desc (StringInfo buf, XLogReaderState *record)
 
const char * heap_identify (uint8 info)
 
void heap_mask (char *pagedata, BlockNumber blkno)
 
void heap2_redo (XLogReaderState *record)
 
void heap2_desc (StringInfo buf, XLogReaderState *record)
 
const char * heap2_identify (uint8 info)
 
void heap_xlog_logical_rewrite (XLogReaderState *r)
 
XLogRecPtr log_heap_cleanup_info (RelFileNode rnode, TransactionId latestRemovedXid)
 
XLogRecPtr log_heap_clean (Relation reln, Buffer buffer, OffsetNumber *redirected, int nredirected, OffsetNumber *nowdead, int ndead, OffsetNumber *nowunused, int nunused, TransactionId latestRemovedXid)
 
XLogRecPtr log_heap_freeze (Relation reln, Buffer buffer, TransactionId cutoff_xid, xl_heap_freeze_tuple *tuples, int ntuples)
 
bool heap_prepare_freeze_tuple (HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId cutoff_xid, TransactionId cutoff_multi, xl_heap_freeze_tuple *frz, bool *totally_frozen)
 
void heap_execute_freeze_tuple (HeapTupleHeader tuple, xl_heap_freeze_tuple *xlrec_tp)
 
XLogRecPtr log_heap_visible (RelFileNode rnode, Buffer heap_buffer, Buffer vm_buffer, TransactionId cutoff_xid, uint8 flags)
 

Macro Definition Documentation

◆ SizeOfHeapClean

#define SizeOfHeapClean   (offsetof(xl_heap_clean, ndead) + sizeof(uint16))

Definition at line 246 of file heapam_xlog.h.

Referenced by log_heap_clean().

◆ SizeOfHeapCleanupInfo

#define SizeOfHeapCleanupInfo   (sizeof(xl_heap_cleanup_info))

Definition at line 259 of file heapam_xlog.h.

Referenced by log_heap_cleanup_info().

◆ SizeOfHeapConfirm

#define SizeOfHeapConfirm   (offsetof(xl_heap_confirm, offnum) + sizeof(OffsetNumber))

Definition at line 299 of file heapam_xlog.h.

Referenced by heap_finish_speculative().

◆ SizeOfHeapDelete

#define SizeOfHeapDelete   (offsetof(xl_heap_delete, flags) + sizeof(uint8))

Definition at line 111 of file heapam_xlog.h.

Referenced by DecodeDelete(), heap_abort_speculative(), and heap_delete().

◆ SizeOfHeapFreezePage

#define SizeOfHeapFreezePage   (offsetof(xl_heap_freeze_page, ntuples) + sizeof(uint16))

Definition at line 339 of file heapam_xlog.h.

Referenced by log_heap_freeze().

◆ SizeOfHeapHeader

#define SizeOfHeapHeader   (offsetof(xl_heap_header, t_hoff) + sizeof(uint8))

◆ SizeOfHeapInplace

#define SizeOfHeapInplace   (offsetof(xl_heap_inplace, offnum) + sizeof(OffsetNumber))

Definition at line 308 of file heapam_xlog.h.

Referenced by heap_inplace_update().

◆ SizeOfHeapInsert

#define SizeOfHeapInsert   (offsetof(xl_heap_insert, flags) + sizeof(uint8))

Definition at line 160 of file heapam_xlog.h.

Referenced by heap_insert().

◆ SizeOfHeapLock

#define SizeOfHeapLock   (offsetof(xl_heap_lock, flags) + sizeof(int8))

Definition at line 280 of file heapam_xlog.h.

Referenced by heap_lock_tuple(), and heap_update().

◆ SizeOfHeapLockUpdated

#define SizeOfHeapLockUpdated   (offsetof(xl_heap_lock_updated, flags) + sizeof(uint8))

Definition at line 291 of file heapam_xlog.h.

Referenced by heap_lock_updated_tuple_rec().

◆ SizeOfHeapMultiInsert

#define SizeOfHeapMultiInsert   offsetof(xl_heap_multi_insert, offsets)

Definition at line 180 of file heapam_xlog.h.

Referenced by heap_multi_insert().

◆ SizeOfHeapNewCid

#define SizeOfHeapNewCid   (offsetof(xl_heap_new_cid, target_tid) + sizeof(ItemPointerData))

Definition at line 373 of file heapam_xlog.h.

Referenced by log_heap_new_cid().

◆ SizeOfHeapTruncate

#define SizeOfHeapTruncate   (offsetof(xl_heap_truncate, relids))

Definition at line 132 of file heapam_xlog.h.

Referenced by ExecuteTruncateGuts().

◆ SizeOfHeapUpdate

#define SizeOfHeapUpdate   (offsetof(xl_heap_update, new_offnum) + sizeof(OffsetNumber))

Definition at line 225 of file heapam_xlog.h.

Referenced by DecodeUpdate(), and log_heap_update().

◆ SizeOfHeapVisible

#define SizeOfHeapVisible   (offsetof(xl_heap_visible, flags) + sizeof(uint8))

Definition at line 353 of file heapam_xlog.h.

Referenced by log_heap_visible().

◆ SizeOfMultiInsertTuple

#define SizeOfMultiInsertTuple   (offsetof(xl_multi_insert_tuple, t_hoff) + sizeof(uint8))

Definition at line 191 of file heapam_xlog.h.

Referenced by DecodeMultiInsert(), heap_multi_insert(), and heap_xlog_multi_insert().

◆ XLH_DELETE_ALL_VISIBLE_CLEARED

#define XLH_DELETE_ALL_VISIBLE_CLEARED   (1<<0)

Definition at line 92 of file heapam_xlog.h.

Referenced by heap_delete(), and heap_xlog_delete().

◆ XLH_DELETE_CONTAINS_OLD

#define XLH_DELETE_CONTAINS_OLD   (XLH_DELETE_CONTAINS_OLD_TUPLE | XLH_DELETE_CONTAINS_OLD_KEY)

Definition at line 99 of file heapam_xlog.h.

Referenced by DecodeDelete().

◆ XLH_DELETE_CONTAINS_OLD_KEY

#define XLH_DELETE_CONTAINS_OLD_KEY   (1<<2)

Definition at line 94 of file heapam_xlog.h.

Referenced by heap_delete().

◆ XLH_DELETE_CONTAINS_OLD_TUPLE

#define XLH_DELETE_CONTAINS_OLD_TUPLE   (1<<1)

Definition at line 93 of file heapam_xlog.h.

Referenced by heap_delete().

◆ XLH_DELETE_IS_PARTITION_MOVE

#define XLH_DELETE_IS_PARTITION_MOVE   (1<<4)

Definition at line 96 of file heapam_xlog.h.

Referenced by heap_delete(), and heap_xlog_delete().

◆ XLH_DELETE_IS_SUPER

#define XLH_DELETE_IS_SUPER   (1<<3)

Definition at line 95 of file heapam_xlog.h.

Referenced by DecodeDelete(), heap_abort_speculative(), and heap_xlog_delete().

◆ XLH_FREEZE_XVAC

#define XLH_FREEZE_XVAC   0x02

Definition at line 315 of file heapam_xlog.h.

Referenced by heap_execute_freeze_tuple(), and heap_prepare_freeze_tuple().

◆ XLH_INSERT_ALL_VISIBLE_CLEARED

#define XLH_INSERT_ALL_VISIBLE_CLEARED   (1<<0)

◆ XLH_INSERT_CONTAINS_NEW_TUPLE

#define XLH_INSERT_CONTAINS_NEW_TUPLE   (1<<3)

Definition at line 69 of file heapam_xlog.h.

Referenced by DecodeInsert(), DecodeMultiInsert(), heap_insert(), and heap_multi_insert().

◆ XLH_INSERT_IS_SPECULATIVE

#define XLH_INSERT_IS_SPECULATIVE   (1<<2)

Definition at line 68 of file heapam_xlog.h.

Referenced by DecodeInsert(), and heap_insert().

◆ XLH_INSERT_LAST_IN_MULTI

#define XLH_INSERT_LAST_IN_MULTI   (1<<1)

Definition at line 67 of file heapam_xlog.h.

Referenced by DecodeMultiInsert(), and heap_multi_insert().

◆ XLH_INVALID_XVAC

#define XLH_INVALID_XVAC   0x04

Definition at line 316 of file heapam_xlog.h.

Referenced by heap_execute_freeze_tuple(), and heap_prepare_freeze_tuple().

◆ XLH_LOCK_ALL_FROZEN_CLEARED

#define XLH_LOCK_ALL_FROZEN_CLEARED   0x01

◆ XLH_TRUNCATE_CASCADE

#define XLH_TRUNCATE_CASCADE   (1<<0)

Definition at line 116 of file heapam_xlog.h.

Referenced by DecodeTruncate(), ExecuteTruncateGuts(), and heap_desc().

◆ XLH_TRUNCATE_RESTART_SEQS

#define XLH_TRUNCATE_RESTART_SEQS   (1<<1)

Definition at line 117 of file heapam_xlog.h.

Referenced by DecodeTruncate(), ExecuteTruncateGuts(), and heap_desc().

◆ XLH_UPDATE_CONTAINS_NEW_TUPLE

#define XLH_UPDATE_CONTAINS_NEW_TUPLE   (1<<4)

Definition at line 80 of file heapam_xlog.h.

Referenced by DecodeUpdate(), and log_heap_update().

◆ XLH_UPDATE_CONTAINS_OLD

#define XLH_UPDATE_CONTAINS_OLD   (XLH_UPDATE_CONTAINS_OLD_TUPLE | XLH_UPDATE_CONTAINS_OLD_KEY)

Definition at line 85 of file heapam_xlog.h.

Referenced by DecodeUpdate().

◆ XLH_UPDATE_CONTAINS_OLD_KEY

#define XLH_UPDATE_CONTAINS_OLD_KEY   (1<<3)

Definition at line 79 of file heapam_xlog.h.

Referenced by log_heap_update().

◆ XLH_UPDATE_CONTAINS_OLD_TUPLE

#define XLH_UPDATE_CONTAINS_OLD_TUPLE   (1<<2)

Definition at line 78 of file heapam_xlog.h.

Referenced by log_heap_update().

◆ XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED   (1<<1)

Definition at line 77 of file heapam_xlog.h.

Referenced by heap_xlog_update(), and log_heap_update().

◆ XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED   (1<<0)

Definition at line 75 of file heapam_xlog.h.

Referenced by heap_xlog_update(), and log_heap_update().

◆ XLH_UPDATE_PREFIX_FROM_OLD

#define XLH_UPDATE_PREFIX_FROM_OLD   (1<<5)

Definition at line 81 of file heapam_xlog.h.

Referenced by heap_xlog_update(), and log_heap_update().

◆ XLH_UPDATE_SUFFIX_FROM_OLD

#define XLH_UPDATE_SUFFIX_FROM_OLD   (1<<6)

Definition at line 82 of file heapam_xlog.h.

Referenced by heap_xlog_update(), and log_heap_update().

◆ XLHL_KEYS_UPDATED

#define XLHL_KEYS_UPDATED   0x10

Definition at line 266 of file heapam_xlog.h.

Referenced by compute_infobits(), fix_infomask_from_infobits(), and out_infobits().

◆ XLHL_XMAX_EXCL_LOCK

#define XLHL_XMAX_EXCL_LOCK   0x04

Definition at line 264 of file heapam_xlog.h.

Referenced by compute_infobits(), fix_infomask_from_infobits(), and out_infobits().

◆ XLHL_XMAX_IS_MULTI

#define XLHL_XMAX_IS_MULTI   0x01

Definition at line 262 of file heapam_xlog.h.

Referenced by compute_infobits(), fix_infomask_from_infobits(), and out_infobits().

◆ XLHL_XMAX_KEYSHR_LOCK

#define XLHL_XMAX_KEYSHR_LOCK   0x08

Definition at line 265 of file heapam_xlog.h.

Referenced by compute_infobits(), fix_infomask_from_infobits(), and out_infobits().

◆ XLHL_XMAX_LOCK_ONLY

#define XLHL_XMAX_LOCK_ONLY   0x02

Definition at line 263 of file heapam_xlog.h.

Referenced by compute_infobits(), fix_infomask_from_infobits(), and out_infobits().

◆ XLOG_HEAP2_CLEAN

#define XLOG_HEAP2_CLEAN   0x10

Definition at line 54 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), heap2_desc(), heap2_identify(), heap2_redo(), and log_heap_clean().

◆ XLOG_HEAP2_CLEANUP_INFO

#define XLOG_HEAP2_CLEANUP_INFO   0x30

◆ XLOG_HEAP2_FREEZE_PAGE

#define XLOG_HEAP2_FREEZE_PAGE   0x20

Definition at line 55 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), heap2_desc(), heap2_identify(), heap2_redo(), and log_heap_freeze().

◆ XLOG_HEAP2_LOCK_UPDATED

#define XLOG_HEAP2_LOCK_UPDATED   0x60

◆ XLOG_HEAP2_MULTI_INSERT

#define XLOG_HEAP2_MULTI_INSERT   0x50

◆ XLOG_HEAP2_NEW_CID

#define XLOG_HEAP2_NEW_CID   0x70

Definition at line 60 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), heap2_desc(), heap2_identify(), heap2_redo(), and log_heap_new_cid().

◆ XLOG_HEAP2_REWRITE

#define XLOG_HEAP2_REWRITE   0x00

◆ XLOG_HEAP2_VISIBLE

#define XLOG_HEAP2_VISIBLE   0x40

Definition at line 57 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), heap2_desc(), heap2_identify(), heap2_redo(), and log_heap_visible().

◆ XLOG_HEAP_CONFIRM

#define XLOG_HEAP_CONFIRM   0x50

◆ XLOG_HEAP_DELETE

#define XLOG_HEAP_DELETE   0x10

◆ XLOG_HEAP_HOT_UPDATE

#define XLOG_HEAP_HOT_UPDATE   0x40

Definition at line 36 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_desc(), heap_identify(), heap_redo(), and log_heap_update().

◆ XLOG_HEAP_INIT_PAGE

◆ XLOG_HEAP_INPLACE

#define XLOG_HEAP_INPLACE   0x70

Definition at line 39 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_desc(), heap_identify(), heap_inplace_update(), and heap_redo().

◆ XLOG_HEAP_INSERT

#define XLOG_HEAP_INSERT   0x00

Definition at line 32 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_desc(), heap_identify(), heap_insert(), and heap_redo().

◆ XLOG_HEAP_LOCK

#define XLOG_HEAP_LOCK   0x60

◆ XLOG_HEAP_OPMASK

#define XLOG_HEAP_OPMASK   0x70

Definition at line 41 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), DecodeHeapOp(), heap2_desc(), heap2_redo(), heap_desc(), and heap_redo().

◆ XLOG_HEAP_TRUNCATE

#define XLOG_HEAP_TRUNCATE   0x30

Definition at line 35 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), ExecuteTruncateGuts(), heap_desc(), heap_identify(), and heap_redo().

◆ XLOG_HEAP_UPDATE

#define XLOG_HEAP_UPDATE   0x20

Definition at line 34 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_desc(), heap_identify(), heap_redo(), and log_heap_update().

Typedef Documentation

◆ xl_heap_clean

◆ xl_heap_cleanup_info

◆ xl_heap_confirm

◆ xl_heap_delete

◆ xl_heap_freeze_page

◆ xl_heap_freeze_tuple

◆ xl_heap_header

◆ xl_heap_inplace

◆ xl_heap_insert

◆ xl_heap_lock

◆ xl_heap_lock_updated

◆ xl_heap_multi_insert

◆ xl_heap_new_cid

◆ xl_heap_rewrite_mapping

◆ xl_heap_truncate

◆ xl_heap_update

◆ xl_heap_visible

◆ xl_multi_insert_tuple

Function Documentation

◆ heap2_desc()

void heap2_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 113 of file heapdesc.c.

References appendStringInfo(), xl_heap_new_cid::cmax, xl_heap_new_cid::cmin, xl_heap_new_cid::combocid, xl_heap_freeze_page::cutoff_xid, xl_heap_visible::cutoff_xid, RelFileNode::dbNode, xl_heap_lock_updated::flags, xl_heap_visible::flags, xl_heap_lock_updated::infobits_set, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, xl_heap_clean::latestRemovedXid, xl_heap_cleanup_info::latestRemovedXid, xl_heap_multi_insert::ntuples, xl_heap_freeze_page::ntuples, xl_heap_lock_updated::offnum, out_infobits(), RelFileNode::relNode, RelFileNode::spcNode, xl_heap_new_cid::target_node, xl_heap_new_cid::target_tid, XLOG_HEAP2_CLEAN, XLOG_HEAP2_CLEANUP_INFO, XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_VISIBLE, XLOG_HEAP_OPMASK, XLogRecGetData, XLogRecGetInfo, XLR_INFO_MASK, and xl_heap_lock_updated::xmax.

114 {
115  char *rec = XLogRecGetData(record);
116  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
117 
118  info &= XLOG_HEAP_OPMASK;
119  if (info == XLOG_HEAP2_CLEAN)
120  {
121  xl_heap_clean *xlrec = (xl_heap_clean *) rec;
122 
123  appendStringInfo(buf, "remxid %u", xlrec->latestRemovedXid);
124  }
125  else if (info == XLOG_HEAP2_FREEZE_PAGE)
126  {
127  xl_heap_freeze_page *xlrec = (xl_heap_freeze_page *) rec;
128 
129  appendStringInfo(buf, "cutoff xid %u ntuples %u",
130  xlrec->cutoff_xid, xlrec->ntuples);
131  }
132  else if (info == XLOG_HEAP2_CLEANUP_INFO)
133  {
135 
136  appendStringInfo(buf, "remxid %u", xlrec->latestRemovedXid);
137  }
138  else if (info == XLOG_HEAP2_VISIBLE)
139  {
140  xl_heap_visible *xlrec = (xl_heap_visible *) rec;
141 
142  appendStringInfo(buf, "cutoff xid %u flags %d",
143  xlrec->cutoff_xid, xlrec->flags);
144  }
145  else if (info == XLOG_HEAP2_MULTI_INSERT)
146  {
148 
149  appendStringInfo(buf, "%d tuples", xlrec->ntuples);
150  }
151  else if (info == XLOG_HEAP2_LOCK_UPDATED)
152  {
154 
155  appendStringInfo(buf, "off %u: xmax %u: flags %u ",
156  xlrec->offnum, xlrec->xmax, xlrec->flags);
157  out_infobits(buf, xlrec->infobits_set);
158  }
159  else if (info == XLOG_HEAP2_NEW_CID)
160  {
161  xl_heap_new_cid *xlrec = (xl_heap_new_cid *) rec;
162 
163  appendStringInfo(buf, "rel %u/%u/%u; tid %u/%u",
164  xlrec->target_node.spcNode,
165  xlrec->target_node.dbNode,
166  xlrec->target_node.relNode,
169  appendStringInfo(buf, "; cmin: %u, cmax: %u, combo: %u",
170  xlrec->cmin, xlrec->cmax, xlrec->combocid);
171  }
172 }
#define XLOG_HEAP2_LOCK_UPDATED
Definition: heapam_xlog.h:59
CommandId combocid
Definition: heapam_xlog.h:364
TransactionId cutoff_xid
Definition: heapam_xlog.h:335
unsigned char uint8
Definition: c.h:323
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:41
CommandId cmax
Definition: heapam_xlog.h:363
ItemPointerData target_tid
Definition: heapam_xlog.h:370
OffsetNumber offnum
Definition: heapam_xlog.h:286
#define XLOG_HEAP2_MULTI_INSERT
Definition: heapam_xlog.h:58
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:57
#define XLogRecGetData(decoder)
Definition: xlogreader.h:226
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
TransactionId cutoff_xid
Definition: heapam_xlog.h:349
#define XLOG_HEAP2_CLEAN
Definition: heapam_xlog.h:54
#define XLOG_HEAP2_CLEANUP_INFO
Definition: heapam_xlog.h:56
static void out_infobits(StringInfo buf, uint8 infobits)
Definition: heapdesc.c:20
#define XLOG_HEAP2_NEW_CID
Definition: heapam_xlog.h:60
TransactionId xmax
Definition: heapam_xlog.h:285
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:222
RelFileNode target_node
Definition: heapam_xlog.h:369
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define ItemPointerGetOffsetNumber(pointer)
Definition: itemptr.h:95
#define XLOG_HEAP2_FREEZE_PAGE
Definition: heapam_xlog.h:55
TransactionId latestRemovedXid
Definition: heapam_xlog.h:240
CommandId cmin
Definition: heapam_xlog.h:362
#define ItemPointerGetBlockNumber(pointer)
Definition: itemptr.h:76
TransactionId latestRemovedXid
Definition: heapam_xlog.h:256

◆ heap2_identify()

const char* heap2_identify ( uint8  info)

Definition at line 220 of file heapdesc.c.

References XLOG_HEAP2_CLEAN, XLOG_HEAP2_CLEANUP_INFO, XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VISIBLE, XLOG_HEAP_INIT_PAGE, and XLR_INFO_MASK.

221 {
222  const char *id = NULL;
223 
224  switch (info & ~XLR_INFO_MASK)
225  {
226  case XLOG_HEAP2_CLEAN:
227  id = "CLEAN";
228  break;
230  id = "FREEZE_PAGE";
231  break;
233  id = "CLEANUP_INFO";
234  break;
235  case XLOG_HEAP2_VISIBLE:
236  id = "VISIBLE";
237  break;
239  id = "MULTI_INSERT";
240  break;
242  id = "MULTI_INSERT+INIT";
243  break;
245  id = "LOCK_UPDATED";
246  break;
247  case XLOG_HEAP2_NEW_CID:
248  id = "NEW_CID";
249  break;
250  case XLOG_HEAP2_REWRITE:
251  id = "REWRITE";
252  break;
253  }
254 
255  return id;
256 }
#define XLOG_HEAP2_LOCK_UPDATED
Definition: heapam_xlog.h:59
#define XLOG_HEAP2_REWRITE
Definition: heapam_xlog.h:53
#define XLOG_HEAP_INIT_PAGE
Definition: heapam_xlog.h:46
#define XLOG_HEAP2_MULTI_INSERT
Definition: heapam_xlog.h:58
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:57
#define XLOG_HEAP2_CLEAN
Definition: heapam_xlog.h:54
#define XLOG_HEAP2_CLEANUP_INFO
Definition: heapam_xlog.h:56
#define XLOG_HEAP2_NEW_CID
Definition: heapam_xlog.h:60
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define XLOG_HEAP2_FREEZE_PAGE
Definition: heapam_xlog.h:55

◆ heap2_redo()

void heap2_redo ( XLogReaderState record)

Definition at line 9302 of file heapam.c.

References elog, heap_xlog_clean(), heap_xlog_cleanup_info(), heap_xlog_freeze_page(), heap_xlog_lock_updated(), heap_xlog_logical_rewrite(), heap_xlog_multi_insert(), heap_xlog_visible(), PANIC, XLOG_HEAP2_CLEAN, XLOG_HEAP2_CLEANUP_INFO, XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VISIBLE, XLOG_HEAP_OPMASK, XLogRecGetInfo, and XLR_INFO_MASK.

9303 {
9304  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
9305 
9306  switch (info & XLOG_HEAP_OPMASK)
9307  {
9308  case XLOG_HEAP2_CLEAN:
9309  heap_xlog_clean(record);
9310  break;
9312  heap_xlog_freeze_page(record);
9313  break;
9315  heap_xlog_cleanup_info(record);
9316  break;
9317  case XLOG_HEAP2_VISIBLE:
9318  heap_xlog_visible(record);
9319  break;
9321  heap_xlog_multi_insert(record);
9322  break;
9324  heap_xlog_lock_updated(record);
9325  break;
9326  case XLOG_HEAP2_NEW_CID:
9327 
9328  /*
9329  * Nothing to do on a real replay, only used during logical
9330  * decoding.
9331  */
9332  break;
9333  case XLOG_HEAP2_REWRITE:
9334  heap_xlog_logical_rewrite(record);
9335  break;
9336  default:
9337  elog(PANIC, "heap2_redo: unknown op code %u", info);
9338  }
9339 }
void heap_xlog_logical_rewrite(XLogReaderState *r)
Definition: rewriteheap.c:1121
#define XLOG_HEAP2_LOCK_UPDATED
Definition: heapam_xlog.h:59
#define XLOG_HEAP2_REWRITE
Definition: heapam_xlog.h:53
unsigned char uint8
Definition: c.h:323
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:41
#define PANIC
Definition: elog.h:53
#define XLOG_HEAP2_MULTI_INSERT
Definition: heapam_xlog.h:58
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:57
static void heap_xlog_lock_updated(XLogReaderState *record)
Definition: heapam.c:9156
static void heap_xlog_freeze_page(XLogReaderState *record)
Definition: heapam.c:8370
#define XLOG_HEAP2_CLEAN
Definition: heapam_xlog.h:54
#define XLOG_HEAP2_CLEANUP_INFO
Definition: heapam_xlog.h:56
static void heap_xlog_multi_insert(XLogReaderState *record)
Definition: heapam.c:8638
#define XLOG_HEAP2_NEW_CID
Definition: heapam_xlog.h:60
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:222
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
static void heap_xlog_cleanup_info(XLogReaderState *record)
Definition: heapam.c:8144
#define XLOG_HEAP2_FREEZE_PAGE
Definition: heapam_xlog.h:55
static void heap_xlog_visible(XLogReaderState *record)
Definition: heapam.c:8255
#define elog
Definition: elog.h:219
static void heap_xlog_clean(XLogReaderState *record)
Definition: heapam.c:8165

◆ heap_desc()

void heap_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 35 of file heapdesc.c.

References appendStringInfo(), xl_heap_truncate::flags, xl_heap_lock::flags, i, xl_heap_delete::infobits_set, xl_heap_lock::infobits_set, xl_heap_lock::locking_xid, xl_heap_update::new_offnum, xl_heap_update::new_xmax, xl_heap_truncate::nrelids, xl_heap_delete::offnum, xl_heap_insert::offnum, xl_heap_lock::offnum, xl_heap_confirm::offnum, xl_heap_inplace::offnum, xl_heap_update::old_infobits_set, xl_heap_update::old_offnum, xl_heap_update::old_xmax, out_infobits(), xl_heap_truncate::relids, XLH_TRUNCATE_CASCADE, XLH_TRUNCATE_RESTART_SEQS, XLOG_HEAP_CONFIRM, XLOG_HEAP_DELETE, XLOG_HEAP_HOT_UPDATE, XLOG_HEAP_INPLACE, XLOG_HEAP_INSERT, XLOG_HEAP_LOCK, XLOG_HEAP_OPMASK, XLOG_HEAP_TRUNCATE, XLOG_HEAP_UPDATE, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

36 {
37  char *rec = XLogRecGetData(record);
38  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
39 
40  info &= XLOG_HEAP_OPMASK;
41  if (info == XLOG_HEAP_INSERT)
42  {
43  xl_heap_insert *xlrec = (xl_heap_insert *) rec;
44 
45  appendStringInfo(buf, "off %u", xlrec->offnum);
46  }
47  else if (info == XLOG_HEAP_DELETE)
48  {
49  xl_heap_delete *xlrec = (xl_heap_delete *) rec;
50 
51  appendStringInfo(buf, "off %u ", xlrec->offnum);
52  out_infobits(buf, xlrec->infobits_set);
53  }
54  else if (info == XLOG_HEAP_UPDATE)
55  {
56  xl_heap_update *xlrec = (xl_heap_update *) rec;
57 
58  appendStringInfo(buf, "off %u xmax %u ",
59  xlrec->old_offnum,
60  xlrec->old_xmax);
61  out_infobits(buf, xlrec->old_infobits_set);
62  appendStringInfo(buf, "; new off %u xmax %u",
63  xlrec->new_offnum,
64  xlrec->new_xmax);
65  }
66  else if (info == XLOG_HEAP_HOT_UPDATE)
67  {
68  xl_heap_update *xlrec = (xl_heap_update *) rec;
69 
70  appendStringInfo(buf, "off %u xmax %u ",
71  xlrec->old_offnum,
72  xlrec->old_xmax);
73  out_infobits(buf, xlrec->old_infobits_set);
74  appendStringInfo(buf, "; new off %u xmax %u",
75  xlrec->new_offnum,
76  xlrec->new_xmax);
77  }
78  else if (info == XLOG_HEAP_TRUNCATE)
79  {
80  xl_heap_truncate *xlrec = (xl_heap_truncate *) rec;
81  int i;
82 
83  if (xlrec->flags & XLH_TRUNCATE_CASCADE)
84  appendStringInfo(buf, "cascade ");
85  if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS)
86  appendStringInfo(buf, "restart_seqs ");
87  appendStringInfo(buf, "nrelids %u relids", xlrec->nrelids);
88  for (i = 0; i < xlrec->nrelids; i++)
89  appendStringInfo(buf, " %u", xlrec->relids[i]);
90  }
91  else if (info == XLOG_HEAP_CONFIRM)
92  {
93  xl_heap_confirm *xlrec = (xl_heap_confirm *) rec;
94 
95  appendStringInfo(buf, "off %u", xlrec->offnum);
96  }
97  else if (info == XLOG_HEAP_LOCK)
98  {
99  xl_heap_lock *xlrec = (xl_heap_lock *) rec;
100 
101  appendStringInfo(buf, "off %u: xid %u: flags %u ",
102  xlrec->offnum, xlrec->locking_xid, xlrec->flags);
103  out_infobits(buf, xlrec->infobits_set);
104  }
105  else if (info == XLOG_HEAP_INPLACE)
106  {
107  xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
108 
109  appendStringInfo(buf, "off %u", xlrec->offnum);
110  }
111 }
#define XLH_TRUNCATE_CASCADE
Definition: heapam_xlog.h:116
#define XLOG_HEAP_INSERT
Definition: heapam_xlog.h:32
uint8 old_infobits_set
Definition: heapam_xlog.h:214
OffsetNumber offnum
Definition: heapam_xlog.h:296
OffsetNumber offnum
Definition: heapam_xlog.h:275
TransactionId locking_xid
Definition: heapam_xlog.h:274
unsigned char uint8
Definition: c.h:323
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:41
#define XLOG_HEAP_HOT_UPDATE
Definition: heapam_xlog.h:36
OffsetNumber old_offnum
Definition: heapam_xlog.h:213
OffsetNumber offnum
Definition: heapam_xlog.h:106
Oid relids[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:129
#define XLogRecGetData(decoder)
Definition: xlogreader.h:226
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
TransactionId new_xmax
Definition: heapam_xlog.h:216
int8 infobits_set
Definition: heapam_xlog.h:276
static void out_infobits(StringInfo buf, uint8 infobits)
Definition: heapdesc.c:20
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:222
OffsetNumber offnum
Definition: heapam_xlog.h:304
#define XLH_TRUNCATE_RESTART_SEQS
Definition: heapam_xlog.h:117
#define XLOG_HEAP_TRUNCATE
Definition: heapam_xlog.h:35
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
uint8 infobits_set
Definition: heapam_xlog.h:107
#define XLOG_HEAP_UPDATE
Definition: heapam_xlog.h:34
#define XLOG_HEAP_INPLACE
Definition: heapam_xlog.h:39
#define XLOG_HEAP_LOCK
Definition: heapam_xlog.h:38
int i
OffsetNumber new_offnum
Definition: heapam_xlog.h:217
#define XLOG_HEAP_DELETE
Definition: heapam_xlog.h:33
OffsetNumber offnum
Definition: heapam_xlog.h:154
TransactionId old_xmax
Definition: heapam_xlog.h:212
#define XLOG_HEAP_CONFIRM
Definition: heapam_xlog.h:37

◆ heap_execute_freeze_tuple()

void heap_execute_freeze_tuple ( HeapTupleHeader  tuple,
xl_heap_freeze_tuple xlrec_tp 
)

Definition at line 7009 of file heapam.c.

References FrozenTransactionId, xl_heap_freeze_tuple::frzflags, HeapTupleHeaderSetXmax, HeapTupleHeaderSetXvac, InvalidTransactionId, HeapTupleHeaderData::t_infomask, xl_heap_freeze_tuple::t_infomask, HeapTupleHeaderData::t_infomask2, xl_heap_freeze_tuple::t_infomask2, XLH_FREEZE_XVAC, XLH_INVALID_XVAC, and xl_heap_freeze_tuple::xmax.

Referenced by heap_freeze_tuple(), heap_xlog_freeze_page(), and lazy_scan_heap().

7010 {
7011  HeapTupleHeaderSetXmax(tuple, frz->xmax);
7012 
7013  if (frz->frzflags & XLH_FREEZE_XVAC)
7015 
7016  if (frz->frzflags & XLH_INVALID_XVAC)
7018 
7019  tuple->t_infomask = frz->t_infomask;
7020  tuple->t_infomask2 = frz->t_infomask2;
7021 }
#define HeapTupleHeaderSetXvac(tup, xid)
Definition: htup_details.h:428
#define HeapTupleHeaderSetXmax(tup, xid)
Definition: htup_details.h:385
#define InvalidTransactionId
Definition: transam.h:31
#define FrozenTransactionId
Definition: transam.h:33
#define XLH_INVALID_XVAC
Definition: heapam_xlog.h:316
#define XLH_FREEZE_XVAC
Definition: heapam_xlog.h:315

◆ heap_identify()

const char* heap_identify ( uint8  info)

Definition at line 175 of file heapdesc.c.

References XLOG_HEAP_CONFIRM, XLOG_HEAP_DELETE, XLOG_HEAP_HOT_UPDATE, XLOG_HEAP_INIT_PAGE, XLOG_HEAP_INPLACE, XLOG_HEAP_INSERT, XLOG_HEAP_LOCK, XLOG_HEAP_TRUNCATE, XLOG_HEAP_UPDATE, and XLR_INFO_MASK.

176 {
177  const char *id = NULL;
178 
179  switch (info & ~XLR_INFO_MASK)
180  {
181  case XLOG_HEAP_INSERT:
182  id = "INSERT";
183  break;
185  id = "INSERT+INIT";
186  break;
187  case XLOG_HEAP_DELETE:
188  id = "DELETE";
189  break;
190  case XLOG_HEAP_UPDATE:
191  id = "UPDATE";
192  break;
194  id = "UPDATE+INIT";
195  break;
197  id = "HOT_UPDATE";
198  break;
200  id = "HOT_UPDATE+INIT";
201  break;
202  case XLOG_HEAP_TRUNCATE:
203  id = "TRUNCATE";
204  break;
205  case XLOG_HEAP_CONFIRM:
206  id = "HEAP_CONFIRM";
207  break;
208  case XLOG_HEAP_LOCK:
209  id = "LOCK";
210  break;
211  case XLOG_HEAP_INPLACE:
212  id = "INPLACE";
213  break;
214  }
215 
216  return id;
217 }
#define XLOG_HEAP_INSERT
Definition: heapam_xlog.h:32
#define XLOG_HEAP_HOT_UPDATE
Definition: heapam_xlog.h:36
#define XLOG_HEAP_INIT_PAGE
Definition: heapam_xlog.h:46
#define XLOG_HEAP_TRUNCATE
Definition: heapam_xlog.h:35
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define XLOG_HEAP_UPDATE
Definition: heapam_xlog.h:34
#define XLOG_HEAP_INPLACE
Definition: heapam_xlog.h:39
#define XLOG_HEAP_LOCK
Definition: heapam_xlog.h:38
#define XLOG_HEAP_DELETE
Definition: heapam_xlog.h:33
#define XLOG_HEAP_CONFIRM
Definition: heapam_xlog.h:37

◆ heap_mask()

void heap_mask ( char *  pagedata,
BlockNumber  blkno 
)

Definition at line 9385 of file heapam.c.

References HEAP_XACT_MASK, HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HeapTupleHeaderIsSpeculative, HeapTupleHeaderXminFrozen, ItemIdGetLength, ItemIdGetOffset, ItemIdHasStorage, ItemIdIsNormal, ItemPointerSet, MASK_MARKER, mask_page_hint_bits(), mask_page_lsn_and_checksum(), mask_unused_space(), MAXALIGN, PageGetItemId, PageGetMaxOffsetNumber, and HeapTupleHeaderData::t_infomask.

9386 {
9387  Page page = (Page) pagedata;
9388  OffsetNumber off;
9389 
9391 
9392  mask_page_hint_bits(page);
9393  mask_unused_space(page);
9394 
9395  for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
9396  {
9397  ItemId iid = PageGetItemId(page, off);
9398  char *page_item;
9399 
9400  page_item = (char *) (page + ItemIdGetOffset(iid));
9401 
9402  if (ItemIdIsNormal(iid))
9403  {
9404  HeapTupleHeader page_htup = (HeapTupleHeader) page_item;
9405 
9406  /*
9407  * If xmin of a tuple is not yet frozen, we should ignore
9408  * differences in hint bits, since they can be set without
9409  * emitting WAL.
9410  */
9411  if (!HeapTupleHeaderXminFrozen(page_htup))
9412  page_htup->t_infomask &= ~HEAP_XACT_MASK;
9413  else
9414  {
9415  /* Still we need to mask xmax hint bits. */
9416  page_htup->t_infomask &= ~HEAP_XMAX_INVALID;
9417  page_htup->t_infomask &= ~HEAP_XMAX_COMMITTED;
9418  }
9419 
9420  /*
9421  * During replay, we set Command Id to FirstCommandId. Hence, mask
9422  * it. See heap_xlog_insert() for details.
9423  */
9424  page_htup->t_choice.t_heap.t_field3.t_cid = MASK_MARKER;
9425 
9426  /*
9427  * For a speculative tuple, heap_insert() does not set ctid in the
9428  * caller-passed heap tuple itself, leaving the ctid field to
9429  * contain a speculative token value - a per-backend monotonically
9430  * increasing identifier. Besides, it does not WAL-log ctid under
9431  * any circumstances.
9432  *
9433  * During redo, heap_xlog_insert() sets t_ctid to current block
9434  * number and self offset number. It doesn't care about any
9435  * speculative insertions in master. Hence, we set t_ctid to
9436  * current block number and self offset number to ignore any
9437  * inconsistency.
9438  */
9439  if (HeapTupleHeaderIsSpeculative(page_htup))
9440  ItemPointerSet(&page_htup->t_ctid, blkno, off);
9441 
9442  /*
9443  * NB: Not ignoring ctid changes due to the tuple having moved
9444  * (i.e. HeapTupleHeaderIndicatesMovedPartitions), because that's
9445  * important information that needs to be in-sync between primary
9446  * and standby, and thus is WAL logged.
9447  */
9448  }
9449 
9450  /*
9451  * Ignore any padding bytes after the tuple, when the length of the
9452  * item is not MAXALIGNed.
9453  */
9454  if (ItemIdHasStorage(iid))
9455  {
9456  int len = ItemIdGetLength(iid);
9457  int padlen = MAXALIGN(len) - len;
9458 
9459  if (padlen > 0)
9460  memset(page_item + len, MASK_MARKER, padlen);
9461  }
9462  }
9463 }
union HeapTupleHeaderData::@45 t_choice
HeapTupleFields t_heap
Definition: htup_details.h:153
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HeapTupleHeaderIsSpeculative(tup)
Definition: htup_details.h:434
void mask_page_hint_bits(Page page)
Definition: bufmask.c:46
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:203
#define PageGetMaxOffsetNumber(page)
Definition: bufpage.h:353
void mask_unused_space(Page page)
Definition: bufmask.c:71
uint16 OffsetNumber
Definition: off.h:24
#define ItemIdGetLength(itemId)
Definition: itemid.h:58
#define MASK_MARKER
Definition: bufmask.h:24
#define HEAP_XMAX_INVALID
Definition: htup_details.h:204
ItemPointerData t_ctid
Definition: htup_details.h:157
#define ItemIdGetOffset(itemId)
Definition: itemid.h:64
union HeapTupleFields::@44 t_field3
#define PageGetItemId(page, offsetNumber)
Definition: bufpage.h:231
void mask_page_lsn_and_checksum(Page page)
Definition: bufmask.c:31
#define HeapTupleHeaderXminFrozen(tup)
Definition: htup_details.h:340
#define ItemIdHasStorage(itemId)
Definition: itemid.h:119
#define ItemIdIsNormal(itemId)
Definition: itemid.h:98
#define MAXALIGN(LEN)
Definition: c.h:652
#define HEAP_XACT_MASK
Definition: htup_details.h:215
CommandId t_cid
Definition: htup_details.h:125
Pointer Page
Definition: bufpage.h:74
#define ItemPointerSet(pointer, blockNumber, offNum)
Definition: itemptr.h:105

◆ heap_prepare_freeze_tuple()

bool heap_prepare_freeze_tuple ( HeapTupleHeader  tuple,
TransactionId  relfrozenxid,
TransactionId  relminmxid,
TransactionId  cutoff_xid,
TransactionId  cutoff_multi,
xl_heap_freeze_tuple frz,
bool totally_frozen 
)

Definition at line 6797 of file heapam.c.

References Assert, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, FreezeMultiXactId(), FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, FRM_NOOP, FRM_RETURN_IS_MULTI, FRM_RETURN_IS_XID, xl_heap_freeze_tuple::frzflags, GetMultiXactIdHintBits(), HEAP_HOT_UPDATED, HEAP_KEYS_UPDATED, HEAP_MOVED, HEAP_MOVED_OFF, HEAP_XMAX_BITS, HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY, HEAP_XMAX_IS_MULTI, HEAP_XMIN_COMMITTED, HEAP_XMIN_FROZEN, HEAP_XMIN_INVALID, HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetXmin, HeapTupleHeaderGetXvac, InvalidTransactionId, HeapTupleHeaderData::t_infomask, xl_heap_freeze_tuple::t_infomask, HeapTupleHeaderData::t_infomask2, xl_heap_freeze_tuple::t_infomask2, TransactionIdDidCommit(), TransactionIdIsNormal, TransactionIdPrecedes(), XLH_FREEZE_XVAC, XLH_INVALID_XVAC, and xl_heap_freeze_tuple::xmax.

Referenced by heap_freeze_tuple(), and lazy_scan_heap().

6801 {
6802  bool changed = false;
6803  bool freeze_xmax = false;
6804  TransactionId xid;
6805  bool totally_frozen = true;
6806 
6807  frz->frzflags = 0;
6808  frz->t_infomask2 = tuple->t_infomask2;
6809  frz->t_infomask = tuple->t_infomask;
6810  frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
6811 
6812  /* Process xmin */
6813  xid = HeapTupleHeaderGetXmin(tuple);
6814  if (TransactionIdIsNormal(xid))
6815  {
6817  ereport(ERROR,
6819  errmsg_internal("found xmin %u from before relfrozenxid %u",
6820  xid, relfrozenxid)));
6821 
6822  if (TransactionIdPrecedes(xid, cutoff_xid))
6823  {
6824  if (!TransactionIdDidCommit(xid))
6825  ereport(ERROR,
6827  errmsg_internal("uncommitted xmin %u from before xid cutoff %u needs to be frozen",
6828  xid, cutoff_xid)));
6829 
6830  frz->t_infomask |= HEAP_XMIN_FROZEN;
6831  changed = true;
6832  }
6833  else
6834  totally_frozen = false;
6835  }
6836 
6837  /*
6838  * Process xmax. To thoroughly examine the current Xmax value we need to
6839  * resolve a MultiXactId to its member Xids, in case some of them are
6840  * below the given cutoff for Xids. In that case, those values might need
6841  * freezing, too. Also, if a multi needs freezing, we cannot simply take
6842  * it out --- if there's a live updater Xid, it needs to be kept.
6843  *
6844  * Make sure to keep heap_tuple_needs_freeze in sync with this.
6845  */
6846  xid = HeapTupleHeaderGetRawXmax(tuple);
6847 
6848  if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
6849  {
6850  TransactionId newxmax;
6851  uint16 flags;
6852 
6853  newxmax = FreezeMultiXactId(xid, tuple->t_infomask,
6855  cutoff_xid, cutoff_multi, &flags);
6856 
6857  if (flags & FRM_INVALIDATE_XMAX)
6858  freeze_xmax = true;
6859  else if (flags & FRM_RETURN_IS_XID)
6860  {
6861  /*
6862  * NB -- some of these transformations are only valid because we
6863  * know the return Xid is a tuple updater (i.e. not merely a
6864  * locker.) Also note that the only reason we don't explicitly
6865  * worry about HEAP_KEYS_UPDATED is because it lives in
6866  * t_infomask2 rather than t_infomask.
6867  */
6868  frz->t_infomask &= ~HEAP_XMAX_BITS;
6869  frz->xmax = newxmax;
6870  if (flags & FRM_MARK_COMMITTED)
6872  changed = true;
6873  totally_frozen = false;
6874  }
6875  else if (flags & FRM_RETURN_IS_MULTI)
6876  {
6877  uint16 newbits;
6878  uint16 newbits2;
6879 
6880  /*
6881  * We can't use GetMultiXactIdHintBits directly on the new multi
6882  * here; that routine initializes the masks to all zeroes, which
6883  * would lose other bits we need. Doing it this way ensures all
6884  * unrelated bits remain untouched.
6885  */
6886  frz->t_infomask &= ~HEAP_XMAX_BITS;
6887  frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
6888  GetMultiXactIdHintBits(newxmax, &newbits, &newbits2);
6889  frz->t_infomask |= newbits;
6890  frz->t_infomask2 |= newbits2;
6891 
6892  frz->xmax = newxmax;
6893 
6894  changed = true;
6895  totally_frozen = false;
6896  }
6897  else
6898  {
6899  Assert(flags & FRM_NOOP);
6900  }
6901  }
6902  else if (TransactionIdIsNormal(xid))
6903  {
6905  ereport(ERROR,
6907  errmsg_internal("found xmax %u from before relfrozenxid %u",
6908  xid, relfrozenxid)));
6909 
6910  if (TransactionIdPrecedes(xid, cutoff_xid))
6911  {
6912  /*
6913  * If we freeze xmax, make absolutely sure that it's not an XID
6914  * that is important. (Note, a lock-only xmax can be removed
6915  * independent of committedness, since a committed lock holder has
6916  * released the lock).
6917  */
6918  if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) &&
6920  ereport(ERROR,
6922  errmsg_internal("cannot freeze committed xmax %u",
6923  xid)));
6924  freeze_xmax = true;
6925  }
6926  else
6927  totally_frozen = false;
6928  }
6929 
6930  if (freeze_xmax)
6931  {
6932  frz->xmax = InvalidTransactionId;
6933 
6934  /*
6935  * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
6936  * LOCKED. Normalize to INVALID just to be sure no one gets confused.
6937  * Also get rid of the HEAP_KEYS_UPDATED bit.
6938  */
6939  frz->t_infomask &= ~HEAP_XMAX_BITS;
6940  frz->t_infomask |= HEAP_XMAX_INVALID;
6941  frz->t_infomask2 &= ~HEAP_HOT_UPDATED;
6942  frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
6943  changed = true;
6944  }
6945 
6946  /*
6947  * Old-style VACUUM FULL is gone, but we have to keep this code as long as
6948  * we support having MOVED_OFF/MOVED_IN tuples in the database.
6949  */
6950  if (tuple->t_infomask & HEAP_MOVED)
6951  {
6952  xid = HeapTupleHeaderGetXvac(tuple);
6953 
6954  /*
6955  * For Xvac, we ignore the cutoff_xid and just always perform the
6956  * freeze operation. The oldest release in which such a value can
6957  * actually be set is PostgreSQL 8.4, because old-style VACUUM FULL
6958  * was removed in PostgreSQL 9.0. Note that if we were to respect
6959  * cutoff_xid here, we'd need to make surely to clear totally_frozen
6960  * when we skipped freezing on that basis.
6961  */
6962  if (TransactionIdIsNormal(xid))
6963  {
6964  /*
6965  * If a MOVED_OFF tuple is not dead, the xvac transaction must
6966  * have failed; whereas a non-dead MOVED_IN tuple must mean the
6967  * xvac transaction succeeded.
6968  */
6969  if (tuple->t_infomask & HEAP_MOVED_OFF)
6970  frz->frzflags |= XLH_INVALID_XVAC;
6971  else
6972  frz->frzflags |= XLH_FREEZE_XVAC;
6973 
6974  /*
6975  * Might as well fix the hint bits too; usually XMIN_COMMITTED
6976  * will already be set here, but there's a small chance not.
6977  */
6978  Assert(!(tuple->t_infomask & HEAP_XMIN_INVALID));
6980  changed = true;
6981  }
6982  }
6983 
6984  *totally_frozen_p = totally_frozen;
6985  return changed;
6986 }
#define FRM_RETURN_IS_XID
Definition: heapam.c:6472
static void GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
Definition: heapam.c:7061
#define FRM_MARK_COMMITTED
Definition: heapam.c:6474
#define HEAP_XMAX_BITS
Definition: htup_details.h:267
uint32 TransactionId
Definition: c.h:474
#define HEAP_XMIN_FROZEN
Definition: htup_details.h:202
int errcode(int sqlerrcode)
Definition: elog.c:575
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:203
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:125
#define HEAP_XMIN_INVALID
Definition: htup_details.h:201
#define HeapTupleHeaderGetRawXmax(tup)
Definition: htup_details.h:380
unsigned short uint16
Definition: c.h:324
#define ERROR
Definition: elog.h:43
#define HEAP_XMAX_INVALID
Definition: htup_details.h:204
#define FRM_INVALIDATE_XMAX
Definition: heapam.c:6471
#define InvalidTransactionId
Definition: transam.h:31
#define HeapTupleHeaderGetXvac(tup)
Definition: htup_details.h:420
#define ereport(elevel, rest)
Definition: elog.h:122
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:43
#define FRM_RETURN_IS_MULTI
Definition: heapam.c:6473
#define HEAP_XMAX_IS_LOCKED_ONLY(infomask)
Definition: htup_details.h:227
#define HEAP_KEYS_UPDATED
Definition: htup_details.h:275
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:205
#define HEAP_XMIN_COMMITTED
Definition: htup_details.h:200
#define HEAP_MOVED
Definition: htup_details.h:213
TransactionId relminmxid
Definition: pg_class.h:72
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
#define HEAP_MOVED_OFF
Definition: htup_details.h:207
#define Assert(condition)
Definition: c.h:699
#define FRM_NOOP
Definition: heapam.c:6470
#define HeapTupleHeaderGetXmin(tup)
Definition: htup_details.h:318
TransactionId xmax
Definition: heapam_xlog.h:320
TransactionId relfrozenxid
Definition: pg_class.h:71
static TransactionId FreezeMultiXactId(MultiXactId multi, uint16 t_infomask, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId cutoff_xid, MultiXactId cutoff_multi, uint16 *flags)
Definition: heapam.c:6498
#define HEAP_HOT_UPDATED
Definition: htup_details.h:277
#define XLH_INVALID_XVAC
Definition: heapam_xlog.h:316
#define TransactionIdIsNormal(xid)
Definition: transam.h:42
#define XLH_FREEZE_XVAC
Definition: heapam_xlog.h:315

◆ heap_redo()

void heap_redo ( XLogReaderState record)

Definition at line 9257 of file heapam.c.

References elog, heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_update(), PANIC, XLOG_HEAP_CONFIRM, XLOG_HEAP_DELETE, XLOG_HEAP_HOT_UPDATE, XLOG_HEAP_INPLACE, XLOG_HEAP_INSERT, XLOG_HEAP_LOCK, XLOG_HEAP_OPMASK, XLOG_HEAP_TRUNCATE, XLOG_HEAP_UPDATE, XLogRecGetInfo, and XLR_INFO_MASK.

9258 {
9259  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
9260 
9261  /*
9262  * These operations don't overwrite MVCC data so no conflict processing is
9263  * required. The ones in heap2 rmgr do.
9264  */
9265 
9266  switch (info & XLOG_HEAP_OPMASK)
9267  {
9268  case XLOG_HEAP_INSERT:
9269  heap_xlog_insert(record);
9270  break;
9271  case XLOG_HEAP_DELETE:
9272  heap_xlog_delete(record);
9273  break;
9274  case XLOG_HEAP_UPDATE:
9275  heap_xlog_update(record, false);
9276  break;
9277  case XLOG_HEAP_TRUNCATE:
9278  /*
9279  * TRUNCATE is a no-op because the actions are already logged as
9280  * SMGR WAL records. TRUNCATE WAL record only exists for logical
9281  * decoding.
9282  */
9283  break;
9284  case XLOG_HEAP_HOT_UPDATE:
9285  heap_xlog_update(record, true);
9286  break;
9287  case XLOG_HEAP_CONFIRM:
9288  heap_xlog_confirm(record);
9289  break;
9290  case XLOG_HEAP_LOCK:
9291  heap_xlog_lock(record);
9292  break;
9293  case XLOG_HEAP_INPLACE:
9294  heap_xlog_inplace(record);
9295  break;
9296  default:
9297  elog(PANIC, "heap_redo: unknown op code %u", info);
9298  }
9299 }
#define XLOG_HEAP_INSERT
Definition: heapam_xlog.h:32
unsigned char uint8
Definition: c.h:323
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:41
#define XLOG_HEAP_HOT_UPDATE
Definition: heapam_xlog.h:36
#define PANIC
Definition: elog.h:53
static void heap_xlog_confirm(XLogReaderState *record)
Definition: heapam.c:9049
static void heap_xlog_lock(XLogReaderState *record)
Definition: heapam.c:9085
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:222
#define XLOG_HEAP_TRUNCATE
Definition: heapam_xlog.h:35
static void heap_xlog_insert(XLogReaderState *record)
Definition: heapam.c:8522
static void heap_xlog_inplace(XLogReaderState *record)
Definition: heapam.c:9216
static void heap_xlog_delete(XLogReaderState *record)
Definition: heapam.c:8449
#define XLR_INFO_MASK
Definition: xlogrecord.h:62
#define XLOG_HEAP_UPDATE
Definition: heapam_xlog.h:34
#define XLOG_HEAP_INPLACE
Definition: heapam_xlog.h:39
static void heap_xlog_update(XLogReaderState *record, bool hot_update)
Definition: heapam.c:8777
#define XLOG_HEAP_LOCK
Definition: heapam_xlog.h:38
#define elog
Definition: elog.h:219
#define XLOG_HEAP_DELETE
Definition: heapam_xlog.h:33
#define XLOG_HEAP_CONFIRM
Definition: heapam_xlog.h:37

◆ heap_xlog_logical_rewrite()

void heap_xlog_logical_rewrite ( XLogReaderState r)

Definition at line 1121 of file rewriteheap.c.

References CloseTransientFile(), ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), ftruncate, LOGICAL_REWRITE_FORMAT, xl_heap_rewrite_mapping::mapped_db, xl_heap_rewrite_mapping::mapped_rel, xl_heap_rewrite_mapping::mapped_xid, MAXPGPATH, xl_heap_rewrite_mapping::num_mappings, xl_heap_rewrite_mapping::offset, OpenTransientFile(), PG_BINARY, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), snprintf(), xl_heap_rewrite_mapping::start_lsn, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC, WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE, WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE, write, XLogRecGetData, and XLogRecGetXid.

Referenced by heap2_redo().

1122 {
1123  char path[MAXPGPATH];
1124  int fd;
1125  xl_heap_rewrite_mapping *xlrec;
1126  uint32 len;
1127  char *data;
1128 
1129  xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
1130 
1131  snprintf(path, MAXPGPATH,
1132  "pg_logical/mappings/" LOGICAL_REWRITE_FORMAT,
1133  xlrec->mapped_db, xlrec->mapped_rel,
1134  (uint32) (xlrec->start_lsn >> 32),
1135  (uint32) xlrec->start_lsn,
1136  xlrec->mapped_xid, XLogRecGetXid(r));
1137 
1138  fd = OpenTransientFile(path,
1139  O_CREAT | O_WRONLY | PG_BINARY);
1140  if (fd < 0)
1141  ereport(ERROR,
1143  errmsg("could not create file \"%s\": %m", path)));
1144 
1145  /*
1146  * Truncate all data that's not guaranteed to have been safely fsynced (by
1147  * previous record or by the last checkpoint).
1148  */
1150  if (ftruncate(fd, xlrec->offset) != 0)
1151  ereport(ERROR,
1153  errmsg("could not truncate file \"%s\" to %u: %m",
1154  path, (uint32) xlrec->offset)));
1156 
1157  /* now seek to the position we want to write our data to */
1158  if (lseek(fd, xlrec->offset, SEEK_SET) != xlrec->offset)
1159  ereport(ERROR,
1161  errmsg("could not seek to end of file \"%s\": %m",
1162  path)));
1163 
1164  data = XLogRecGetData(r) + sizeof(*xlrec);
1165 
1166  len = xlrec->num_mappings * sizeof(LogicalRewriteMappingData);
1167 
1168  /* write out tail end of mapping file (again) */
1170  if (write(fd, data, len) != len)
1171  ereport(ERROR,
1173  errmsg("could not write to file \"%s\": %m", path)));
1175 
1176  /*
1177  * Now fsync all previously written data. We could improve things and only
1178  * do this for the last write to a file, but the required bookkeeping
1179  * doesn't seem worth the trouble.
1180  */
1182  if (pg_fsync(fd) != 0)
1183  ereport(ERROR,
1185  errmsg("could not fsync file \"%s\": %m", path)));
1187 
1188  CloseTransientFile(fd);
1189 }
#define write(a, b, c)
Definition: win32.h:14
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
static int fd(const char *x, int i)
Definition: preproc-init.c:105
#define PG_BINARY
Definition: c.h:1080
#define XLogRecGetData(decoder)
Definition: xlogreader.h:226
#define ERROR
Definition: elog.h:43
int OpenTransientFile(const char *fileName, int fileFlags)
Definition: fd.c:2396
#define MAXPGPATH
int errcode_for_file_access(void)
Definition: elog.c:598
unsigned int uint32
Definition: c.h:325
static void pgstat_report_wait_end(void)
Definition: pgstat.h:1260
#define ereport(elevel, rest)
Definition: elog.h:122
int CloseTransientFile(int fd)
Definition: fd.c:2566
#define XLogRecGetXid(decoder)
Definition: xlogreader.h:224
TransactionId mapped_xid
Definition: heapam_xlog.h:378
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: pgstat.h:1236
#define LOGICAL_REWRITE_FORMAT
Definition: rewriteheap.h:54
int errmsg(const char *fmt,...)
Definition: elog.c:797
struct LogicalRewriteMappingData LogicalRewriteMappingData
int pg_fsync(int fd)
Definition: fd.c:341
#define ftruncate(a, b)
Definition: win32_port.h:60

◆ HeapTupleHeaderAdvanceLatestRemovedXid()

void HeapTupleHeaderAdvanceLatestRemovedXid ( HeapTupleHeader  tuple,
TransactionId latestRemovedXid 
)

Definition at line 7544 of file heapam.c.

References HEAP_MOVED, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleHeaderGetXvac, HeapTupleHeaderXminCommitted, HeapTupleHeaderXminInvalid, HeapTupleHeaderData::t_infomask, TransactionIdDidCommit(), TransactionIdFollows(), and TransactionIdPrecedes().

Referenced by btree_xlog_delete_get_latestRemovedXid(), hash_xlog_vacuum_get_latestRemovedXid(), heap_prune_chain(), and lazy_scan_heap().

7546 {
7547  TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
7549  TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
7550 
7551  if (tuple->t_infomask & HEAP_MOVED)
7552  {
7553  if (TransactionIdPrecedes(*latestRemovedXid, xvac))
7554  *latestRemovedXid = xvac;
7555  }
7556 
7557  /*
7558  * Ignore tuples inserted by an aborted transaction or if the tuple was
7559  * updated/deleted by the inserting transaction.
7560  *
7561  * Look for a committed hint bit, or if no xmin bit is set, check clog.
7562  * This needs to work on both master and standby, where it is used to
7563  * assess btree delete records.
7564  */
7565  if (HeapTupleHeaderXminCommitted(tuple) ||
7567  {
7568  if (xmax != xmin &&
7569  TransactionIdFollows(xmax, *latestRemovedXid))
7570  *latestRemovedXid = xmax;
7571  }
7572 
7573  /* *latestRemovedXid may still be invalid at end */
7574 }
#define HeapTupleHeaderGetUpdateXid(tup)
Definition: htup_details.h:370
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.c:334
uint32 TransactionId
Definition: c.h:474
#define HeapTupleHeaderXminInvalid(tup)
Definition: htup_details.h:334
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:125
#define HeapTupleHeaderXminCommitted(tup)
Definition: htup_details.h:329
#define HeapTupleHeaderGetXvac(tup)
Definition: htup_details.h:420
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:300
#define HEAP_MOVED
Definition: htup_details.h:213
#define HeapTupleHeaderGetXmin(tup)
Definition: htup_details.h:318

◆ log_heap_clean()

XLogRecPtr log_heap_clean ( Relation  reln,
Buffer  buffer,
OffsetNumber redirected,
int  nredirected,
OffsetNumber nowdead,
int  ndead,
OffsetNumber nowunused,
int  nunused,
TransactionId  latestRemovedXid 
)

Definition at line 7612 of file heapam.c.

References Assert, xl_heap_clean::latestRemovedXid, xl_heap_clean::ndead, xl_heap_clean::nredirected, REGBUF_STANDARD, RelationNeedsWAL, SizeOfHeapClean, XLOG_HEAP2_CLEAN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by heap_page_prune(), and lazy_vacuum_page().

7617 {
7618  xl_heap_clean xlrec;
7619  XLogRecPtr recptr;
7620 
7621  /* Caller should not call me on a non-WAL-logged relation */
7622  Assert(RelationNeedsWAL(reln));
7623 
7624  xlrec.latestRemovedXid = latestRemovedXid;
7625  xlrec.nredirected = nredirected;
7626  xlrec.ndead = ndead;
7627 
7628  XLogBeginInsert();
7629  XLogRegisterData((char *) &xlrec, SizeOfHeapClean);
7630 
7632 
7633  /*
7634  * The OffsetNumber arrays are not actually in the buffer, but we pretend
7635  * that they are. When XLogInsert stores the whole buffer, the offset
7636  * arrays need not be stored too. Note that even if all three arrays are
7637  * empty, we want to expose the buffer as a candidate for whole-page
7638  * storage, since this record type implies a defragmentation operation
7639  * even if no item pointers changed state.
7640  */
7641  if (nredirected > 0)
7642  XLogRegisterBufData(0, (char *) redirected,
7643  nredirected * sizeof(OffsetNumber) * 2);
7644 
7645  if (ndead > 0)
7646  XLogRegisterBufData(0, (char *) nowdead,
7647  ndead * sizeof(OffsetNumber));
7648 
7649  if (nunused > 0)
7650  XLogRegisterBufData(0, (char *) nowunused,
7651  nunused * sizeof(OffsetNumber));
7652 
7653  recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_CLEAN);
7654 
7655  return recptr;
7656 }
void XLogRegisterBufData(uint8 block_id, char *data, int len)
Definition: xloginsert.c:361
uint16 nredirected
Definition: heapam_xlog.h:241
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:213
uint16 OffsetNumber
Definition: off.h:24
#define SizeOfHeapClean
Definition: heapam_xlog.h:246
#define XLOG_HEAP2_CLEAN
Definition: heapam_xlog.h:54
#define REGBUF_STANDARD
Definition: xloginsert.h:34
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:699
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:215
#define RelationNeedsWAL(relation)
Definition: rel.h:510
TransactionId latestRemovedXid
Definition: heapam_xlog.h:240
void XLogBeginInsert(void)
Definition: xloginsert.c:120

◆ log_heap_cleanup_info()

XLogRecPtr log_heap_cleanup_info ( RelFileNode  rnode,
TransactionId  latestRemovedXid 
)

Definition at line 7583 of file heapam.c.

References xl_heap_cleanup_info::latestRemovedXid, xl_heap_cleanup_info::node, SizeOfHeapCleanupInfo, XLOG_HEAP2_CLEANUP_INFO, XLogBeginInsert(), XLogInsert(), and XLogRegisterData().

Referenced by vacuum_log_cleanup_info().

7584 {
7585  xl_heap_cleanup_info xlrec;
7586  XLogRecPtr recptr;
7587 
7588  xlrec.node = rnode;
7589  xlrec.latestRemovedXid = latestRemovedXid;
7590 
7591  XLogBeginInsert();
7592  XLogRegisterData((char *) &xlrec, SizeOfHeapCleanupInfo);
7593 
7594  recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_CLEANUP_INFO);
7595 
7596  return recptr;
7597 }
#define SizeOfHeapCleanupInfo
Definition: heapam_xlog.h:259
#define XLOG_HEAP2_CLEANUP_INFO
Definition: heapam_xlog.h:56
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogBeginInsert(void)
Definition: xloginsert.c:120
TransactionId latestRemovedXid
Definition: heapam_xlog.h:256

◆ log_heap_freeze()

XLogRecPtr log_heap_freeze ( Relation  reln,
Buffer  buffer,
TransactionId  cutoff_xid,
xl_heap_freeze_tuple tuples,
int  ntuples 
)

Definition at line 7663 of file heapam.c.

References Assert, xl_heap_freeze_page::cutoff_xid, xl_heap_freeze_page::ntuples, REGBUF_STANDARD, RelationNeedsWAL, SizeOfHeapFreezePage, XLOG_HEAP2_FREEZE_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by lazy_scan_heap().

7665 {
7666  xl_heap_freeze_page xlrec;
7667  XLogRecPtr recptr;
7668 
7669  /* Caller should not call me on a non-WAL-logged relation */
7670  Assert(RelationNeedsWAL(reln));
7671  /* nor when there are no tuples to freeze */
7672  Assert(ntuples > 0);
7673 
7674  xlrec.cutoff_xid = cutoff_xid;
7675  xlrec.ntuples = ntuples;
7676 
7677  XLogBeginInsert();
7678  XLogRegisterData((char *) &xlrec, SizeOfHeapFreezePage);
7679 
7680  /*
7681  * The freeze plan array is not actually in the buffer, but pretend that
7682  * it is. When XLogInsert stores the whole buffer, the freeze plan need
7683  * not be stored too.
7684  */
7686  XLogRegisterBufData(0, (char *) tuples,
7687  ntuples * sizeof(xl_heap_freeze_tuple));
7688 
7689  recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_FREEZE_PAGE);
7690 
7691  return recptr;
7692 }
void XLogRegisterBufData(uint8 block_id, char *data, int len)
Definition: xloginsert.c:361
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:213
TransactionId cutoff_xid
Definition: heapam_xlog.h:335
#define SizeOfHeapFreezePage
Definition: heapam_xlog.h:339
#define REGBUF_STANDARD
Definition: xloginsert.h:34
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:699
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:215
#define RelationNeedsWAL(relation)
Definition: rel.h:510
#define XLOG_HEAP2_FREEZE_PAGE
Definition: heapam_xlog.h:55
void XLogBeginInsert(void)
Definition: xloginsert.c:120

◆ log_heap_visible()

XLogRecPtr log_heap_visible ( RelFileNode  rnode,
Buffer  heap_buffer,
Buffer  vm_buffer,
TransactionId  cutoff_xid,
uint8  flags 
)

Definition at line 7704 of file heapam.c.

References Assert, BufferIsValid, xl_heap_visible::cutoff_xid, xl_heap_visible::flags, REGBUF_NO_IMAGE, REGBUF_STANDARD, SizeOfHeapVisible, XLOG_HEAP2_VISIBLE, XLogBeginInsert(), XLogHintBitIsNeeded, XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by visibilitymap_set().

7706 {
7707  xl_heap_visible xlrec;
7708  XLogRecPtr recptr;
7709  uint8 flags;
7710 
7711  Assert(BufferIsValid(heap_buffer));
7712  Assert(BufferIsValid(vm_buffer));
7713 
7714  xlrec.cutoff_xid = cutoff_xid;
7715  xlrec.flags = vmflags;
7716  XLogBeginInsert();
7717  XLogRegisterData((char *) &xlrec, SizeOfHeapVisible);
7718 
7719  XLogRegisterBuffer(0, vm_buffer, 0);
7720 
7721  flags = REGBUF_STANDARD;
7722  if (!XLogHintBitIsNeeded())
7723  flags |= REGBUF_NO_IMAGE;
7724  XLogRegisterBuffer(1, heap_buffer, flags);
7725 
7726  recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_VISIBLE);
7727 
7728  return recptr;
7729 }
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:213
unsigned char uint8
Definition: c.h:323
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:57
TransactionId cutoff_xid
Definition: heapam_xlog.h:349
#define REGBUF_STANDARD
Definition: xloginsert.h:34
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
#define SizeOfHeapVisible
Definition: heapam_xlog.h:353
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:699
#define REGBUF_NO_IMAGE
Definition: xloginsert.h:31
#define BufferIsValid(bufnum)
Definition: bufmgr.h:114
void XLogBeginInsert(void)
Definition: xloginsert.c:120
#define XLogHintBitIsNeeded()
Definition: xlog.h:157