#include "access/htup.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/buf.h"
#include "storage/bufpage.h"
#include "storage/relfilelocator.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_prune

struct	xl_heap_vacuum

struct	xl_heap_lock

struct	xl_heap_lock_updated

struct	xl_heap_confirm

struct	xl_heap_inplace

struct	xl_heap_freeze_plan

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_PRUNE 0x10

#define	XLOG_HEAP2_VACUUM 0x20

#define	XLOG_HEAP2_FREEZE_PAGE 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_INSERT_ON_TOAST_RELATION (1<<4)

#define	XLH_INSERT_ALL_FROZEN_SET (1<<5)

#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	SizeOfHeapPrune (offsetof(xl_heap_prune, ndead) + sizeof(uint16))

#define	SizeOfHeapVacuum (offsetof(xl_heap_vacuum, nunused) + sizeof(uint16))

#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, nplans) + 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_prune	xl_heap_prune

typedef struct xl_heap_vacuum	xl_heap_vacuum

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_plan	xl_heap_freeze_plan

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	HeapTupleHeaderAdvanceConflictHorizon (HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)

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_visible (RelFileLocator rlocator, Buffer heap_buffer, Buffer vm_buffer, TransactionId snapshotConflictHorizon, uint8 vmflags)

Macro Definition Documentation

◆ SizeOfHeapConfirm

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

Definition at line 305 of file heapam_xlog.h.

◆ SizeOfHeapDelete

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

Definition at line 115 of file heapam_xlog.h.

◆ SizeOfHeapFreezePage

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

Definition at line 352 of file heapam_xlog.h.

◆ SizeOfHeapHeader

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

Definition at line 151 of file heapam_xlog.h.

◆ SizeOfHeapInplace

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

Definition at line 314 of file heapam_xlog.h.

◆ SizeOfHeapInsert

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

Definition at line 162 of file heapam_xlog.h.

◆ SizeOfHeapLock

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

Definition at line 286 of file heapam_xlog.h.

◆ SizeOfHeapLockUpdated

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

Definition at line 297 of file heapam_xlog.h.

◆ SizeOfHeapMultiInsert

#define SizeOfHeapMultiInsert offsetof(xl_heap_multi_insert, offsets)

Definition at line 182 of file heapam_xlog.h.

◆ SizeOfHeapNewCid

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

Definition at line 386 of file heapam_xlog.h.

◆ SizeOfHeapPrune

#define SizeOfHeapPrune (offsetof(xl_heap_prune, ndead) + sizeof(uint16))

Definition at line 251 of file heapam_xlog.h.

◆ SizeOfHeapTruncate

#define SizeOfHeapTruncate (offsetof(xl_heap_truncate, relids))

Definition at line 136 of file heapam_xlog.h.

◆ SizeOfHeapUpdate

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

Definition at line 227 of file heapam_xlog.h.

◆ SizeOfHeapVacuum

#define SizeOfHeapVacuum (offsetof(xl_heap_vacuum, nunused) + sizeof(uint16))

Definition at line 265 of file heapam_xlog.h.

◆ SizeOfHeapVisible

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

Definition at line 366 of file heapam_xlog.h.

◆ SizeOfMultiInsertTuple

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

Definition at line 193 of file heapam_xlog.h.

◆ XLH_DELETE_ALL_VISIBLE_CLEARED

#define XLH_DELETE_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 96 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD

#define XLH_DELETE_CONTAINS_OLD (XLH_DELETE_CONTAINS_OLD_TUPLE | XLH_DELETE_CONTAINS_OLD_KEY)

Definition at line 103 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD_KEY

#define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)

Definition at line 98 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD_TUPLE

#define XLH_DELETE_CONTAINS_OLD_TUPLE (1<<1)

Definition at line 97 of file heapam_xlog.h.

◆ XLH_DELETE_IS_PARTITION_MOVE

#define XLH_DELETE_IS_PARTITION_MOVE (1<<4)

Definition at line 100 of file heapam_xlog.h.

◆ XLH_DELETE_IS_SUPER

#define XLH_DELETE_IS_SUPER (1<<3)

Definition at line 99 of file heapam_xlog.h.

◆ XLH_FREEZE_XVAC

#define XLH_FREEZE_XVAC 0x02

Definition at line 321 of file heapam_xlog.h.

◆ XLH_INSERT_ALL_FROZEN_SET

#define XLH_INSERT_ALL_FROZEN_SET (1<<5)

Definition at line 73 of file heapam_xlog.h.

◆ XLH_INSERT_ALL_VISIBLE_CLEARED

#define XLH_INSERT_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 66 of file heapam_xlog.h.

◆ XLH_INSERT_CONTAINS_NEW_TUPLE

#define XLH_INSERT_CONTAINS_NEW_TUPLE (1<<3)

Definition at line 69 of file heapam_xlog.h.

◆ XLH_INSERT_IS_SPECULATIVE

#define XLH_INSERT_IS_SPECULATIVE (1<<2)

Definition at line 68 of file heapam_xlog.h.

◆ XLH_INSERT_LAST_IN_MULTI

#define XLH_INSERT_LAST_IN_MULTI (1<<1)

Definition at line 67 of file heapam_xlog.h.

◆ XLH_INSERT_ON_TOAST_RELATION

#define XLH_INSERT_ON_TOAST_RELATION (1<<4)

Definition at line 70 of file heapam_xlog.h.

◆ XLH_INVALID_XVAC

#define XLH_INVALID_XVAC 0x04

Definition at line 322 of file heapam_xlog.h.

◆ XLH_LOCK_ALL_FROZEN_CLEARED

#define XLH_LOCK_ALL_FROZEN_CLEARED 0x01

Definition at line 275 of file heapam_xlog.h.

◆ XLH_TRUNCATE_CASCADE

#define XLH_TRUNCATE_CASCADE (1<<0)

Definition at line 120 of file heapam_xlog.h.

◆ XLH_TRUNCATE_RESTART_SEQS

#define XLH_TRUNCATE_RESTART_SEQS (1<<1)

Definition at line 121 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_NEW_TUPLE

#define XLH_UPDATE_CONTAINS_NEW_TUPLE (1<<4)

Definition at line 84 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD

#define XLH_UPDATE_CONTAINS_OLD (XLH_UPDATE_CONTAINS_OLD_TUPLE | XLH_UPDATE_CONTAINS_OLD_KEY)

Definition at line 89 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD_KEY

#define XLH_UPDATE_CONTAINS_OLD_KEY (1<<3)

Definition at line 83 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD_TUPLE

#define XLH_UPDATE_CONTAINS_OLD_TUPLE (1<<2)

Definition at line 82 of file heapam_xlog.h.

◆ XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED (1<<1)

Definition at line 81 of file heapam_xlog.h.

◆ XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 79 of file heapam_xlog.h.

◆ XLH_UPDATE_PREFIX_FROM_OLD

#define XLH_UPDATE_PREFIX_FROM_OLD (1<<5)

Definition at line 85 of file heapam_xlog.h.

◆ XLH_UPDATE_SUFFIX_FROM_OLD

#define XLH_UPDATE_SUFFIX_FROM_OLD (1<<6)

Definition at line 86 of file heapam_xlog.h.

◆ XLHL_KEYS_UPDATED

#define XLHL_KEYS_UPDATED 0x10

Definition at line 272 of file heapam_xlog.h.

◆ XLHL_XMAX_EXCL_LOCK

#define XLHL_XMAX_EXCL_LOCK 0x04

Definition at line 270 of file heapam_xlog.h.

◆ XLHL_XMAX_IS_MULTI

#define XLHL_XMAX_IS_MULTI 0x01

Definition at line 268 of file heapam_xlog.h.

◆ XLHL_XMAX_KEYSHR_LOCK

#define XLHL_XMAX_KEYSHR_LOCK 0x08

Definition at line 271 of file heapam_xlog.h.

◆ XLHL_XMAX_LOCK_ONLY

#define XLHL_XMAX_LOCK_ONLY 0x02

Definition at line 269 of file heapam_xlog.h.

◆ XLOG_HEAP2_FREEZE_PAGE

#define XLOG_HEAP2_FREEZE_PAGE 0x30

Definition at line 56 of file heapam_xlog.h.

◆ XLOG_HEAP2_LOCK_UPDATED

#define XLOG_HEAP2_LOCK_UPDATED 0x60

Definition at line 59 of file heapam_xlog.h.

◆ XLOG_HEAP2_MULTI_INSERT

#define XLOG_HEAP2_MULTI_INSERT 0x50

Definition at line 58 of file heapam_xlog.h.

◆ XLOG_HEAP2_NEW_CID

#define XLOG_HEAP2_NEW_CID 0x70

Definition at line 60 of file heapam_xlog.h.

◆ XLOG_HEAP2_PRUNE

#define XLOG_HEAP2_PRUNE 0x10

Definition at line 54 of file heapam_xlog.h.

◆ XLOG_HEAP2_REWRITE

#define XLOG_HEAP2_REWRITE 0x00

Definition at line 53 of file heapam_xlog.h.

◆ XLOG_HEAP2_VACUUM

#define XLOG_HEAP2_VACUUM 0x20

Definition at line 55 of file heapam_xlog.h.

◆ XLOG_HEAP2_VISIBLE

#define XLOG_HEAP2_VISIBLE 0x40

Definition at line 57 of file heapam_xlog.h.

◆ XLOG_HEAP_CONFIRM

#define XLOG_HEAP_CONFIRM 0x50

Definition at line 37 of file heapam_xlog.h.

◆ XLOG_HEAP_DELETE

#define XLOG_HEAP_DELETE 0x10

Definition at line 33 of file heapam_xlog.h.

◆ XLOG_HEAP_HOT_UPDATE

#define XLOG_HEAP_HOT_UPDATE 0x40

Definition at line 36 of file heapam_xlog.h.

◆ XLOG_HEAP_INIT_PAGE

#define XLOG_HEAP_INIT_PAGE 0x80

Definition at line 46 of file heapam_xlog.h.

◆ XLOG_HEAP_INPLACE

#define XLOG_HEAP_INPLACE 0x70

Definition at line 39 of file heapam_xlog.h.

◆ XLOG_HEAP_INSERT

#define XLOG_HEAP_INSERT 0x00

Definition at line 32 of file heapam_xlog.h.

◆ XLOG_HEAP_LOCK

#define XLOG_HEAP_LOCK 0x60

Definition at line 38 of file heapam_xlog.h.

◆ XLOG_HEAP_OPMASK

#define XLOG_HEAP_OPMASK 0x70

Definition at line 41 of file heapam_xlog.h.

◆ XLOG_HEAP_TRUNCATE

#define XLOG_HEAP_TRUNCATE 0x30

Definition at line 35 of file heapam_xlog.h.

◆ XLOG_HEAP_UPDATE

#define XLOG_HEAP_UPDATE 0x20

Definition at line 34 of file heapam_xlog.h.

Typedef Documentation

◆ xl_heap_confirm

typedef struct xl_heap_confirm xl_heap_confirm

◆ xl_heap_delete

typedef struct xl_heap_delete xl_heap_delete

◆ xl_heap_freeze_page

typedef struct xl_heap_freeze_page xl_heap_freeze_page

◆ xl_heap_freeze_plan

typedef struct xl_heap_freeze_plan xl_heap_freeze_plan

◆ xl_heap_header

typedef struct xl_heap_header xl_heap_header

◆ xl_heap_inplace

typedef struct xl_heap_inplace xl_heap_inplace

◆ xl_heap_insert

typedef struct xl_heap_insert xl_heap_insert

◆ xl_heap_lock

typedef struct xl_heap_lock xl_heap_lock

◆ xl_heap_lock_updated

typedef struct xl_heap_lock_updated xl_heap_lock_updated

◆ xl_heap_multi_insert

typedef struct xl_heap_multi_insert xl_heap_multi_insert

◆ xl_heap_new_cid

typedef struct xl_heap_new_cid xl_heap_new_cid

◆ xl_heap_prune

typedef struct xl_heap_prune xl_heap_prune

◆ xl_heap_rewrite_mapping

typedef struct xl_heap_rewrite_mapping xl_heap_rewrite_mapping

◆ xl_heap_truncate

typedef struct xl_heap_truncate xl_heap_truncate

◆ xl_heap_update

typedef struct xl_heap_update xl_heap_update

◆ xl_heap_vacuum

typedef struct xl_heap_vacuum xl_heap_vacuum

◆ xl_heap_visible

typedef struct xl_heap_visible xl_heap_visible

◆ xl_multi_insert_tuple

typedef struct xl_multi_insert_tuple xl_multi_insert_tuple

Function Documentation

◆ heap2_desc()

void heap2_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 118 of file heapdesc.c.

 {
     char       *rec = XLogRecGetData(record);
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     info &= XLOG_HEAP_OPMASK;
     if (info == XLOG_HEAP2_PRUNE)
     {
         xl_heap_prune *xlrec = (xl_heap_prune *) rec;
  
         appendStringInfo(buf, "snapshotConflictHorizon %u nredirected %u ndead %u",
                          xlrec->snapshotConflictHorizon,
                          xlrec->nredirected,
                          xlrec->ndead);
     }
     else if (info == XLOG_HEAP2_VACUUM)
     {
         xl_heap_vacuum *xlrec = (xl_heap_vacuum *) rec;
  
         appendStringInfo(buf, "nunused %u", xlrec->nunused);
     }
     else if (info == XLOG_HEAP2_FREEZE_PAGE)
     {
         xl_heap_freeze_page *xlrec = (xl_heap_freeze_page *) rec;
  
         appendStringInfo(buf, "snapshotConflictHorizon %u nplans %u",
                          xlrec->snapshotConflictHorizon, xlrec->nplans);
     }
     else if (info == XLOG_HEAP2_VISIBLE)
     {
         xl_heap_visible *xlrec = (xl_heap_visible *) rec;
  
         appendStringInfo(buf, "snapshotConflictHorizon %u flags 0x%02X",
                          xlrec->snapshotConflictHorizon, xlrec->flags);
     }
     else if (info == XLOG_HEAP2_MULTI_INSERT)
     {
         xl_heap_multi_insert *xlrec = (xl_heap_multi_insert *) rec;
  
         appendStringInfo(buf, "%d tuples flags 0x%02X", xlrec->ntuples,
                          xlrec->flags);
     }
     else if (info == XLOG_HEAP2_LOCK_UPDATED)
     {
         xl_heap_lock_updated *xlrec = (xl_heap_lock_updated *) rec;
  
         appendStringInfo(buf, "off %u: xmax %u: flags 0x%02X ",
                          xlrec->offnum, xlrec->xmax, xlrec->flags);
         out_infobits(buf, xlrec->infobits_set);
     }
     else if (info == XLOG_HEAP2_NEW_CID)
     {
         xl_heap_new_cid *xlrec = (xl_heap_new_cid *) rec;
  
         appendStringInfo(buf, "rel %u/%u/%u; tid %u/%u",
                          xlrec->target_locator.spcOid,
                          xlrec->target_locator.dbOid,
                          xlrec->target_locator.relNumber,
                          ItemPointerGetBlockNumber(&(xlrec->target_tid)),
                          ItemPointerGetOffsetNumber(&(xlrec->target_tid)));
         appendStringInfo(buf, "; cmin: %u, cmax: %u, combo: %u",
                          xlrec->cmin, xlrec->cmax, xlrec->combocid);
     }
 }

References appendStringInfo(), buf, xl_heap_new_cid::cmax, xl_heap_new_cid::cmin, xl_heap_new_cid::combocid, RelFileLocator::dbOid, xl_heap_multi_insert::flags, xl_heap_lock_updated::flags, xl_heap_visible::flags, xl_heap_lock_updated::infobits_set, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), xl_heap_prune::ndead, xl_heap_freeze_page::nplans, xl_heap_prune::nredirected, xl_heap_multi_insert::ntuples, xl_heap_vacuum::nunused, xl_heap_lock_updated::offnum, out_infobits(), RelFileLocator::relNumber, xl_heap_prune::snapshotConflictHorizon, xl_heap_freeze_page::snapshotConflictHorizon, xl_heap_visible::snapshotConflictHorizon, RelFileLocator::spcOid, xl_heap_new_cid::target_locator, xl_heap_new_cid::target_tid, XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE, XLOG_HEAP2_VACUUM, XLOG_HEAP2_VISIBLE, XLOG_HEAP_OPMASK, XLogRecGetData, XLogRecGetInfo, XLR_INFO_MASK, and xl_heap_lock_updated::xmax.

◆ heap2_identify()

const char* heap2_identify ( uint8 info )

Definition at line 229 of file heapdesc.c.

 {
     const char *id = NULL;
  
     switch (info & ~XLR_INFO_MASK)
     {
         case XLOG_HEAP2_PRUNE:
             id = "PRUNE";
             break;
         case XLOG_HEAP2_VACUUM:
             id = "VACUUM";
             break;
         case XLOG_HEAP2_FREEZE_PAGE:
             id = "FREEZE_PAGE";
             break;
         case XLOG_HEAP2_VISIBLE:
             id = "VISIBLE";
             break;
         case XLOG_HEAP2_MULTI_INSERT:
             id = "MULTI_INSERT";
             break;
         case XLOG_HEAP2_MULTI_INSERT | XLOG_HEAP_INIT_PAGE:
             id = "MULTI_INSERT+INIT";
             break;
         case XLOG_HEAP2_LOCK_UPDATED:
             id = "LOCK_UPDATED";
             break;
         case XLOG_HEAP2_NEW_CID:
             id = "NEW_CID";
             break;
         case XLOG_HEAP2_REWRITE:
             id = "REWRITE";
             break;
     }
  
     return id;
 }

References XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VACUUM, XLOG_HEAP2_VISIBLE, XLOG_HEAP_INIT_PAGE, and XLR_INFO_MASK.

◆ heap2_redo()

void heap2_redo ( XLogReaderState * record )

Definition at line 10064 of file heapam.c.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     switch (info & XLOG_HEAP_OPMASK)
     {
         case XLOG_HEAP2_PRUNE:
             heap_xlog_prune(record);
             break;
         case XLOG_HEAP2_VACUUM:
             heap_xlog_vacuum(record);
             break;
         case XLOG_HEAP2_FREEZE_PAGE:
             heap_xlog_freeze_page(record);
             break;
         case XLOG_HEAP2_VISIBLE:
             heap_xlog_visible(record);
             break;
         case XLOG_HEAP2_MULTI_INSERT:
             heap_xlog_multi_insert(record);
             break;
         case XLOG_HEAP2_LOCK_UPDATED:
             heap_xlog_lock_updated(record);
             break;
         case XLOG_HEAP2_NEW_CID:
  
             /*
              * Nothing to do on a real replay, only used during logical
              * decoding.
              */
             break;
         case XLOG_HEAP2_REWRITE:
             heap_xlog_logical_rewrite(record);
             break;
         default:
             elog(PANIC, "heap2_redo: unknown op code %u", info);
     }
 }

References elog(), heap_xlog_freeze_page(), heap_xlog_lock_updated(), heap_xlog_logical_rewrite(), heap_xlog_multi_insert(), heap_xlog_prune(), heap_xlog_vacuum(), heap_xlog_visible(), PANIC, XLOG_HEAP2_FREEZE_PAGE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VACUUM, XLOG_HEAP2_VISIBLE, XLOG_HEAP_OPMASK, XLogRecGetInfo, and XLR_INFO_MASK.

◆ heap_desc()

void heap_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 35 of file heapdesc.c.

 {
     char       *rec = XLogRecGetData(record);
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     info &= XLOG_HEAP_OPMASK;
     if (info == XLOG_HEAP_INSERT)
     {
         xl_heap_insert *xlrec = (xl_heap_insert *) rec;
  
         appendStringInfo(buf, "off %u flags 0x%02X", xlrec->offnum,
                          xlrec->flags);
     }
     else if (info == XLOG_HEAP_DELETE)
     {
         xl_heap_delete *xlrec = (xl_heap_delete *) rec;
  
         appendStringInfo(buf, "off %u flags 0x%02X ",
                          xlrec->offnum,
                          xlrec->flags);
         out_infobits(buf, xlrec->infobits_set);
     }
     else if (info == XLOG_HEAP_UPDATE)
     {
         xl_heap_update *xlrec = (xl_heap_update *) rec;
  
         appendStringInfo(buf, "off %u xmax %u flags 0x%02X ",
                          xlrec->old_offnum,
                          xlrec->old_xmax,
                          xlrec->flags);
         out_infobits(buf, xlrec->old_infobits_set);
         appendStringInfo(buf, "; new off %u xmax %u",
                          xlrec->new_offnum,
                          xlrec->new_xmax);
     }
     else if (info == XLOG_HEAP_HOT_UPDATE)
     {
         xl_heap_update *xlrec = (xl_heap_update *) rec;
  
         appendStringInfo(buf, "off %u xmax %u flags 0x%02X ",
                          xlrec->old_offnum,
                          xlrec->old_xmax,
                          xlrec->flags);
         out_infobits(buf, xlrec->old_infobits_set);
         appendStringInfo(buf, "; new off %u xmax %u",
                          xlrec->new_offnum,
                          xlrec->new_xmax);
     }
     else if (info == XLOG_HEAP_TRUNCATE)
     {
         xl_heap_truncate *xlrec = (xl_heap_truncate *) rec;
         int         i;
  
         if (xlrec->flags & XLH_TRUNCATE_CASCADE)
             appendStringInfoString(buf, "cascade ");
         if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS)
             appendStringInfoString(buf, "restart_seqs ");
         appendStringInfo(buf, "nrelids %u relids", xlrec->nrelids);
         for (i = 0; i < xlrec->nrelids; i++)
             appendStringInfo(buf, " %u", xlrec->relids[i]);
     }
     else if (info == XLOG_HEAP_CONFIRM)
     {
         xl_heap_confirm *xlrec = (xl_heap_confirm *) rec;
  
         appendStringInfo(buf, "off %u", xlrec->offnum);
     }
     else if (info == XLOG_HEAP_LOCK)
     {
         xl_heap_lock *xlrec = (xl_heap_lock *) rec;
  
         appendStringInfo(buf, "off %u: xid %u: flags 0x%02X ",
                          xlrec->offnum, xlrec->locking_xid, xlrec->flags);
         out_infobits(buf, xlrec->infobits_set);
     }
     else if (info == XLOG_HEAP_INPLACE)
     {
         xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
  
         appendStringInfo(buf, "off %u", xlrec->offnum);
     }
 }

References appendStringInfo(), appendStringInfoString(), buf, xl_heap_delete::flags, xl_heap_truncate::flags, xl_heap_insert::flags, xl_heap_update::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.

◆ heap_identify()

const char* heap_identify ( uint8 info )

Definition at line 184 of file heapdesc.c.

 {
     const char *id = NULL;
  
     switch (info & ~XLR_INFO_MASK)
     {
         case XLOG_HEAP_INSERT:
             id = "INSERT";
             break;
         case XLOG_HEAP_INSERT | XLOG_HEAP_INIT_PAGE:
             id = "INSERT+INIT";
             break;
         case XLOG_HEAP_DELETE:
             id = "DELETE";
             break;
         case XLOG_HEAP_UPDATE:
             id = "UPDATE";
             break;
         case XLOG_HEAP_UPDATE | XLOG_HEAP_INIT_PAGE:
             id = "UPDATE+INIT";
             break;
         case XLOG_HEAP_HOT_UPDATE:
             id = "HOT_UPDATE";
             break;
         case XLOG_HEAP_HOT_UPDATE | XLOG_HEAP_INIT_PAGE:
             id = "HOT_UPDATE+INIT";
             break;
         case XLOG_HEAP_TRUNCATE:
             id = "TRUNCATE";
             break;
         case XLOG_HEAP_CONFIRM:
             id = "HEAP_CONFIRM";
             break;
         case XLOG_HEAP_LOCK:
             id = "LOCK";
             break;
         case XLOG_HEAP_INPLACE:
             id = "INPLACE";
             break;
     }
  
     return id;
 }

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.

◆ heap_mask()

void heap_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 10107 of file heapam.c.

 {
     Page        page = (Page) pagedata;
     OffsetNumber off;
  
     mask_page_lsn_and_checksum(page);
  
     mask_page_hint_bits(page);
     mask_unused_space(page);
  
     for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
     {
         ItemId      iid = PageGetItemId(page, off);
         char       *page_item;
  
         page_item = (char *) (page + ItemIdGetOffset(iid));
  
         if (ItemIdIsNormal(iid))
         {
             HeapTupleHeader page_htup = (HeapTupleHeader) page_item;
  
             /*
              * If xmin of a tuple is not yet frozen, we should ignore
              * differences in hint bits, since they can be set without
              * emitting WAL.
              */
             if (!HeapTupleHeaderXminFrozen(page_htup))
                 page_htup->t_infomask &= ~HEAP_XACT_MASK;
             else
             {
                 /* Still we need to mask xmax hint bits. */
                 page_htup->t_infomask &= ~HEAP_XMAX_INVALID;
                 page_htup->t_infomask &= ~HEAP_XMAX_COMMITTED;
             }
  
             /*
              * During replay, we set Command Id to FirstCommandId. Hence, mask
              * it. See heap_xlog_insert() for details.
              */
             page_htup->t_choice.t_heap.t_field3.t_cid = MASK_MARKER;
  
             /*
              * For a speculative tuple, heap_insert() does not set ctid in the
              * caller-passed heap tuple itself, leaving the ctid field to
              * contain a speculative token value - a per-backend monotonically
              * increasing identifier. Besides, it does not WAL-log ctid under
              * any circumstances.
              *
              * During redo, heap_xlog_insert() sets t_ctid to current block
              * number and self offset number. It doesn't care about any
              * speculative insertions on the primary. Hence, we set t_ctid to
              * current block number and self offset number to ignore any
              * inconsistency.
              */
             if (HeapTupleHeaderIsSpeculative(page_htup))
                 ItemPointerSet(&page_htup->t_ctid, blkno, off);
  
             /*
              * NB: Not ignoring ctid changes due to the tuple having moved
              * (i.e. HeapTupleHeaderIndicatesMovedPartitions), because that's
              * important information that needs to be in-sync between primary
              * and standby, and thus is WAL logged.
              */
         }
  
         /*
          * Ignore any padding bytes after the tuple, when the length of the
          * item is not MAXALIGNed.
          */
         if (ItemIdHasStorage(iid))
         {
             int         len = ItemIdGetLength(iid);
             int         padlen = MAXALIGN(len) - len;
  
             if (padlen > 0)
                 memset(page_item + len, MASK_MARKER, padlen);
         }
     }
 }

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

◆ heap_redo()

void heap_redo ( XLogReaderState * record )

Definition at line 10018 of file heapam.c.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
  
     /*
      * These operations don't overwrite MVCC data so no conflict processing is
      * required. The ones in heap2 rmgr do.
      */
  
     switch (info & XLOG_HEAP_OPMASK)
     {
         case XLOG_HEAP_INSERT:
             heap_xlog_insert(record);
             break;
         case XLOG_HEAP_DELETE:
             heap_xlog_delete(record);
             break;
         case XLOG_HEAP_UPDATE:
             heap_xlog_update(record, false);
             break;
         case XLOG_HEAP_TRUNCATE:
  
             /*
              * TRUNCATE is a no-op because the actions are already logged as
              * SMGR WAL records.  TRUNCATE WAL record only exists for logical
              * decoding.
              */
             break;
         case XLOG_HEAP_HOT_UPDATE:
             heap_xlog_update(record, true);
             break;
         case XLOG_HEAP_CONFIRM:
             heap_xlog_confirm(record);
             break;
         case XLOG_HEAP_LOCK:
             heap_xlog_lock(record);
             break;
         case XLOG_HEAP_INPLACE:
             heap_xlog_inplace(record);
             break;
         default:
             elog(PANIC, "heap_redo: unknown op code %u", info);
     }
 }

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.

◆ heap_xlog_logical_rewrite()

void heap_xlog_logical_rewrite ( XLogReaderState * r )

Definition at line 1107 of file rewriteheap.c.

 {
     char        path[MAXPGPATH];
     int         fd;
     xl_heap_rewrite_mapping *xlrec;
     uint32      len;
     char       *data;
  
     xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
  
     snprintf(path, MAXPGPATH,
              "pg_logical/mappings/" LOGICAL_REWRITE_FORMAT,
              xlrec->mapped_db, xlrec->mapped_rel,
              LSN_FORMAT_ARGS(xlrec->start_lsn),
              xlrec->mapped_xid, XLogRecGetXid(r));
  
     fd = OpenTransientFile(path,
                            O_CREAT | O_WRONLY | PG_BINARY);
     if (fd < 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not create file \"%s\": %m", path)));
  
     /*
      * Truncate all data that's not guaranteed to have been safely fsynced (by
      * previous record or by the last checkpoint).
      */
     pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE);
     if (ftruncate(fd, xlrec->offset) != 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not truncate file \"%s\" to %u: %m",
                         path, (uint32) xlrec->offset)));
     pgstat_report_wait_end();
  
     data = XLogRecGetData(r) + sizeof(*xlrec);
  
     len = xlrec->num_mappings * sizeof(LogicalRewriteMappingData);
  
     /* write out tail end of mapping file (again) */
     errno = 0;
     pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE);
     if (pg_pwrite(fd, data, len, xlrec->offset) != len)
     {
         /* if write didn't set errno, assume problem is no disk space */
         if (errno == 0)
             errno = ENOSPC;
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not write to file \"%s\": %m", path)));
     }
     pgstat_report_wait_end();
  
     /*
      * Now fsync all previously written data. We could improve things and only
      * do this for the last write to a file, but the required bookkeeping
      * doesn't seem worth the trouble.
      */
     pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC);
     if (pg_fsync(fd) != 0)
         ereport(data_sync_elevel(ERROR),
                 (errcode_for_file_access(),
                  errmsg("could not fsync file \"%s\": %m", path)));
     pgstat_report_wait_end();
  
     if (CloseTransientFile(fd) != 0)
         ereport(ERROR,
                 (errcode_for_file_access(),
                  errmsg("could not close file \"%s\": %m", path)));
 }

References CloseTransientFile(), data, data_sync_elevel(), ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), ftruncate, len, LOGICAL_REWRITE_FORMAT, LSN_FORMAT_ARGS, 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(), pg_pwrite, 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, XLogRecGetData, and XLogRecGetXid.

Referenced by heap2_redo().

◆ HeapTupleHeaderAdvanceConflictHorizon()

void HeapTupleHeaderAdvanceConflictHorizon	(	HeapTupleHeader	tuple,
		TransactionId *	snapshotConflictHorizon
	)

Definition at line 7419 of file heapam.c.

 {
     TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
     TransactionId xmax = HeapTupleHeaderGetUpdateXid(tuple);
     TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
  
     if (tuple->t_infomask & HEAP_MOVED)
     {
         if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
             *snapshotConflictHorizon = xvac;
     }
  
     /*
      * Ignore tuples inserted by an aborted transaction or if the tuple was
      * updated/deleted by the inserting transaction.
      *
      * Look for a committed hint bit, or if no xmin bit is set, check clog.
      */
     if (HeapTupleHeaderXminCommitted(tuple) ||
         (!HeapTupleHeaderXminInvalid(tuple) && TransactionIdDidCommit(xmin)))
     {
         if (xmax != xmin &&
             TransactionIdFollows(xmax, *snapshotConflictHorizon))
             *snapshotConflictHorizon = xmax;
     }
 }

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

Referenced by heap_index_delete_tuples(), and heap_prune_chain().

◆ log_heap_visible()

XLogRecPtr log_heap_visible	(	RelFileLocator	rlocator,
		Buffer	heap_buffer,
		Buffer	vm_buffer,
		TransactionId	snapshotConflictHorizon,
		uint8	vmflags
	)

Definition at line 8251 of file heapam.c.

 {
     xl_heap_visible xlrec;
     XLogRecPtr  recptr;
     uint8       flags;
  
     Assert(BufferIsValid(heap_buffer));
     Assert(BufferIsValid(vm_buffer));
  
     xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
     xlrec.flags = vmflags;
     XLogBeginInsert();
     XLogRegisterData((char *) &xlrec, SizeOfHeapVisible);
  
     XLogRegisterBuffer(0, vm_buffer, 0);
  
     flags = REGBUF_STANDARD;
     if (!XLogHintBitIsNeeded())
         flags |= REGBUF_NO_IMAGE;
     XLogRegisterBuffer(1, heap_buffer, flags);
  
     recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_VISIBLE);
  
     return recptr;
 }

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

Referenced by visibilitymap_set().

Data Structures

Macros

Typedefs

Functions