#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_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	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 248 of file heapam_xlog.h.

Referenced by log_heap_clean().

◆ SizeOfHeapCleanupInfo

#define SizeOfHeapCleanupInfo (sizeof(xl_heap_cleanup_info))

Definition at line 261 of file heapam_xlog.h.

Referenced by log_heap_cleanup_info().

◆ SizeOfHeapConfirm

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

Definition at line 301 of file heapam_xlog.h.

Referenced by heap_finish_speculative().

◆ SizeOfHeapDelete

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

Definition at line 115 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 341 of file heapam_xlog.h.

Referenced by log_heap_freeze().

◆ SizeOfHeapHeader

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

Definition at line 151 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 310 of file heapam_xlog.h.

Referenced by heap_inplace_update().

◆ SizeOfHeapInsert

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

Definition at line 162 of file heapam_xlog.h.

Referenced by heap_insert().

◆ SizeOfHeapLock

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

Definition at line 282 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 293 of file heapam_xlog.h.

Referenced by heap_lock_updated_tuple_rec().

◆ SizeOfHeapMultiInsert

#define SizeOfHeapMultiInsert offsetof(xl_heap_multi_insert, offsets)

Definition at line 182 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 375 of file heapam_xlog.h.

Referenced by log_heap_new_cid().

◆ SizeOfHeapTruncate

#define SizeOfHeapTruncate (offsetof(xl_heap_truncate, relids))

Definition at line 136 of file heapam_xlog.h.

Referenced by ExecuteTruncateGuts().

◆ SizeOfHeapUpdate

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

Definition at line 227 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 355 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 193 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 96 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 103 of file heapam_xlog.h.

Referenced by DecodeDelete().

◆ XLH_DELETE_CONTAINS_OLD_KEY

#define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)

Definition at line 98 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 97 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 100 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 99 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 317 of file heapam_xlog.h.

Referenced by heap_execute_freeze_tuple(), and heap_prepare_freeze_tuple().

◆ XLH_INSERT_ALL_FROZEN_SET

#define XLH_INSERT_ALL_FROZEN_SET (1<<5)

Definition at line 73 of file heapam_xlog.h.

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

◆ 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_INSERT_ON_TOAST_RELATION

#define XLH_INSERT_ON_TOAST_RELATION (1<<4)

Definition at line 70 of file heapam_xlog.h.

Referenced by DecodeInsert(), and heap_insert().

◆ XLH_INVALID_XVAC

#define XLH_INVALID_XVAC 0x04

Definition at line 318 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 271 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 120 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 121 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 84 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 89 of file heapam_xlog.h.

Referenced by DecodeUpdate().

◆ XLH_UPDATE_CONTAINS_OLD_KEY

#define XLH_UPDATE_CONTAINS_OLD_KEY (1<<3)

Definition at line 83 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 82 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 81 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 79 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 85 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 86 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 268 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 266 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 264 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 267 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 265 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 118 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_multi_insert::flags, 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, "latestRemovedXid %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, "latestRemovedXid %u", xlrec->latestRemovedXid);
     }
     else if (info == XLOG_HEAP2_VISIBLE)
     {
         xl_heap_visible *xlrec = (xl_heap_visible *) rec;
 
         appendStringInfo(buf, "cutoff xid %u flags 0x%02X",
                          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 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_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 226 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 9707 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(), appendStringInfoString(), 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.

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

◆ heap_execute_freeze_tuple()

void heap_execute_freeze_tuple	(	HeapTupleHeader	tuple,
		xl_heap_freeze_tuple *	xlrec_tp
	)

Definition at line 6653 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 181 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 9750 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 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);
         }
     }
 }

◆ 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 6424 of file heapam.c.

References Assert, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, FreezeMultiXactId(), FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, 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, TransactionIdIsValid, 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        xmax_already_frozen = false;
     bool        xmin_frozen;
     bool        freeze_xmax;
     TransactionId xid;
 
     frz->frzflags = 0;
     frz->t_infomask2 = tuple->t_infomask2;
     frz->t_infomask = tuple->t_infomask;
     frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
 
     /*
      * Process xmin.  xmin_frozen has two slightly different meanings: in the
      * !XidIsNormal case, it means "the xmin doesn't need any freezing" (it's
      * already a permanent value), while in the block below it is set true to
      * mean "xmin won't need freezing after what we do to it here" (false
      * otherwise).  In both cases we're allowed to set totally_frozen, as far
      * as xmin is concerned.
      */
     xid = HeapTupleHeaderGetXmin(tuple);
     if (!TransactionIdIsNormal(xid))
         xmin_frozen = true;
     else
     {
         if (TransactionIdPrecedes(xid, relfrozenxid))
             ereport(ERROR,
                     (errcode(ERRCODE_DATA_CORRUPTED),
                      errmsg_internal("found xmin %u from before relfrozenxid %u",
                                      xid, relfrozenxid)));
 
         xmin_frozen = TransactionIdPrecedes(xid, cutoff_xid);
         if (xmin_frozen)
         {
             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;
         }
     }
 
     /*
      * 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);
 
         freeze_xmax = (flags & FRM_INVALIDATE_XMAX);
 
         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;
         }
         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;
         }
     }
     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
             freeze_xmax = false;
     }
     else if ((tuple->t_infomask & HEAP_XMAX_INVALID) ||
              !TransactionIdIsValid(HeapTupleHeaderGetRawXmax(tuple)))
     {
         freeze_xmax = false;
         xmax_already_frozen = true;
     }
     else
         ereport(ERROR,
                 (errcode(ERRCODE_DATA_CORRUPTED),
                  errmsg_internal("found xmax %u (infomask 0x%04x) not frozen, not multi, not normal",
                                  xid, tuple->t_infomask)));
 
     if (freeze_xmax)
     {
         Assert(!xmax_already_frozen);
 
         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 = (xmin_frozen &&
                          (freeze_xmax || xmax_already_frozen));
     return changed;
 }

◆ heap_redo()

void heap_redo ( XLogReaderState * record )

Definition at line 9661 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 1109 of file rewriteheap.c.

References CloseTransientFile(), data_sync_elevel(), ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), ftruncate, 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().

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

◆ HeapTupleHeaderAdvanceLatestRemovedXid()

void HeapTupleHeaderAdvanceLatestRemovedXid	(	HeapTupleHeader	tuple,
		TransactionId *	latestRemovedXid
	)

Definition at line 7201 of file heapam.c.

References HEAP_MOVED, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleHeaderGetXvac, HeapTupleHeaderXminCommitted, HeapTupleHeaderXminInvalid, i, InvalidBlockNumber, ItemPointerGetBlockNumber, MAIN_FORKNUM, PrefetchBuffer(), HeapTupleHeaderData::t_infomask, TM_IndexDelete::tid, TransactionIdDidCommit(), TransactionIdFollows(), and TransactionIdPrecedes().

Referenced by heap_index_delete_tuples(), 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.
      */
     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 7984 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 line 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 7955 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 8035 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 8076 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;
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ SizeOfHeapClean

◆ SizeOfHeapCleanupInfo

◆ SizeOfHeapConfirm

◆ SizeOfHeapDelete

◆ SizeOfHeapFreezePage

◆ SizeOfHeapHeader

◆ SizeOfHeapInplace

◆ SizeOfHeapInsert

◆ SizeOfHeapLock

◆ SizeOfHeapLockUpdated

◆ SizeOfHeapMultiInsert

◆ SizeOfHeapNewCid

◆ SizeOfHeapTruncate

◆ SizeOfHeapUpdate

◆ SizeOfHeapVisible

◆ SizeOfMultiInsertTuple

◆ XLH_DELETE_ALL_VISIBLE_CLEARED

◆ XLH_DELETE_CONTAINS_OLD

◆ XLH_DELETE_CONTAINS_OLD_KEY

◆ XLH_DELETE_CONTAINS_OLD_TUPLE

◆ XLH_DELETE_IS_PARTITION_MOVE

◆ XLH_DELETE_IS_SUPER

◆ XLH_FREEZE_XVAC

◆ XLH_INSERT_ALL_FROZEN_SET

◆ XLH_INSERT_ALL_VISIBLE_CLEARED

◆ XLH_INSERT_CONTAINS_NEW_TUPLE

◆ XLH_INSERT_IS_SPECULATIVE

◆ XLH_INSERT_LAST_IN_MULTI

◆ XLH_INSERT_ON_TOAST_RELATION

◆ XLH_INVALID_XVAC

◆ XLH_LOCK_ALL_FROZEN_CLEARED

◆ XLH_TRUNCATE_CASCADE

◆ XLH_TRUNCATE_RESTART_SEQS

◆ XLH_UPDATE_CONTAINS_NEW_TUPLE

◆ XLH_UPDATE_CONTAINS_OLD

◆ XLH_UPDATE_CONTAINS_OLD_KEY

◆ XLH_UPDATE_CONTAINS_OLD_TUPLE

◆ XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED

◆ XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED

◆ XLH_UPDATE_PREFIX_FROM_OLD

◆ XLH_UPDATE_SUFFIX_FROM_OLD

◆ XLHL_KEYS_UPDATED

◆ XLHL_XMAX_EXCL_LOCK

◆ XLHL_XMAX_IS_MULTI

◆ XLHL_XMAX_KEYSHR_LOCK

◆ XLHL_XMAX_LOCK_ONLY

◆ 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_CONFIRM

◆ XLOG_HEAP_DELETE

◆ XLOG_HEAP_HOT_UPDATE

◆ XLOG_HEAP_INIT_PAGE

◆ XLOG_HEAP_INPLACE

◆ XLOG_HEAP_INSERT

◆ XLOG_HEAP_LOCK

◆ XLOG_HEAP_OPMASK

◆ XLOG_HEAP_TRUNCATE

◆ XLOG_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