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

{
    TransactionId xmax;         /* xmax of the deleted tuple */
    OffsetNumber offnum;        /* deleted tuple's offset */
    uint8       infobits_set;   /* infomask bits */
    uint8       flags;
} xl_heap_delete;
 
#define SizeOfHeapDelete    (offsetof(xl_heap_delete, flags) + sizeof(uint8))
 
/*
 * xl_heap_truncate flag values, 8 bits are available.
 */
#define XLH_TRUNCATE_CASCADE                    (1<<0)
#define XLH_TRUNCATE_RESTART_SEQS               (1<<1)
 
/*
 * For truncate we list all truncated relids in an array, followed by all
 * sequence relids that need to be restarted, if any.
 * All rels are always within the same database, so we just list dbid once.
 */
typedef struct xl_heap_truncate
{
    Oid         dbId;
    uint32      nrelids;
    uint8       flags;
    Oid         relids[FLEXIBLE_ARRAY_MEMBER];
} xl_heap_truncate;
 
#define SizeOfHeapTruncate  (offsetof(xl_heap_truncate, relids))
 
/*
 * We don't store the whole fixed part (HeapTupleHeaderData) of an inserted
 * or updated tuple in WAL; we can save a few bytes by reconstructing the
 * fields that are available elsewhere in the WAL record, or perhaps just
 * plain needn't be reconstructed.  These are the fields we must store.
 */
typedef struct xl_heap_header
{
    uint16      t_infomask2;
    uint16      t_infomask;
    uint8       t_hoff;
} xl_heap_header;
 
#define SizeOfHeapHeader    (offsetof(xl_heap_header, t_hoff) + sizeof(uint8))
 
/* This is what we need to know about insert */
typedef struct xl_heap_insert
{
    OffsetNumber offnum;        /* inserted tuple's offset */
    uint8       flags;
 
    /* xl_heap_header & TUPLE DATA in backup block 0 */
} xl_heap_insert;
 
#define SizeOfHeapInsert    (offsetof(xl_heap_insert, flags) + sizeof(uint8))
 
/*
 * This is what we need to know about a multi-insert.
 *
 * The main data of the record consists of this xl_heap_multi_insert header.
 * 'offsets' array is omitted if the whole page is reinitialized
 * (XLOG_HEAP_INIT_PAGE).
 *
 * In block 0's data portion, there is an xl_multi_insert_tuple struct,
 * followed by the tuple data for each tuple. There is padding to align
 * each xl_multi_insert_tuple struct.
 */
typedef struct xl_heap_multi_insert
{
    uint8       flags;
    uint16      ntuples;
    OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER];
} xl_heap_multi_insert;
 
#define SizeOfHeapMultiInsert   offsetof(xl_heap_multi_insert, offsets)
 
typedef struct xl_multi_insert_tuple
{
    uint16      datalen;        /* size of tuple data that follows */
    uint16      t_infomask2;
    uint16      t_infomask;
    uint8       t_hoff;
    /* TUPLE DATA FOLLOWS AT END OF STRUCT */
} xl_multi_insert_tuple;
 
#define SizeOfMultiInsertTuple  (offsetof(xl_multi_insert_tuple, t_hoff) + sizeof(uint8))
 
/*
 * This is what we need to know about update|hot_update
 *
 * Backup blk 0: new page
 *
 * If XLH_UPDATE_PREFIX_FROM_OLD or XLH_UPDATE_SUFFIX_FROM_OLD flags are set,
 * the prefix and/or suffix come first, as one or two uint16s.
 *
 * After that, xl_heap_header and new tuple data follow.  The new tuple
 * data doesn't include the prefix and suffix, which are copied from the
 * old tuple on replay.
 *
 * If XLH_UPDATE_CONTAINS_NEW_TUPLE flag is given, the tuple data is
 * included even if a full-page image was taken.
 *
 * Backup blk 1: old page, if different. (no data, just a reference to the blk)
 */
typedef struct xl_heap_update
{
    TransactionId old_xmax;     /* xmax of the old tuple */
    OffsetNumber old_offnum;    /* old tuple's offset */
    uint8       old_infobits_set;   /* infomask bits to set on old tuple */
    uint8       flags;
    TransactionId new_xmax;     /* xmax of the new tuple */
    OffsetNumber new_offnum;    /* new tuple's offset */
 
    /*
     * If XLH_UPDATE_CONTAINS_OLD_TUPLE or XLH_UPDATE_CONTAINS_OLD_KEY flags
     * are set, xl_heap_header and tuple data for the old tuple follow.
     */
} xl_heap_update;
 
#define SizeOfHeapUpdate    (offsetof(xl_heap_update, new_offnum) + sizeof(OffsetNumber))
 
/*
 * These structures and flags encode VACUUM pruning and freezing and on-access
 * pruning page modifications.
 *
 * xl_heap_prune is the main record.  The XLHP_HAS_* flags indicate which
 * "sub-records" are included and the other XLHP_* flags provide additional
 * information about the conditions for replay.
 *
 * The data for block reference 0 contains "sub-records" depending on which of
 * the XLHP_HAS_* flags are set.  See xlhp_* struct definitions below.  The
 * sub-records appear in the same order as the XLHP_* flags.  An example
 * record with every sub-record included:
 *
 *-----------------------------------------------------------------------------
 * Main data section:
 *
 *  xl_heap_prune
 *      uint16              flags
 *  TransactionId           snapshot_conflict_horizon
 *
 * Block 0 data section:
 *
 *  xlhp_freeze_plans
 *      uint16              nplans
 *      [2 bytes of padding]
 *      xlhp_freeze_plan    plans[nplans]
 *
 *  xlhp_prune_items
 *      uint16              nredirected
 *      OffsetNumber        redirected[2 * nredirected]
 *
 *  xlhp_prune_items
 *      uint16              ndead
 *      OffsetNumber        nowdead[ndead]
 *
 *  xlhp_prune_items
 *      uint16              nunused
 *      OffsetNumber        nowunused[nunused]
 *
 *  OffsetNumber            frz_offsets[sum([plan.ntuples for plan in plans])]
 *-----------------------------------------------------------------------------
 *
 * NOTE: because the record data is assembled from many optional parts, we
 * have to pay close attention to alignment.  In the main data section,
 * 'snapshot_conflict_horizon' is stored unaligned after 'flags', to save
 * space.  In the block 0 data section, the freeze plans appear first, because
 * they contain TransactionId fields that require 4-byte alignment.  All the
 * other fields require only 2-byte alignment.  This is also the reason that
 * 'frz_offsets' is stored separately from the xlhp_freeze_plan structs.
 */
typedef struct xl_heap_prune
{
    uint16      flags;
 
    /*
     * If XLHP_HAS_CONFLICT_HORIZON is set, the conflict horizon XID follows,
     * unaligned
     */
} xl_heap_prune;
 
#define SizeOfHeapPrune (offsetof(xl_heap_prune, flags) + sizeof(uint16))
 
/* to handle recovery conflict during logical decoding on standby */
#define     XLHP_IS_CATALOG_REL         (1 << 1)
 
/*
 * Does replaying the record require a cleanup-lock?
 *
 * Pruning, in VACUUM's first pass or when otherwise accessing a page,
 * requires a cleanup lock.  For freezing, and VACUUM's second pass which
 * marks LP_DEAD line pointers as unused without moving any tuple data, an
 * ordinary exclusive lock is sufficient.
 */
#define     XLHP_CLEANUP_LOCK          (1 << 2)
 
/*
 * If we remove or freeze any entries that contain xids, we need to include a
 * snapshot conflict horizon.  It's used in Hot Standby mode to ensure that
 * there are no queries running for which the removed tuples are still
 * visible, or which still consider the frozen XIDs as running.
 */
#define     XLHP_HAS_CONFLICT_HORIZON   (1 << 3)
 
/*
 * Indicates that an xlhp_freeze_plans sub-record and one or more
 * xlhp_freeze_plan sub-records are present.
 */
#define     XLHP_HAS_FREEZE_PLANS       (1 << 4)
 
/*
 * XLHP_HAS_REDIRECTIONS, XLHP_HAS_DEAD_ITEMS, and XLHP_HAS_NOW_UNUSED_ITEMS
 * indicate that xlhp_prune_items sub-records with redirected, dead, and
 * unused item offsets are present.
 */
#define     XLHP_HAS_REDIRECTIONS       (1 << 5)
#define     XLHP_HAS_DEAD_ITEMS         (1 << 6)
#define     XLHP_HAS_NOW_UNUSED_ITEMS   (1 << 7)
 
/*
 * The xl_heap_prune record's flags may also contain which VM bits to set.
 * xl_heap_prune should always use the XLHP_VM_ALL_VISIBLE and
 * XLHP_VM_ALL_FROZEN flags and translate them to their visibilitymapdefs.h
 * equivalents, VISIBILITYMAP_ALL_VISIBLE and VISIBILITYMAP_ALL_FROZEN.
 */
#define     XLHP_VM_ALL_VISIBLE         (1 << 8)
#define     XLHP_VM_ALL_FROZEN          (1 << 9)
 
/*
 * xlhp_freeze_plan describes how to freeze a group of one or more heap tuples
 * (appears in xl_heap_prune's xlhp_freeze_plans sub-record)
 */
/* 0x01 was XLH_FREEZE_XMIN */
#define     XLH_FREEZE_XVAC     0x02
#define     XLH_INVALID_XVAC    0x04
 
typedef struct xlhp_freeze_plan
{
    TransactionId xmax;
    uint16      t_infomask2;
    uint16      t_infomask;
    uint8       frzflags;
 
    /* Length of individual page offset numbers array for this plan */
    uint16      ntuples;
} xlhp_freeze_plan;
 
/*
 * This is what we need to know about a block being frozen during vacuum
 *
 * The backup block's data contains an array of xlhp_freeze_plan structs (with
 * nplans elements).  The individual item offsets are located in an array at
 * the end of the entire record with nplans * (each plan's ntuples) members
 * Those offsets are in the same order as the plans.  The REDO routine uses
 * the offsets to freeze the corresponding heap tuples.
 *
 * (As of PostgreSQL 17, XLOG_HEAP2_PRUNE_VACUUM_SCAN records replace the
 * separate XLOG_HEAP2_FREEZE_PAGE records.)
 */
typedef struct xlhp_freeze_plans
{
    uint16      nplans;
    xlhp_freeze_plan plans[FLEXIBLE_ARRAY_MEMBER];
} xlhp_freeze_plans;
 
/*
 * Generic sub-record type contained in block reference 0 of an xl_heap_prune
 * record and used for redirect, dead, and unused items if any of
 * XLHP_HAS_REDIRECTIONS/XLHP_HAS_DEAD_ITEMS/XLHP_HAS_NOW_UNUSED_ITEMS are
 * set.  Note that in the XLHP_HAS_REDIRECTIONS variant, there are actually 2
 * * length number of OffsetNumbers in the data.
 */
typedef struct xlhp_prune_items
{
    uint16      ntargets;
    OffsetNumber data[FLEXIBLE_ARRAY_MEMBER];
} xlhp_prune_items;
 
 
/* flags for infobits_set */
#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
 
/* flag bits for xl_heap_lock / xl_heap_lock_updated's flag field */
#define XLH_LOCK_ALL_FROZEN_CLEARED     0x01
 
/* This is what we need to know about lock */
typedef struct xl_heap_lock
{
    TransactionId xmax;         /* might be a MultiXactId */
    OffsetNumber offnum;        /* locked tuple's offset on page */
    uint8       infobits_set;   /* infomask and infomask2 bits to set */
    uint8       flags;          /* XLH_LOCK_* flag bits */
} xl_heap_lock;
 
#define SizeOfHeapLock  (offsetof(xl_heap_lock, flags) + sizeof(uint8))
 
/* This is what we need to know about locking an updated version of a row */
typedef struct xl_heap_lock_updated
{
    TransactionId xmax;
    OffsetNumber offnum;
    uint8       infobits_set;
    uint8       flags;
} xl_heap_lock_updated;
 
#define SizeOfHeapLockUpdated   (offsetof(xl_heap_lock_updated, flags) + sizeof(uint8))
 
/* This is what we need to know about confirmation of speculative insertion */
typedef struct xl_heap_confirm
{
    OffsetNumber offnum;        /* confirmed tuple's offset on page */
} xl_heap_confirm;
 
#define SizeOfHeapConfirm   (offsetof(xl_heap_confirm, offnum) + sizeof(OffsetNumber))
 
/* This is what we need to know about in-place update */
typedef struct xl_heap_inplace
{
    OffsetNumber offnum;        /* updated tuple's offset on page */
    Oid         dbId;           /* MyDatabaseId */
    Oid         tsId;           /* MyDatabaseTableSpace */
    bool        relcacheInitFileInval;  /* invalidate relcache init files */
    int         nmsgs;          /* number of shared inval msgs */
    SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER];
} xl_heap_inplace;
 
#define MinSizeOfHeapInplace    (offsetof(xl_heap_inplace, nmsgs) + sizeof(int))
 
/*
 * This is what we need to know about setting a visibility map bit
 *
 * Backup blk 0: visibility map buffer
 * Backup blk 1: heap buffer
 */
typedef struct xl_heap_visible
{
    TransactionId snapshotConflictHorizon;
    uint8       flags;
} xl_heap_visible;
 
#define SizeOfHeapVisible (offsetof(xl_heap_visible, flags) + sizeof(uint8))
 
typedef struct xl_heap_new_cid
{
    /*
     * store toplevel xid so we don't have to merge cids from different
     * transactions
     */
    TransactionId top_xid;
    CommandId   cmin;
    CommandId   cmax;
    CommandId   combocid;       /* just for debugging */
 
    /*
     * Store the relfilelocator/ctid pair to facilitate lookups.
     */
    RelFileLocator target_locator;
    ItemPointerData target_tid;
} xl_heap_new_cid;
 
#define SizeOfHeapNewCid (offsetof(xl_heap_new_cid, target_tid) + sizeof(ItemPointerData))
 
/* logical rewrite xlog record header */
typedef struct xl_heap_rewrite_mapping
{
    TransactionId mapped_xid;   /* xid that might need to see the row */
    Oid         mapped_db;      /* DbOid or InvalidOid for shared rels */
    Oid         mapped_rel;     /* Oid of the mapped relation */
    off_t       offset;         /* How far have we written so far */
    uint32      num_mappings;   /* Number of in-memory mappings */
    XLogRecPtr  start_lsn;      /* Insert LSN at begin of rewrite */
} xl_heap_rewrite_mapping;
 
extern void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple,
                                                  TransactionId *snapshotConflictHorizon);
 
extern void heap_redo(XLogReaderState *record);
extern void heap_desc(StringInfo buf, XLogReaderState *record);
extern const char *heap_identify(uint8 info);
extern void heap_mask(char *pagedata, BlockNumber blkno);
extern void heap2_redo(XLogReaderState *record);
extern void heap2_desc(StringInfo buf, XLogReaderState *record);
extern const char *heap2_identify(uint8 info);
extern void heap_xlog_logical_rewrite(XLogReaderState *r);
 
extern XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer,
                                   Buffer vm_buffer,
                                   TransactionId snapshotConflictHorizon,
                                   uint8 vmflags);
 
/* in heapdesc.c, so it can be shared between frontend/backend code */
extern 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);
 
#endif                          /* 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  )

extern

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, fb(), heap_xlog_deserialize_prune_and_freeze(), infobits_desc(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), offset_elem_desc(), plan_elem_desc(), redirect_elem_desc(), SizeOfHeapPrune, 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, and XLogRecHasBlockData.

heap2_identify()

const char * heap2_identify ( uint8  info )

extern

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 fb(), 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 )

extern

Definition at line 1352 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, fb(), 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  )

extern

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, fb(), infobits_desc(), oid_elem_desc(), standby_desc_invalidations(), truncate_flags_desc(), 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, and XLogRecGetInfo.

heap_identify()

const char * heap_identify ( uint8  info )

extern

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 fb(), 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  )

extern

Definition at line 1391 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 fb(), HEAP_XACT_MASK, 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 )

extern

Definition at line 1306 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, fb(), 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  )

extern

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, data, fb(), 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 )

extern

Definition at line 1075 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, fb(), fd(), len, LOGICAL_REWRITE_FORMAT, LSN_FORMAT_ARGS, MAXPGPATH, OpenTransientFile(), PG_BINARY, pg_fsync(), PG_LOGICAL_MAPPINGS_DIR, pg_pwrite, pgstat_report_wait_end(), pgstat_report_wait_start(), snprintf, XLogRecGetData, and XLogRecGetXid.

Referenced by heap2_redo().

HeapTupleHeaderAdvanceConflictHorizon()

void HeapTupleHeaderAdvanceConflictHorizon ( HeapTupleHeader  tuple, TransactionId *  snapshotConflictHorizon  )

extern

Definition at line 8062 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 fb(), 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  )

extern

Definition at line 8893 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(), fb(), REGBUF_NO_IMAGE, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfHeapVisible, VISIBILITYMAP_XLOG_CATALOG_REL, XLOG_HEAP2_VISIBLE, XLogBeginInsert(), XLogHintBitIsNeeded, XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by visibilitymap_set().