heapam_xlog.h File Reference

#include "access/htup.h"
#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/buf.h"
#include "storage/bufpage.h"
#include "storage/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(uint8))
#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	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, uint8 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 436 of file heapam_xlog.h.

SizeOfHeapConfirm

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

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

SizeOfHeapLockUpdated

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

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

SizeOfHeapPrune

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

Definition at line 296 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 450 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 339 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 340 of file heapam_xlog.h.

XLH_LOCK_ALL_FROZEN_CLEARED

#define XLH_LOCK_ALL_FROZEN_CLEARED   0x01

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

XLHL_XMAX_EXCL_LOCK

#define XLHL_XMAX_EXCL_LOCK   0x04

Definition at line 388 of file heapam_xlog.h.

XLHL_XMAX_IS_MULTI

#define XLHL_XMAX_IS_MULTI   0x01

Definition at line 386 of file heapam_xlog.h.

XLHL_XMAX_KEYSHR_LOCK

#define XLHL_XMAX_KEYSHR_LOCK   0x08

Definition at line 389 of file heapam_xlog.h.

XLHL_XMAX_LOCK_ONLY

#define XLHL_XMAX_LOCK_ONLY   0x02

Definition at line 387 of file heapam_xlog.h.

XLHP_CLEANUP_LOCK

#define XLHP_CLEANUP_LOCK   (1 << 2)

Definition at line 309 of file heapam_xlog.h.

XLHP_HAS_CONFLICT_HORIZON

#define XLHP_HAS_CONFLICT_HORIZON   (1 << 3)

Definition at line 317 of file heapam_xlog.h.

XLHP_HAS_DEAD_ITEMS

#define XLHP_HAS_DEAD_ITEMS   (1 << 6)

Definition at line 331 of file heapam_xlog.h.

XLHP_HAS_FREEZE_PLANS

#define XLHP_HAS_FREEZE_PLANS   (1 << 4)

Definition at line 323 of file heapam_xlog.h.

XLHP_HAS_NOW_UNUSED_ITEMS

#define XLHP_HAS_NOW_UNUSED_ITEMS   (1 << 7)

Definition at line 332 of file heapam_xlog.h.

XLHP_HAS_REDIRECTIONS

#define XLHP_HAS_REDIRECTIONS   (1 << 5)

Definition at line 330 of file heapam_xlog.h.

XLHP_IS_CATALOG_REL

#define XLHP_IS_CATALOG_REL   (1 << 1)

Definition at line 299 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 264 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 (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 (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, XLHP_HAS_CONFLICT_HORIZON, XLHP_IS_CATALOG_REL, 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, XLR_INFO_MASK, and xl_heap_lock_updated::xmax.

heap2_identify()

const char* heap2_identify

(

uint8

info

)

Definition at line 434 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 1228 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, XLogRecGetInfo, and XLR_INFO_MASK.

heap_desc()

void heap_desc	(	StringInfo	buf,
		XLogReaderState *	record
	)

Definition at line 184 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, XLR_INFO_MASK, xl_heap_delete::xmax, and xl_heap_lock::xmax.

heap_identify()

const char* heap_identify

(

uint8

info

)

Definition at line 389 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 1267 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 1182 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, XLogRecGetInfo, and XLR_INFO_MASK.

heap_xlog_deserialize_prune_and_freeze()

void heap_xlog_deserialize_prune_and_freeze	(	char *	cursor,
		uint8	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 105 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 1073 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(), ftruncate, len, LOGICAL_REWRITE_FORMAT, LSN_FORMAT_ARGS, xl_heap_rewrite_mapping::mapped_db, xl_heap_rewrite_mapping::mapped_rel, xl_heap_rewrite_mapping::mapped_xid, MAXPGPATH, xl_heap_rewrite_mapping::num_mappings, xl_heap_rewrite_mapping::offset, OpenTransientFile(), PG_BINARY, pg_fsync(), PG_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 7811 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_page_prune_and_freeze(), and heap_prune_chain().

log_heap_visible()

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

Definition at line 8642 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((char *) &xlrec, SizeOfHeapVisible);
 
    XLogRegisterBuffer(0, vm_buffer, 0);
 
    flags = REGBUF_STANDARD;
    if (!XLogHintBitIsNeeded())
        flags |= REGBUF_NO_IMAGE;
    XLogRegisterBuffer(1, heap_buffer, flags);
 
    recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_VISIBLE);
 
    return recptr;
}

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

Referenced by visibilitymap_set().