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

Definition at line 149 of file heapam_xlog.h.

Referenced by DecodeDelete(), DecodeInsert(), DecodeUpdate(), DecodeXLogTuple(), heap_delete(), heap_insert(), heap_xlog_insert(), heap_xlog_update(), and log_heap_update().

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)

Definition at line 66 of file heapam_xlog.h.

Referenced by heap_insert(), heap_multi_insert(), heap_xlog_insert(), and heap_xlog_multi_insert().

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

Definition at line 269 of file heapam_xlog.h.

Referenced by heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), heap_xlog_lock(), and heap_xlog_lock_updated().

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

Definition at line 56 of file heapam_xlog.h.

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

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

Definition at line 59 of file heapam_xlog.h.

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

XLOG_HEAP2_MULTI_INSERT

#define XLOG_HEAP2_MULTI_INSERT   0x50

Definition at line 58 of file heapam_xlog.h.

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

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

Definition at line 53 of file heapam_xlog.h.

Referenced by DecodeHeap2Op(), heap2_identify(), heap2_redo(), and logical_heap_rewrite_flush_mappings().

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

Definition at line 37 of file heapam_xlog.h.

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

XLOG_HEAP_DELETE

#define XLOG_HEAP_DELETE   0x10

Definition at line 33 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_abort_speculative(), heap_delete(), heap_desc(), heap_identify(), and heap_redo().

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

#define XLOG_HEAP_INIT_PAGE   0x80

Definition at line 46 of file heapam_xlog.h.

Referenced by heap2_identify(), heap_identify(), heap_insert(), heap_multi_insert(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), and log_heap_update().

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

Definition at line 38 of file heapam_xlog.h.

Referenced by DecodeHeapOp(), heap_desc(), heap_identify(), heap_lock_tuple(), heap_redo(), and heap_update().

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

typedef struct xl_heap_clean xl_heap_clean

xl_heap_cleanup_info

typedef struct xl_heap_cleanup_info xl_heap_cleanup_info

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_tuple

typedef struct xl_heap_freeze_tuple xl_heap_freeze_tuple

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

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    info &= XLOG_HEAP_OPMASK;
    if (info == XLOG_HEAP2_CLEAN)
    {
        xl_heap_clean *xlrec = (xl_heap_clean *) rec;

        appendStringInfo(buf, "remxid %u", xlrec->latestRemovedXid);
    }
    else if (info == XLOG_HEAP2_FREEZE_PAGE)
    {
        xl_heap_freeze_page *xlrec = (xl_heap_freeze_page *) rec;

        appendStringInfo(buf, "cutoff xid %u ntuples %u",
                         xlrec->cutoff_xid, xlrec->ntuples);
    }
    else if (info == XLOG_HEAP2_CLEANUP_INFO)
    {
        xl_heap_cleanup_info *xlrec = (xl_heap_cleanup_info *) rec;

        appendStringInfo(buf, "remxid %u", xlrec->latestRemovedXid);
    }
    else if (info == XLOG_HEAP2_VISIBLE)
    {
        xl_heap_visible *xlrec = (xl_heap_visible *) rec;

        appendStringInfo(buf, "cutoff xid %u flags %d",
                         xlrec->cutoff_xid, xlrec->flags);
    }
    else if (info == XLOG_HEAP2_MULTI_INSERT)
    {
        xl_heap_multi_insert *xlrec = (xl_heap_multi_insert *) rec;

        appendStringInfo(buf, "%d tuples", xlrec->ntuples);
    }
    else if (info == XLOG_HEAP2_LOCK_UPDATED)
    {
        xl_heap_lock_updated *xlrec = (xl_heap_lock_updated *) rec;

        appendStringInfo(buf, "off %u: xmax %u: flags %u ",
                         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_node.spcNode,
                         xlrec->target_node.dbNode,
                         xlrec->target_node.relNode,
                         ItemPointerGetBlockNumber(&(xlrec->target_tid)),
                         ItemPointerGetOffsetNumber(&(xlrec->target_tid)));
        appendStringInfo(buf, "; cmin: %u, cmax: %u, combo: %u",
                         xlrec->cmin, xlrec->cmax, xlrec->combocid);
    }
}

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.

{
    const char *id = NULL;

    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_HEAP2_CLEAN:
            id = "CLEAN";
            break;
        case XLOG_HEAP2_FREEZE_PAGE:
            id = "FREEZE_PAGE";
            break;
        case XLOG_HEAP2_CLEANUP_INFO:
            id = "CLEANUP_INFO";
            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;
}

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.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    switch (info & XLOG_HEAP_OPMASK)
    {
        case XLOG_HEAP2_CLEAN:
            heap_xlog_clean(record);
            break;
        case XLOG_HEAP2_FREEZE_PAGE:
            heap_xlog_freeze_page(record);
            break;
        case XLOG_HEAP2_CLEANUP_INFO:
            heap_xlog_cleanup_info(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);
    }
}

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.

{
    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", xlrec->offnum);
    }
    else if (info == XLOG_HEAP_DELETE)
    {
        xl_heap_delete *xlrec = (xl_heap_delete *) rec;

        appendStringInfo(buf, "off %u ", xlrec->offnum);
        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 ",
                         xlrec->old_offnum,
                         xlrec->old_xmax);
        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 ",
                         xlrec->old_offnum,
                         xlrec->old_xmax);
        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)
            appendStringInfo(buf, "cascade ");
        if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS)
            appendStringInfo(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 %u ",
                         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);
    }
}

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().

{
    HeapTupleHeaderSetXmax(tuple, frz->xmax);

    if (frz->frzflags & XLH_FREEZE_XVAC)
        HeapTupleHeaderSetXvac(tuple, FrozenTransactionId);

    if (frz->frzflags & XLH_INVALID_XVAC)
        HeapTupleHeaderSetXvac(tuple, InvalidTransactionId);

    tuple->t_infomask = frz->t_infomask;
    tuple->t_infomask2 = frz->t_infomask2;
}

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.

{
    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;
}

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.

{
    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 in master. 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);
        }
    }
}

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().

{
    bool        changed = false;
    bool        freeze_xmax = false;
    TransactionId xid;
    bool        totally_frozen = true;

    frz->frzflags = 0;
    frz->t_infomask2 = tuple->t_infomask2;
    frz->t_infomask = tuple->t_infomask;
    frz->xmax = HeapTupleHeaderGetRawXmax(tuple);

    /* Process xmin */
    xid = HeapTupleHeaderGetXmin(tuple);
    if (TransactionIdIsNormal(xid))
    {
        if (TransactionIdPrecedes(xid, relfrozenxid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg_internal("found xmin %u from before relfrozenxid %u",
                                     xid, relfrozenxid)));

        if (TransactionIdPrecedes(xid, cutoff_xid))
        {
            if (!TransactionIdDidCommit(xid))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("uncommitted xmin %u from before xid cutoff %u needs to be frozen",
                                         xid, cutoff_xid)));

            frz->t_infomask |= HEAP_XMIN_FROZEN;
            changed = true;
        }
        else
            totally_frozen = false;
    }

    /*
     * Process xmax.  To thoroughly examine the current Xmax value we need to
     * resolve a MultiXactId to its member Xids, in case some of them are
     * below the given cutoff for Xids.  In that case, those values might need
     * freezing, too.  Also, if a multi needs freezing, we cannot simply take
     * it out --- if there's a live updater Xid, it needs to be kept.
     *
     * Make sure to keep heap_tuple_needs_freeze in sync with this.
     */
    xid = HeapTupleHeaderGetRawXmax(tuple);

    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
    {
        TransactionId newxmax;
        uint16      flags;

        newxmax = FreezeMultiXactId(xid, tuple->t_infomask,
                                    relfrozenxid, relminmxid,
                                    cutoff_xid, cutoff_multi, &flags);

        if (flags & FRM_INVALIDATE_XMAX)
            freeze_xmax = true;
        else if (flags & FRM_RETURN_IS_XID)
        {
            /*
             * NB -- some of these transformations are only valid because we
             * know the return Xid is a tuple updater (i.e. not merely a
             * locker.) Also note that the only reason we don't explicitly
             * worry about HEAP_KEYS_UPDATED is because it lives in
             * t_infomask2 rather than t_infomask.
             */
            frz->t_infomask &= ~HEAP_XMAX_BITS;
            frz->xmax = newxmax;
            if (flags & FRM_MARK_COMMITTED)
                frz->t_infomask |= HEAP_XMAX_COMMITTED;
            changed = true;
            totally_frozen = false;
        }
        else if (flags & FRM_RETURN_IS_MULTI)
        {
            uint16      newbits;
            uint16      newbits2;

            /*
             * We can't use GetMultiXactIdHintBits directly on the new multi
             * here; that routine initializes the masks to all zeroes, which
             * would lose other bits we need.  Doing it this way ensures all
             * unrelated bits remain untouched.
             */
            frz->t_infomask &= ~HEAP_XMAX_BITS;
            frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
            GetMultiXactIdHintBits(newxmax, &newbits, &newbits2);
            frz->t_infomask |= newbits;
            frz->t_infomask2 |= newbits2;

            frz->xmax = newxmax;

            changed = true;
            totally_frozen = false;
        }
        else
        {
            Assert(flags & FRM_NOOP);
        }
    }
    else if (TransactionIdIsNormal(xid))
    {
        if (TransactionIdPrecedes(xid, relfrozenxid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg_internal("found xmax %u from before relfrozenxid %u",
                                     xid, relfrozenxid)));

        if (TransactionIdPrecedes(xid, cutoff_xid))
        {
            /*
             * If we freeze xmax, make absolutely sure that it's not an XID
             * that is important.  (Note, a lock-only xmax can be removed
             * independent of committedness, since a committed lock holder has
             * released the lock).
             */
            if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) &&
                TransactionIdDidCommit(xid))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("cannot freeze committed xmax %u",
                                         xid)));
            freeze_xmax = true;
        }
        else
            totally_frozen = false;
    }

    if (freeze_xmax)
    {
        frz->xmax = InvalidTransactionId;

        /*
         * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
         * LOCKED.  Normalize to INVALID just to be sure no one gets confused.
         * Also get rid of the HEAP_KEYS_UPDATED bit.
         */
        frz->t_infomask &= ~HEAP_XMAX_BITS;
        frz->t_infomask |= HEAP_XMAX_INVALID;
        frz->t_infomask2 &= ~HEAP_HOT_UPDATED;
        frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
        changed = true;
    }

    /*
     * Old-style VACUUM FULL is gone, but we have to keep this code as long as
     * we support having MOVED_OFF/MOVED_IN tuples in the database.
     */
    if (tuple->t_infomask & HEAP_MOVED)
    {
        xid = HeapTupleHeaderGetXvac(tuple);

        /*
         * For Xvac, we ignore the cutoff_xid and just always perform the
         * freeze operation.  The oldest release in which such a value can
         * actually be set is PostgreSQL 8.4, because old-style VACUUM FULL
         * was removed in PostgreSQL 9.0.  Note that if we were to respect
         * cutoff_xid here, we'd need to make surely to clear totally_frozen
         * when we skipped freezing on that basis.
         */
        if (TransactionIdIsNormal(xid))
        {
            /*
             * If a MOVED_OFF tuple is not dead, the xvac transaction must
             * have failed; whereas a non-dead MOVED_IN tuple must mean the
             * xvac transaction succeeded.
             */
            if (tuple->t_infomask & HEAP_MOVED_OFF)
                frz->frzflags |= XLH_INVALID_XVAC;
            else
                frz->frzflags |= XLH_FREEZE_XVAC;

            /*
             * Might as well fix the hint bits too; usually XMIN_COMMITTED
             * will already be set here, but there's a small chance not.
             */
            Assert(!(tuple->t_infomask & HEAP_XMIN_INVALID));
            frz->t_infomask |= HEAP_XMIN_COMMITTED;
            changed = true;
        }
    }

    *totally_frozen_p = totally_frozen;
    return changed;
}

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.

{
    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);
    }
}

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().

{
    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,
             (uint32) (xlrec->start_lsn >> 32),
             (uint32) 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();

    /* now seek to the position we want to write our data to */
    if (lseek(fd, xlrec->offset, SEEK_SET) != xlrec->offset)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not seek to end of file \"%s\": %m",
                        path)));

    data = XLogRecGetData(r) + sizeof(*xlrec);

    len = xlrec->num_mappings * sizeof(LogicalRewriteMappingData);

    /* write out tail end of mapping file (again) */
    pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE);
    if (write(fd, data, len) != len)
        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(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m", path)));
    pgstat_report_wait_end();

    CloseTransientFile(fd);
}

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().

{
    TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
    TransactionId xmax = HeapTupleHeaderGetUpdateXid(tuple);
    TransactionId xvac = HeapTupleHeaderGetXvac(tuple);

    if (tuple->t_infomask & HEAP_MOVED)
    {
        if (TransactionIdPrecedes(*latestRemovedXid, xvac))
            *latestRemovedXid = 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.
     * This needs to work on both master and standby, where it is used to
     * assess btree delete records.
     */
    if (HeapTupleHeaderXminCommitted(tuple) ||
        (!HeapTupleHeaderXminInvalid(tuple) && TransactionIdDidCommit(xmin)))
    {
        if (xmax != xmin &&
            TransactionIdFollows(xmax, *latestRemovedXid))
            *latestRemovedXid = xmax;
    }

    /* *latestRemovedXid may still be invalid at end */
}

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().

{
    xl_heap_clean xlrec;
    XLogRecPtr  recptr;

    /* Caller should not call me on a non-WAL-logged relation */
    Assert(RelationNeedsWAL(reln));

    xlrec.latestRemovedXid = latestRemovedXid;
    xlrec.nredirected = nredirected;
    xlrec.ndead = ndead;

    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec, SizeOfHeapClean);

    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);

    /*
     * The OffsetNumber arrays are not actually in the buffer, but we pretend
     * that they are.  When XLogInsert stores the whole buffer, the offset
     * arrays need not be stored too.  Note that even if all three arrays are
     * empty, we want to expose the buffer as a candidate for whole-page
     * storage, since this record type implies a defragmentation operation
     * even if no item pointers changed state.
     */
    if (nredirected > 0)
        XLogRegisterBufData(0, (char *) redirected,
                            nredirected * sizeof(OffsetNumber) * 2);

    if (ndead > 0)
        XLogRegisterBufData(0, (char *) nowdead,
                            ndead * sizeof(OffsetNumber));

    if (nunused > 0)
        XLogRegisterBufData(0, (char *) nowunused,
                            nunused * sizeof(OffsetNumber));

    recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_CLEAN);

    return recptr;
}

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().

{
    xl_heap_cleanup_info xlrec;
    XLogRecPtr  recptr;

    xlrec.node = rnode;
    xlrec.latestRemovedXid = latestRemovedXid;

    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec, SizeOfHeapCleanupInfo);

    recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_CLEANUP_INFO);

    return recptr;
}

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().

{
    xl_heap_freeze_page xlrec;
    XLogRecPtr  recptr;

    /* Caller should not call me on a non-WAL-logged relation */
    Assert(RelationNeedsWAL(reln));
    /* nor when there are no tuples to freeze */
    Assert(ntuples > 0);

    xlrec.cutoff_xid = cutoff_xid;
    xlrec.ntuples = ntuples;

    XLogBeginInsert();
    XLogRegisterData((char *) &xlrec, SizeOfHeapFreezePage);

    /*
     * The freeze plan array is not actually in the buffer, but pretend that
     * it is.  When XLogInsert stores the whole buffer, the freeze plan need
     * not be stored too.
     */
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
    XLogRegisterBufData(0, (char *) tuples,
                        ntuples * sizeof(xl_heap_freeze_tuple));

    recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_FREEZE_PAGE);

    return recptr;
}

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().

{
    xl_heap_visible xlrec;
    XLogRecPtr  recptr;
    uint8       flags;

    Assert(BufferIsValid(heap_buffer));
    Assert(BufferIsValid(vm_buffer));

    xlrec.cutoff_xid = cutoff_xid;
    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;
}