#include "access/htup.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/buf.h"
#include "storage/bufpage.h"
#include "storage/relfilelocator.h"
#include "storage/sinval.h"
#include "utils/relcache.h"

Include dependency graph for heapam_xlog.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	xl_heap_delete

struct	xl_heap_truncate

struct	xl_heap_header

struct	xl_heap_insert

struct	xl_heap_multi_insert

struct	xl_multi_insert_tuple

struct	xl_heap_update

struct	xl_heap_prune

struct	xlhp_freeze_plan

struct	xlhp_freeze_plans

struct	xlhp_prune_items

struct	xl_heap_lock

struct	xl_heap_lock_updated

struct	xl_heap_confirm

struct	xl_heap_inplace

struct	xl_heap_visible

struct	xl_heap_new_cid

struct	xl_heap_rewrite_mapping

Macros
#define	XLOG_HEAP_INSERT 0x00

#define	XLOG_HEAP_DELETE 0x10

#define	XLOG_HEAP_UPDATE 0x20

#define	XLOG_HEAP_TRUNCATE 0x30

#define	XLOG_HEAP_HOT_UPDATE 0x40

#define	XLOG_HEAP_CONFIRM 0x50

#define	XLOG_HEAP_LOCK 0x60

#define	XLOG_HEAP_INPLACE 0x70

#define	XLOG_HEAP_OPMASK 0x70

#define	XLOG_HEAP_INIT_PAGE 0x80

#define	XLOG_HEAP2_REWRITE 0x00

#define	XLOG_HEAP2_PRUNE_ON_ACCESS 0x10

#define	XLOG_HEAP2_PRUNE_VACUUM_SCAN 0x20

#define	XLOG_HEAP2_PRUNE_VACUUM_CLEANUP 0x30

#define	XLOG_HEAP2_VISIBLE 0x40

#define	XLOG_HEAP2_MULTI_INSERT 0x50

#define	XLOG_HEAP2_LOCK_UPDATED 0x60

#define	XLOG_HEAP2_NEW_CID 0x70

#define	XLH_INSERT_ALL_VISIBLE_CLEARED (1<<0)

#define	XLH_INSERT_LAST_IN_MULTI (1<<1)

#define	XLH_INSERT_IS_SPECULATIVE (1<<2)

#define	XLH_INSERT_CONTAINS_NEW_TUPLE (1<<3)

#define	XLH_INSERT_ON_TOAST_RELATION (1<<4)

#define	XLH_INSERT_ALL_FROZEN_SET (1<<5)

#define	XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED (1<<0)

#define	XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED (1<<1)

#define	XLH_UPDATE_CONTAINS_OLD_TUPLE (1<<2)

#define	XLH_UPDATE_CONTAINS_OLD_KEY (1<<3)

#define	XLH_UPDATE_CONTAINS_NEW_TUPLE (1<<4)

#define	XLH_UPDATE_PREFIX_FROM_OLD (1<<5)

#define	XLH_UPDATE_SUFFIX_FROM_OLD (1<<6)

#define	XLH_UPDATE_CONTAINS_OLD (XLH_UPDATE_CONTAINS_OLD_TUPLE \| XLH_UPDATE_CONTAINS_OLD_KEY)

#define	XLH_DELETE_ALL_VISIBLE_CLEARED (1<<0)

#define	XLH_DELETE_CONTAINS_OLD_TUPLE (1<<1)

#define	XLH_DELETE_CONTAINS_OLD_KEY (1<<2)

#define	XLH_DELETE_IS_SUPER (1<<3)

#define	XLH_DELETE_IS_PARTITION_MOVE (1<<4)

#define	XLH_DELETE_CONTAINS_OLD (XLH_DELETE_CONTAINS_OLD_TUPLE \| XLH_DELETE_CONTAINS_OLD_KEY)

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

#define	XLH_TRUNCATE_CASCADE (1<<0)

#define	XLH_TRUNCATE_RESTART_SEQS (1<<1)

#define	SizeOfHeapTruncate (offsetof(xl_heap_truncate, relids))

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

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

#define	SizeOfHeapMultiInsert offsetof(xl_heap_multi_insert, offsets)

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

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

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

#define	XLHP_IS_CATALOG_REL (1 << 1)

#define	XLHP_CLEANUP_LOCK (1 << 2)

#define	XLHP_HAS_CONFLICT_HORIZON (1 << 3)

#define	XLHP_HAS_FREEZE_PLANS (1 << 4)

#define	XLHP_HAS_REDIRECTIONS (1 << 5)

#define	XLHP_HAS_DEAD_ITEMS (1 << 6)

#define	XLHP_HAS_NOW_UNUSED_ITEMS (1 << 7)

#define	XLHP_VM_ALL_VISIBLE (1 << 8)

#define	XLHP_VM_ALL_FROZEN (1 << 9)

#define	XLH_FREEZE_XVAC 0x02

#define	XLH_INVALID_XVAC 0x04

#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(uint8))

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

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

#define	MinSizeOfHeapInplace (offsetof(xl_heap_inplace, nmsgs) + sizeof(int))

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

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

Typedefs
typedef struct xl_heap_delete	xl_heap_delete

typedef struct xl_heap_truncate	xl_heap_truncate

typedef struct xl_heap_header	xl_heap_header

typedef struct xl_heap_insert	xl_heap_insert

typedef struct xl_heap_multi_insert	xl_heap_multi_insert

typedef struct xl_multi_insert_tuple	xl_multi_insert_tuple

typedef struct xl_heap_update	xl_heap_update

typedef struct xl_heap_prune	xl_heap_prune

typedef struct xlhp_freeze_plan	xlhp_freeze_plan

typedef struct xlhp_freeze_plans	xlhp_freeze_plans

typedef struct xlhp_prune_items	xlhp_prune_items

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_visible	xl_heap_visible

typedef struct xl_heap_new_cid	xl_heap_new_cid

typedef struct xl_heap_rewrite_mapping	xl_heap_rewrite_mapping

Functions
void	HeapTupleHeaderAdvanceConflictHorizon (HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)

void	heap_redo (XLogReaderState *record)

void	heap_desc (StringInfo buf, XLogReaderState *record)

const char *	heap_identify (uint8 info)

void	heap_mask (char *pagedata, BlockNumber blkno)

void	heap2_redo (XLogReaderState *record)

void	heap2_desc (StringInfo buf, XLogReaderState *record)

const char *	heap2_identify (uint8 info)

void	heap_xlog_logical_rewrite (XLogReaderState *r)

XLogRecPtr	log_heap_visible (Relation rel, Buffer heap_buffer, Buffer vm_buffer, TransactionId snapshotConflictHorizon, uint8 vmflags)

void	heap_xlog_deserialize_prune_and_freeze (char cursor, uint16 flags, int nplans, xlhp_freeze_plan plans, OffsetNumber frz_offsets, int nredirected, OffsetNumber redirected, int ndead, OffsetNumber *nowdead, int nunused, OffsetNumber **nowunused)

Macro Definition Documentation

◆ MinSizeOfHeapInplace

#define MinSizeOfHeapInplace (offsetof(xl_heap_inplace, nmsgs) + sizeof(int))

Definition at line 444 of file heapam_xlog.h.

◆ SizeOfHeapConfirm

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

Definition at line 431 of file heapam_xlog.h.

◆ SizeOfHeapDelete

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

Definition at line 121 of file heapam_xlog.h.

◆ SizeOfHeapHeader

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

Definition at line 157 of file heapam_xlog.h.

◆ SizeOfHeapInsert

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

Definition at line 168 of file heapam_xlog.h.

◆ SizeOfHeapLock

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

Definition at line 412 of file heapam_xlog.h.

◆ SizeOfHeapLockUpdated

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

Definition at line 423 of file heapam_xlog.h.

◆ SizeOfHeapMultiInsert

#define SizeOfHeapMultiInsert offsetof(xl_heap_multi_insert, offsets)

Definition at line 188 of file heapam_xlog.h.

◆ SizeOfHeapNewCid

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

Definition at line 478 of file heapam_xlog.h.

◆ SizeOfHeapPrune

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

Definition at line 295 of file heapam_xlog.h.

◆ SizeOfHeapTruncate

#define SizeOfHeapTruncate (offsetof(xl_heap_truncate, relids))

Definition at line 142 of file heapam_xlog.h.

◆ SizeOfHeapUpdate

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

Definition at line 233 of file heapam_xlog.h.

◆ SizeOfHeapVisible

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

Definition at line 458 of file heapam_xlog.h.

◆ SizeOfMultiInsertTuple

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

Definition at line 199 of file heapam_xlog.h.

◆ XLH_DELETE_ALL_VISIBLE_CLEARED

#define XLH_DELETE_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 102 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD

#define XLH_DELETE_CONTAINS_OLD (XLH_DELETE_CONTAINS_OLD_TUPLE | XLH_DELETE_CONTAINS_OLD_KEY)

Definition at line 109 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD_KEY

#define XLH_DELETE_CONTAINS_OLD_KEY (1<<2)

Definition at line 104 of file heapam_xlog.h.

◆ XLH_DELETE_CONTAINS_OLD_TUPLE

#define XLH_DELETE_CONTAINS_OLD_TUPLE (1<<1)

Definition at line 103 of file heapam_xlog.h.

◆ XLH_DELETE_IS_PARTITION_MOVE

#define XLH_DELETE_IS_PARTITION_MOVE (1<<4)

Definition at line 106 of file heapam_xlog.h.

◆ XLH_DELETE_IS_SUPER

#define XLH_DELETE_IS_SUPER (1<<3)

Definition at line 105 of file heapam_xlog.h.

◆ XLH_FREEZE_XVAC

#define XLH_FREEZE_XVAC 0x02

Definition at line 347 of file heapam_xlog.h.

◆ XLH_INSERT_ALL_FROZEN_SET

#define XLH_INSERT_ALL_FROZEN_SET (1<<5)

Definition at line 79 of file heapam_xlog.h.

◆ XLH_INSERT_ALL_VISIBLE_CLEARED

#define XLH_INSERT_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 72 of file heapam_xlog.h.

◆ XLH_INSERT_CONTAINS_NEW_TUPLE

#define XLH_INSERT_CONTAINS_NEW_TUPLE (1<<3)

Definition at line 75 of file heapam_xlog.h.

◆ XLH_INSERT_IS_SPECULATIVE

#define XLH_INSERT_IS_SPECULATIVE (1<<2)

Definition at line 74 of file heapam_xlog.h.

◆ XLH_INSERT_LAST_IN_MULTI

#define XLH_INSERT_LAST_IN_MULTI (1<<1)

Definition at line 73 of file heapam_xlog.h.

◆ XLH_INSERT_ON_TOAST_RELATION

#define XLH_INSERT_ON_TOAST_RELATION (1<<4)

Definition at line 76 of file heapam_xlog.h.

◆ XLH_INVALID_XVAC

#define XLH_INVALID_XVAC 0x04

Definition at line 348 of file heapam_xlog.h.

◆ XLH_LOCK_ALL_FROZEN_CLEARED

#define XLH_LOCK_ALL_FROZEN_CLEARED 0x01

Definition at line 401 of file heapam_xlog.h.

◆ XLH_TRUNCATE_CASCADE

#define XLH_TRUNCATE_CASCADE (1<<0)

Definition at line 126 of file heapam_xlog.h.

◆ XLH_TRUNCATE_RESTART_SEQS

#define XLH_TRUNCATE_RESTART_SEQS (1<<1)

Definition at line 127 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_NEW_TUPLE

#define XLH_UPDATE_CONTAINS_NEW_TUPLE (1<<4)

Definition at line 90 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD

#define XLH_UPDATE_CONTAINS_OLD (XLH_UPDATE_CONTAINS_OLD_TUPLE | XLH_UPDATE_CONTAINS_OLD_KEY)

Definition at line 95 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD_KEY

#define XLH_UPDATE_CONTAINS_OLD_KEY (1<<3)

Definition at line 89 of file heapam_xlog.h.

◆ XLH_UPDATE_CONTAINS_OLD_TUPLE

#define XLH_UPDATE_CONTAINS_OLD_TUPLE (1<<2)

Definition at line 88 of file heapam_xlog.h.

◆ XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_NEW_ALL_VISIBLE_CLEARED (1<<1)

Definition at line 87 of file heapam_xlog.h.

◆ XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED

#define XLH_UPDATE_OLD_ALL_VISIBLE_CLEARED (1<<0)

Definition at line 85 of file heapam_xlog.h.

◆ XLH_UPDATE_PREFIX_FROM_OLD

#define XLH_UPDATE_PREFIX_FROM_OLD (1<<5)

Definition at line 91 of file heapam_xlog.h.

◆ XLH_UPDATE_SUFFIX_FROM_OLD

#define XLH_UPDATE_SUFFIX_FROM_OLD (1<<6)

Definition at line 92 of file heapam_xlog.h.

◆ XLHL_KEYS_UPDATED

#define XLHL_KEYS_UPDATED 0x10

Definition at line 398 of file heapam_xlog.h.

◆ XLHL_XMAX_EXCL_LOCK

#define XLHL_XMAX_EXCL_LOCK 0x04

Definition at line 396 of file heapam_xlog.h.

◆ XLHL_XMAX_IS_MULTI

#define XLHL_XMAX_IS_MULTI 0x01

Definition at line 394 of file heapam_xlog.h.

◆ XLHL_XMAX_KEYSHR_LOCK

#define XLHL_XMAX_KEYSHR_LOCK 0x08

Definition at line 397 of file heapam_xlog.h.

◆ XLHL_XMAX_LOCK_ONLY

#define XLHL_XMAX_LOCK_ONLY 0x02

Definition at line 395 of file heapam_xlog.h.

◆ XLHP_CLEANUP_LOCK

#define XLHP_CLEANUP_LOCK (1 << 2)

Definition at line 308 of file heapam_xlog.h.

◆ XLHP_HAS_CONFLICT_HORIZON

#define XLHP_HAS_CONFLICT_HORIZON (1 << 3)

Definition at line 316 of file heapam_xlog.h.

◆ XLHP_HAS_DEAD_ITEMS

#define XLHP_HAS_DEAD_ITEMS (1 << 6)

Definition at line 330 of file heapam_xlog.h.

◆ XLHP_HAS_FREEZE_PLANS

#define XLHP_HAS_FREEZE_PLANS (1 << 4)

Definition at line 322 of file heapam_xlog.h.

◆ XLHP_HAS_NOW_UNUSED_ITEMS

#define XLHP_HAS_NOW_UNUSED_ITEMS (1 << 7)

Definition at line 331 of file heapam_xlog.h.

◆ XLHP_HAS_REDIRECTIONS

#define XLHP_HAS_REDIRECTIONS (1 << 5)

Definition at line 329 of file heapam_xlog.h.

◆ XLHP_IS_CATALOG_REL

#define XLHP_IS_CATALOG_REL (1 << 1)

Definition at line 298 of file heapam_xlog.h.

◆ XLHP_VM_ALL_FROZEN

#define XLHP_VM_ALL_FROZEN (1 << 9)

Definition at line 340 of file heapam_xlog.h.

◆ XLHP_VM_ALL_VISIBLE

#define XLHP_VM_ALL_VISIBLE (1 << 8)

Definition at line 339 of file heapam_xlog.h.

◆ XLOG_HEAP2_LOCK_UPDATED

#define XLOG_HEAP2_LOCK_UPDATED 0x60

Definition at line 65 of file heapam_xlog.h.

◆ XLOG_HEAP2_MULTI_INSERT

#define XLOG_HEAP2_MULTI_INSERT 0x50

Definition at line 64 of file heapam_xlog.h.

◆ XLOG_HEAP2_NEW_CID

#define XLOG_HEAP2_NEW_CID 0x70

Definition at line 66 of file heapam_xlog.h.

◆ XLOG_HEAP2_PRUNE_ON_ACCESS

#define XLOG_HEAP2_PRUNE_ON_ACCESS 0x10

Definition at line 60 of file heapam_xlog.h.

◆ XLOG_HEAP2_PRUNE_VACUUM_CLEANUP

#define XLOG_HEAP2_PRUNE_VACUUM_CLEANUP 0x30

Definition at line 62 of file heapam_xlog.h.

◆ XLOG_HEAP2_PRUNE_VACUUM_SCAN

#define XLOG_HEAP2_PRUNE_VACUUM_SCAN 0x20

Definition at line 61 of file heapam_xlog.h.

◆ XLOG_HEAP2_REWRITE

#define XLOG_HEAP2_REWRITE 0x00

Definition at line 59 of file heapam_xlog.h.

◆ XLOG_HEAP2_VISIBLE

#define XLOG_HEAP2_VISIBLE 0x40

Definition at line 63 of file heapam_xlog.h.

◆ XLOG_HEAP_CONFIRM

#define XLOG_HEAP_CONFIRM 0x50

Definition at line 38 of file heapam_xlog.h.

◆ XLOG_HEAP_DELETE

#define XLOG_HEAP_DELETE 0x10

Definition at line 34 of file heapam_xlog.h.

◆ XLOG_HEAP_HOT_UPDATE

#define XLOG_HEAP_HOT_UPDATE 0x40

Definition at line 37 of file heapam_xlog.h.

◆ XLOG_HEAP_INIT_PAGE

#define XLOG_HEAP_INIT_PAGE 0x80

Definition at line 47 of file heapam_xlog.h.

◆ XLOG_HEAP_INPLACE

#define XLOG_HEAP_INPLACE 0x70

Definition at line 40 of file heapam_xlog.h.

◆ XLOG_HEAP_INSERT

#define XLOG_HEAP_INSERT 0x00

Definition at line 33 of file heapam_xlog.h.

◆ XLOG_HEAP_LOCK

#define XLOG_HEAP_LOCK 0x60

Definition at line 39 of file heapam_xlog.h.

◆ XLOG_HEAP_OPMASK

#define XLOG_HEAP_OPMASK 0x70

Definition at line 42 of file heapam_xlog.h.

◆ XLOG_HEAP_TRUNCATE

#define XLOG_HEAP_TRUNCATE 0x30

Definition at line 36 of file heapam_xlog.h.

◆ XLOG_HEAP_UPDATE

#define XLOG_HEAP_UPDATE 0x20

Definition at line 35 of file heapam_xlog.h.

Typedef Documentation

◆ xl_heap_confirm

typedef struct xl_heap_confirm xl_heap_confirm

◆ xl_heap_delete

typedef struct xl_heap_delete xl_heap_delete

◆ xl_heap_header

typedef struct xl_heap_header xl_heap_header

◆ xl_heap_inplace

typedef struct xl_heap_inplace xl_heap_inplace

◆ xl_heap_insert

typedef struct xl_heap_insert xl_heap_insert

◆ xl_heap_lock

typedef struct xl_heap_lock xl_heap_lock

◆ xl_heap_lock_updated

typedef struct xl_heap_lock_updated xl_heap_lock_updated

◆ xl_heap_multi_insert

typedef struct xl_heap_multi_insert xl_heap_multi_insert

◆ xl_heap_new_cid

typedef struct xl_heap_new_cid xl_heap_new_cid

◆ xl_heap_prune

typedef struct xl_heap_prune xl_heap_prune

◆ xl_heap_rewrite_mapping

typedef struct xl_heap_rewrite_mapping xl_heap_rewrite_mapping

◆ xl_heap_truncate

typedef struct xl_heap_truncate xl_heap_truncate

◆ xl_heap_update

typedef struct xl_heap_update xl_heap_update

◆ xl_heap_visible

typedef struct xl_heap_visible xl_heap_visible

◆ xl_multi_insert_tuple

typedef struct xl_multi_insert_tuple xl_multi_insert_tuple

◆ xlhp_freeze_plan

typedef struct xlhp_freeze_plan xlhp_freeze_plan

◆ xlhp_freeze_plans

typedef struct xlhp_freeze_plans xlhp_freeze_plans

◆ xlhp_prune_items

typedef struct xlhp_prune_items xlhp_prune_items

Function Documentation

◆ heap2_desc()

void heap2_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 265 of file heapdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    info &= XLOG_HEAP_OPMASK;
    if (info == XLOG_HEAP2_PRUNE_ON_ACCESS ||
        info == XLOG_HEAP2_PRUNE_VACUUM_SCAN ||
        info == XLOG_HEAP2_PRUNE_VACUUM_CLEANUP)
    {
        xl_heap_prune *xlrec = (xl_heap_prune *) rec;
 
        if (xlrec->flags & XLHP_HAS_CONFLICT_HORIZON)
        {
            TransactionId conflict_xid;
 
            memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
 
            appendStringInfo(buf, "snapshotConflictHorizon: %u",
                             conflict_xid);
        }
 
        appendStringInfo(buf, ", isCatalogRel: %c",
                         xlrec->flags & XLHP_IS_CATALOG_REL ? 'T' : 'F');
 
        if (xlrec->flags & XLHP_VM_ALL_VISIBLE)
        {
            uint8       vmflags = VISIBILITYMAP_ALL_VISIBLE;
 
            if (xlrec->flags & XLHP_VM_ALL_FROZEN)
                vmflags |= VISIBILITYMAP_ALL_FROZEN;
            appendStringInfo(buf, ", vm_flags: 0x%02X", vmflags);
        }
 
        if (XLogRecHasBlockData(record, 0))
        {
            Size        datalen;
            OffsetNumber *redirected;
            OffsetNumber *nowdead;
            OffsetNumber *nowunused;
            int         nredirected;
            int         nunused;
            int         ndead;
            int         nplans;
            xlhp_freeze_plan *plans;
            OffsetNumber *frz_offsets;
 
            char       *cursor = XLogRecGetBlockData(record, 0, &datalen);
 
            heap_xlog_deserialize_prune_and_freeze(cursor, xlrec->flags,
                                                   &nplans, &plans, &frz_offsets,
                                                   &nredirected, &redirected,
                                                   &ndead, &nowdead,
                                                   &nunused, &nowunused);
 
            appendStringInfo(buf, ", nplans: %u, nredirected: %u, ndead: %u, nunused: %u",
                             nplans, nredirected, ndead, nunused);
 
            if (nplans > 0)
            {
                appendStringInfoString(buf, ", plans:");
                array_desc(buf, plans, sizeof(xlhp_freeze_plan), nplans,
                           &plan_elem_desc, &frz_offsets);
            }
 
            if (nredirected > 0)
            {
                appendStringInfoString(buf, ", redirected:");
                array_desc(buf, redirected, sizeof(OffsetNumber) * 2,
                           nredirected, &redirect_elem_desc, NULL);
            }
 
            if (ndead > 0)
            {
                appendStringInfoString(buf, ", dead:");
                array_desc(buf, nowdead, sizeof(OffsetNumber), ndead,
                           &offset_elem_desc, NULL);
            }
 
            if (nunused > 0)
            {
                appendStringInfoString(buf, ", unused:");
                array_desc(buf, nowunused, sizeof(OffsetNumber), nunused,
                           &offset_elem_desc, NULL);
            }
        }
    }
    else if (info == XLOG_HEAP2_VISIBLE)
    {
        xl_heap_visible *xlrec = (xl_heap_visible *) rec;
 
        appendStringInfo(buf, "snapshotConflictHorizon: %u, flags: 0x%02X",
                         xlrec->snapshotConflictHorizon, xlrec->flags);
    }
    else if (info == XLOG_HEAP2_MULTI_INSERT)
    {
        xl_heap_multi_insert *xlrec = (xl_heap_multi_insert *) rec;
        bool        isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
 
        appendStringInfo(buf, "ntuples: %d, flags: 0x%02X", xlrec->ntuples,
                         xlrec->flags);
 
        if (xlrec->flags & XLH_INSERT_ALL_FROZEN_SET)
            appendStringInfo(buf, ", vm_flags: 0x%02X",
                             VISIBILITYMAP_ALL_VISIBLE |
                             VISIBILITYMAP_ALL_FROZEN);
 
        if (XLogRecHasBlockData(record, 0) && !isinit)
        {
            appendStringInfoString(buf, ", offsets:");
            array_desc(buf, xlrec->offsets, sizeof(OffsetNumber),
                       xlrec->ntuples, &offset_elem_desc, NULL);
        }
    }
    else if (info == XLOG_HEAP2_LOCK_UPDATED)
    {
        xl_heap_lock_updated *xlrec = (xl_heap_lock_updated *) rec;
 
        appendStringInfo(buf, "xmax: %u, off: %u, ",
                         xlrec->xmax, xlrec->offnum);
        infobits_desc(buf, xlrec->infobits_set, "infobits");
        appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
    }
    else if (info == XLOG_HEAP2_NEW_CID)
    {
        xl_heap_new_cid *xlrec = (xl_heap_new_cid *) rec;
 
        appendStringInfo(buf, "rel: %u/%u/%u, tid: %u/%u",
                         xlrec->target_locator.spcOid,
                         xlrec->target_locator.dbOid,
                         xlrec->target_locator.relNumber,
                         ItemPointerGetBlockNumber(&(xlrec->target_tid)),
                         ItemPointerGetOffsetNumber(&(xlrec->target_tid)));
        appendStringInfo(buf, ", cmin: %u, cmax: %u, combo: %u",
                         xlrec->cmin, xlrec->cmax, xlrec->combocid);
    }
}

References appendStringInfo(), appendStringInfoString(), array_desc(), buf, xl_heap_new_cid::cmax, xl_heap_new_cid::cmin, xl_heap_new_cid::combocid, RelFileLocator::dbOid, xl_heap_multi_insert::flags, xl_heap_prune::flags, xl_heap_lock_updated::flags, xl_heap_visible::flags, heap_xlog_deserialize_prune_and_freeze(), infobits_desc(), xl_heap_lock_updated::infobits_set, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), xl_heap_multi_insert::ntuples, xl_heap_lock_updated::offnum, offset_elem_desc(), xl_heap_multi_insert::offsets, plan_elem_desc(), redirect_elem_desc(), RelFileLocator::relNumber, SizeOfHeapPrune, xl_heap_visible::snapshotConflictHorizon, RelFileLocator::spcOid, xl_heap_new_cid::target_locator, xl_heap_new_cid::target_tid, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, XLH_INSERT_ALL_FROZEN_SET, XLHP_HAS_CONFLICT_HORIZON, XLHP_IS_CATALOG_REL, XLHP_VM_ALL_FROZEN, XLHP_VM_ALL_VISIBLE, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLOG_HEAP2_VISIBLE, XLOG_HEAP_INIT_PAGE, XLOG_HEAP_OPMASK, XLogRecGetBlockData(), XLogRecGetData, XLogRecGetInfo, XLogRecHasBlockData, and xl_heap_lock_updated::xmax.

◆ heap2_identify()

const char * heap2_identify ( uint8 info )

Definition at line 449 of file heapdesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_HEAP2_PRUNE_ON_ACCESS:
            id = "PRUNE_ON_ACCESS";
            break;
        case XLOG_HEAP2_PRUNE_VACUUM_SCAN:
            id = "PRUNE_VACUUM_SCAN";
            break;
        case XLOG_HEAP2_PRUNE_VACUUM_CLEANUP:
            id = "PRUNE_VACUUM_CLEANUP";
            break;
        case XLOG_HEAP2_VISIBLE:
            id = "VISIBLE";
            break;
        case XLOG_HEAP2_MULTI_INSERT:
            id = "MULTI_INSERT";
            break;
        case XLOG_HEAP2_MULTI_INSERT | XLOG_HEAP_INIT_PAGE:
            id = "MULTI_INSERT+INIT";
            break;
        case XLOG_HEAP2_LOCK_UPDATED:
            id = "LOCK_UPDATED";
            break;
        case XLOG_HEAP2_NEW_CID:
            id = "NEW_CID";
            break;
        case XLOG_HEAP2_REWRITE:
            id = "REWRITE";
            break;
    }
 
    return id;
}

References XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VISIBLE, XLOG_HEAP_INIT_PAGE, and XLR_INFO_MASK.

◆ heap2_redo()

void heap2_redo ( XLogReaderState * record )

Definition at line 1346 of file heapam_xlog.c.

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

References elog, heap_xlog_lock_updated(), heap_xlog_logical_rewrite(), heap_xlog_multi_insert(), heap_xlog_prune_freeze(), heap_xlog_visible(), PANIC, XLOG_HEAP2_LOCK_UPDATED, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP2_NEW_CID, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLOG_HEAP2_REWRITE, XLOG_HEAP2_VISIBLE, XLOG_HEAP_OPMASK, and XLogRecGetInfo.

◆ heap_desc()

void heap_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 185 of file heapdesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    info &= XLOG_HEAP_OPMASK;
    if (info == XLOG_HEAP_INSERT)
    {
        xl_heap_insert *xlrec = (xl_heap_insert *) rec;
 
        appendStringInfo(buf, "off: %u, flags: 0x%02X",
                         xlrec->offnum,
                         xlrec->flags);
    }
    else if (info == XLOG_HEAP_DELETE)
    {
        xl_heap_delete *xlrec = (xl_heap_delete *) rec;
 
        appendStringInfo(buf, "xmax: %u, off: %u, ",
                         xlrec->xmax, xlrec->offnum);
        infobits_desc(buf, xlrec->infobits_set, "infobits");
        appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
    }
    else if (info == XLOG_HEAP_UPDATE)
    {
        xl_heap_update *xlrec = (xl_heap_update *) rec;
 
        appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
                         xlrec->old_xmax, xlrec->old_offnum);
        infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
        appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
                         xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
    }
    else if (info == XLOG_HEAP_HOT_UPDATE)
    {
        xl_heap_update *xlrec = (xl_heap_update *) rec;
 
        appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
                         xlrec->old_xmax, xlrec->old_offnum);
        infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
        appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
                         xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
    }
    else if (info == XLOG_HEAP_TRUNCATE)
    {
        xl_heap_truncate *xlrec = (xl_heap_truncate *) rec;
 
        truncate_flags_desc(buf, xlrec->flags);
        appendStringInfo(buf, ", nrelids: %u", xlrec->nrelids);
        appendStringInfoString(buf, ", relids:");
        array_desc(buf, xlrec->relids, sizeof(Oid), xlrec->nrelids,
                   &oid_elem_desc, NULL);
    }
    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, "xmax: %u, off: %u, ",
                         xlrec->xmax, xlrec->offnum);
        infobits_desc(buf, xlrec->infobits_set, "infobits");
        appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
    }
    else if (info == XLOG_HEAP_INPLACE)
    {
        xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
 
        appendStringInfo(buf, "off: %u", xlrec->offnum);
        standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs,
                                   xlrec->dbId, xlrec->tsId,
                                   xlrec->relcacheInitFileInval);
    }
}

References appendStringInfo(), appendStringInfoString(), array_desc(), buf, xl_heap_inplace::dbId, xl_heap_delete::flags, xl_heap_truncate::flags, xl_heap_insert::flags, xl_heap_update::flags, xl_heap_lock::flags, infobits_desc(), xl_heap_delete::infobits_set, xl_heap_lock::infobits_set, xl_heap_inplace::msgs, xl_heap_update::new_offnum, xl_heap_update::new_xmax, xl_heap_inplace::nmsgs, xl_heap_truncate::nrelids, xl_heap_delete::offnum, xl_heap_insert::offnum, xl_heap_lock::offnum, xl_heap_confirm::offnum, xl_heap_inplace::offnum, oid_elem_desc(), xl_heap_update::old_infobits_set, xl_heap_update::old_offnum, xl_heap_update::old_xmax, xl_heap_inplace::relcacheInitFileInval, xl_heap_truncate::relids, standby_desc_invalidations(), truncate_flags_desc(), xl_heap_inplace::tsId, 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, xl_heap_delete::xmax, and xl_heap_lock::xmax.

◆ heap_identify()

const char * heap_identify ( uint8 info )

Definition at line 404 of file heapdesc.c.

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

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

◆ heap_mask()

void heap_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 1385 of file heapam_xlog.c.

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

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

◆ heap_redo()

void heap_redo ( XLogReaderState * record )

Definition at line 1300 of file heapam_xlog.c.

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

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

◆ heap_xlog_deserialize_prune_and_freeze()

void heap_xlog_deserialize_prune_and_freeze	(	char *	cursor,
		uint16	flags,
		int *	nplans,
		xlhp_freeze_plan **	plans,
		OffsetNumber **	frz_offsets,
		int *	nredirected,
		OffsetNumber **	redirected,
		int *	ndead,
		OffsetNumber **	nowdead,
		int *	nunused,
		OffsetNumber **	nowunused
	)

Definition at line 106 of file heapdesc.c.

{
    if (flags & XLHP_HAS_FREEZE_PLANS)
    {
        xlhp_freeze_plans *freeze_plans = (xlhp_freeze_plans *) cursor;
 
        *nplans = freeze_plans->nplans;
        Assert(*nplans > 0);
        *plans = freeze_plans->plans;
 
        cursor += offsetof(xlhp_freeze_plans, plans);
        cursor += sizeof(xlhp_freeze_plan) * *nplans;
    }
    else
    {
        *nplans = 0;
        *plans = NULL;
    }
 
    if (flags & XLHP_HAS_REDIRECTIONS)
    {
        xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 
        *nredirected = subrecord->ntargets;
        Assert(*nredirected > 0);
        *redirected = &subrecord->data[0];
 
        cursor += offsetof(xlhp_prune_items, data);
        cursor += sizeof(OffsetNumber[2]) * *nredirected;
    }
    else
    {
        *nredirected = 0;
        *redirected = NULL;
    }
 
    if (flags & XLHP_HAS_DEAD_ITEMS)
    {
        xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 
        *ndead = subrecord->ntargets;
        Assert(*ndead > 0);
        *nowdead = subrecord->data;
 
        cursor += offsetof(xlhp_prune_items, data);
        cursor += sizeof(OffsetNumber) * *ndead;
    }
    else
    {
        *ndead = 0;
        *nowdead = NULL;
    }
 
    if (flags & XLHP_HAS_NOW_UNUSED_ITEMS)
    {
        xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
 
        *nunused = subrecord->ntargets;
        Assert(*nunused > 0);
        *nowunused = subrecord->data;
 
        cursor += offsetof(xlhp_prune_items, data);
        cursor += sizeof(OffsetNumber) * *nunused;
    }
    else
    {
        *nunused = 0;
        *nowunused = NULL;
    }
 
    *frz_offsets = (OffsetNumber *) cursor;
}

References Assert(), xlhp_prune_items::data, data, xlhp_freeze_plans::nplans, xlhp_prune_items::ntargets, xlhp_freeze_plans::plans, XLHP_HAS_DEAD_ITEMS, XLHP_HAS_FREEZE_PLANS, XLHP_HAS_NOW_UNUSED_ITEMS, and XLHP_HAS_REDIRECTIONS.

Referenced by heap2_desc(), and heap_xlog_prune_freeze().

◆ heap_xlog_logical_rewrite()

void heap_xlog_logical_rewrite ( XLogReaderState * r )

Definition at line 1072 of file rewriteheap.c.

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

References CloseTransientFile(), data, data_sync_elevel(), ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), len, LOGICAL_REWRITE_FORMAT, LSN_FORMAT_ARGS, xl_heap_rewrite_mapping::mapped_db, xl_heap_rewrite_mapping::mapped_rel, xl_heap_rewrite_mapping::mapped_xid, MAXPGPATH, xl_heap_rewrite_mapping::num_mappings, xl_heap_rewrite_mapping::offset, OpenTransientFile(), PG_BINARY, pg_fsync(), PG_LOGICAL_MAPPINGS_DIR, pg_pwrite, pgstat_report_wait_end(), pgstat_report_wait_start(), snprintf, xl_heap_rewrite_mapping::start_lsn, XLogRecGetData, and XLogRecGetXid.

Referenced by heap2_redo().

◆ HeapTupleHeaderAdvanceConflictHorizon()

void HeapTupleHeaderAdvanceConflictHorizon	(	HeapTupleHeader	tuple,
		TransactionId *	snapshotConflictHorizon
	)

Definition at line 7999 of file heapam.c.

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

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

Referenced by heap_index_delete_tuples(), heap_prune_chain(), and prune_freeze_plan().

◆ log_heap_visible()

XLogRecPtr log_heap_visible	(	Relation	rel,
		Buffer	heap_buffer,
		Buffer	vm_buffer,
		TransactionId	snapshotConflictHorizon,
		uint8	vmflags
	)

Definition at line 8830 of file heapam.c.

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

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

Referenced by visibilitymap_set().

Data Structures

Macros

Typedefs

Functions