PostgreSQL Source Code  git master
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

◆ xl_heap_delete

◆ xl_heap_header

◆ xl_heap_inplace

◆ xl_heap_insert

◆ xl_heap_lock

typedef struct xl_heap_lock xl_heap_lock

◆ xl_heap_lock_updated

◆ xl_heap_multi_insert

◆ xl_heap_new_cid

◆ xl_heap_prune

typedef struct xl_heap_prune xl_heap_prune

◆ xl_heap_rewrite_mapping

◆ xl_heap_truncate

◆ xl_heap_update

◆ xl_heap_visible

◆ xl_multi_insert_tuple

◆ xlhp_freeze_plan

◆ xlhp_freeze_plans

◆ xlhp_prune_items

Function Documentation

◆ heap2_desc()

void heap2_desc ( StringInfo  buf,
XLogReaderState record 
)

Definition at line 264 of file heapdesc.c.

265 {
266  char *rec = XLogRecGetData(record);
267  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
268 
269  info &= XLOG_HEAP_OPMASK;
270  if (info == XLOG_HEAP2_PRUNE_ON_ACCESS ||
273  {
274  xl_heap_prune *xlrec = (xl_heap_prune *) rec;
275 
276  if (xlrec->flags & XLHP_HAS_CONFLICT_HORIZON)
277  {
278  TransactionId conflict_xid;
279 
280  memcpy(&conflict_xid, rec + SizeOfHeapPrune, sizeof(TransactionId));
281 
282  appendStringInfo(buf, "snapshotConflictHorizon: %u",
283  conflict_xid);
284  }
285 
286  appendStringInfo(buf, ", isCatalogRel: %c",
287  xlrec->flags & XLHP_IS_CATALOG_REL ? 'T' : 'F');
288 
289  if (XLogRecHasBlockData(record, 0))
290  {
291  Size datalen;
292  OffsetNumber *redirected;
293  OffsetNumber *nowdead;
294  OffsetNumber *nowunused;
295  int nredirected;
296  int nunused;
297  int ndead;
298  int nplans;
299  xlhp_freeze_plan *plans;
300  OffsetNumber *frz_offsets;
301 
302  char *cursor = XLogRecGetBlockData(record, 0, &datalen);
303 
305  &nplans, &plans, &frz_offsets,
306  &nredirected, &redirected,
307  &ndead, &nowdead,
308  &nunused, &nowunused);
309 
310  appendStringInfo(buf, ", nplans: %u, nredirected: %u, ndead: %u, nunused: %u",
311  nplans, nredirected, ndead, nunused);
312 
313  if (nplans > 0)
314  {
315  appendStringInfoString(buf, ", plans:");
316  array_desc(buf, plans, sizeof(xlhp_freeze_plan), nplans,
317  &plan_elem_desc, &frz_offsets);
318  }
319 
320  if (nredirected > 0)
321  {
322  appendStringInfoString(buf, ", redirected:");
323  array_desc(buf, redirected, sizeof(OffsetNumber) * 2,
324  nredirected, &redirect_elem_desc, NULL);
325  }
326 
327  if (ndead > 0)
328  {
329  appendStringInfoString(buf, ", dead:");
330  array_desc(buf, nowdead, sizeof(OffsetNumber), ndead,
331  &offset_elem_desc, NULL);
332  }
333 
334  if (nunused > 0)
335  {
336  appendStringInfoString(buf, ", unused:");
337  array_desc(buf, nowunused, sizeof(OffsetNumber), nunused,
338  &offset_elem_desc, NULL);
339  }
340  }
341  }
342  else if (info == XLOG_HEAP2_VISIBLE)
343  {
344  xl_heap_visible *xlrec = (xl_heap_visible *) rec;
345 
346  appendStringInfo(buf, "snapshotConflictHorizon: %u, flags: 0x%02X",
347  xlrec->snapshotConflictHorizon, xlrec->flags);
348  }
349  else if (info == XLOG_HEAP2_MULTI_INSERT)
350  {
352  bool isinit = (XLogRecGetInfo(record) & XLOG_HEAP_INIT_PAGE) != 0;
353 
354  appendStringInfo(buf, "ntuples: %d, flags: 0x%02X", xlrec->ntuples,
355  xlrec->flags);
356 
357  if (XLogRecHasBlockData(record, 0) && !isinit)
358  {
359  appendStringInfoString(buf, ", offsets:");
360  array_desc(buf, xlrec->offsets, sizeof(OffsetNumber),
361  xlrec->ntuples, &offset_elem_desc, NULL);
362  }
363  }
364  else if (info == XLOG_HEAP2_LOCK_UPDATED)
365  {
367 
368  appendStringInfo(buf, "xmax: %u, off: %u, ",
369  xlrec->xmax, xlrec->offnum);
370  infobits_desc(buf, xlrec->infobits_set, "infobits");
371  appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
372  }
373  else if (info == XLOG_HEAP2_NEW_CID)
374  {
375  xl_heap_new_cid *xlrec = (xl_heap_new_cid *) rec;
376 
377  appendStringInfo(buf, "rel: %u/%u/%u, tid: %u/%u",
378  xlrec->target_locator.spcOid,
379  xlrec->target_locator.dbOid,
380  xlrec->target_locator.relNumber,
383  appendStringInfo(buf, ", cmin: %u, cmax: %u, combo: %u",
384  xlrec->cmin, xlrec->cmax, xlrec->combocid);
385  }
386 }
uint8_t uint8
Definition: c.h:483
uint32 TransactionId
Definition: c.h:606
size_t Size
Definition: c.h:559
#define XLOG_HEAP2_MULTI_INSERT
Definition: heapam_xlog.h:64
#define XLHP_HAS_CONFLICT_HORIZON
Definition: heapam_xlog.h:317
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:42
#define SizeOfHeapPrune
Definition: heapam_xlog.h:296
#define XLOG_HEAP2_PRUNE_VACUUM_SCAN
Definition: heapam_xlog.h:61
#define XLOG_HEAP2_LOCK_UPDATED
Definition: heapam_xlog.h:65
#define XLOG_HEAP2_PRUNE_ON_ACCESS
Definition: heapam_xlog.h:60
#define XLOG_HEAP2_NEW_CID
Definition: heapam_xlog.h:66
#define XLOG_HEAP2_PRUNE_VACUUM_CLEANUP
Definition: heapam_xlog.h:62
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:63
#define XLHP_IS_CATALOG_REL
Definition: heapam_xlog.h:299
#define XLOG_HEAP_INIT_PAGE
Definition: heapam_xlog.h:47
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: heapdesc.c:105
static void plan_elem_desc(StringInfo buf, void *plan, void *data)
Definition: heapdesc.c:76
static void infobits_desc(StringInfo buf, uint8 infobits, const char *keyname)
Definition: heapdesc.c:26
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
uint16 OffsetNumber
Definition: off.h:24
static char * buf
Definition: pg_test_fsync.c:72
void redirect_elem_desc(StringInfo buf, void *offset, void *data)
void array_desc(StringInfo buf, void *array, size_t elem_size, int count, void(*elem_desc)(StringInfo buf, void *elem, void *data), void *data)
void offset_elem_desc(StringInfo buf, void *offset, void *data)
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:94
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:179
RelFileNumber relNumber
Definition: type.h:138
TransactionId xmax
Definition: heapam_xlog.h:409
OffsetNumber offnum
Definition: heapam_xlog.h:410
OffsetNumber offsets[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:185
CommandId cmin
Definition: heapam_xlog.h:459
CommandId combocid
Definition: heapam_xlog.h:461
ItemPointerData target_tid
Definition: heapam_xlog.h:467
CommandId cmax
Definition: heapam_xlog.h:460
RelFileLocator target_locator
Definition: heapam_xlog.h:466
TransactionId snapshotConflictHorizon
Definition: heapam_xlog.h:446
char * XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len)
Definition: xlogreader.c:2025
#define XLogRecHasBlockData(decoder, block_id)
Definition: xlogreader.h:427
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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.

435 {
436  const char *id = NULL;
437 
438  switch (info & ~XLR_INFO_MASK)
439  {
441  id = "PRUNE_ON_ACCESS";
442  break;
444  id = "PRUNE_VACUUM_SCAN";
445  break;
447  id = "PRUNE_VACUUM_CLEANUP";
448  break;
449  case XLOG_HEAP2_VISIBLE:
450  id = "VISIBLE";
451  break;
453  id = "MULTI_INSERT";
454  break;
456  id = "MULTI_INSERT+INIT";
457  break;
459  id = "LOCK_UPDATED";
460  break;
461  case XLOG_HEAP2_NEW_CID:
462  id = "NEW_CID";
463  break;
464  case XLOG_HEAP2_REWRITE:
465  id = "REWRITE";
466  break;
467  }
468 
469  return id;
470 }
#define XLOG_HEAP2_REWRITE
Definition: heapam_xlog.h:59

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.

1229 {
1230  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1231 
1232  switch (info & XLOG_HEAP_OPMASK)
1233  {
1237  heap_xlog_prune_freeze(record);
1238  break;
1239  case XLOG_HEAP2_VISIBLE:
1240  heap_xlog_visible(record);
1241  break;
1243  heap_xlog_multi_insert(record);
1244  break;
1246  heap_xlog_lock_updated(record);
1247  break;
1248  case XLOG_HEAP2_NEW_CID:
1249 
1250  /*
1251  * Nothing to do on a real replay, only used during logical
1252  * decoding.
1253  */
1254  break;
1255  case XLOG_HEAP2_REWRITE:
1256  heap_xlog_logical_rewrite(record);
1257  break;
1258  default:
1259  elog(PANIC, "heap2_redo: unknown op code %u", info);
1260  }
1261 }
#define PANIC
Definition: elog.h:42
#define elog(elevel,...)
Definition: elog.h:225
static void heap_xlog_prune_freeze(XLogReaderState *record)
Definition: heapam_xlog.c:30
static void heap_xlog_lock_updated(XLogReaderState *record)
Definition: heapam_xlog.c:1072
static void heap_xlog_multi_insert(XLogReaderState *record)
Definition: heapam_xlog.c:537
static void heap_xlog_visible(XLogReaderState *record)
Definition: heapam_xlog.c:182
void heap_xlog_logical_rewrite(XLogReaderState *r)
Definition: rewriteheap.c:1073

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.

185 {
186  char *rec = XLogRecGetData(record);
187  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
188 
189  info &= XLOG_HEAP_OPMASK;
190  if (info == XLOG_HEAP_INSERT)
191  {
192  xl_heap_insert *xlrec = (xl_heap_insert *) rec;
193 
194  appendStringInfo(buf, "off: %u, flags: 0x%02X",
195  xlrec->offnum,
196  xlrec->flags);
197  }
198  else if (info == XLOG_HEAP_DELETE)
199  {
200  xl_heap_delete *xlrec = (xl_heap_delete *) rec;
201 
202  appendStringInfo(buf, "xmax: %u, off: %u, ",
203  xlrec->xmax, xlrec->offnum);
204  infobits_desc(buf, xlrec->infobits_set, "infobits");
205  appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
206  }
207  else if (info == XLOG_HEAP_UPDATE)
208  {
209  xl_heap_update *xlrec = (xl_heap_update *) rec;
210 
211  appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
212  xlrec->old_xmax, xlrec->old_offnum);
213  infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
214  appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
215  xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
216  }
217  else if (info == XLOG_HEAP_HOT_UPDATE)
218  {
219  xl_heap_update *xlrec = (xl_heap_update *) rec;
220 
221  appendStringInfo(buf, "old_xmax: %u, old_off: %u, ",
222  xlrec->old_xmax, xlrec->old_offnum);
223  infobits_desc(buf, xlrec->old_infobits_set, "old_infobits");
224  appendStringInfo(buf, ", flags: 0x%02X, new_xmax: %u, new_off: %u",
225  xlrec->flags, xlrec->new_xmax, xlrec->new_offnum);
226  }
227  else if (info == XLOG_HEAP_TRUNCATE)
228  {
229  xl_heap_truncate *xlrec = (xl_heap_truncate *) rec;
230 
231  truncate_flags_desc(buf, xlrec->flags);
232  appendStringInfo(buf, ", nrelids: %u", xlrec->nrelids);
233  appendStringInfoString(buf, ", relids:");
234  array_desc(buf, xlrec->relids, sizeof(Oid), xlrec->nrelids,
235  &oid_elem_desc, NULL);
236  }
237  else if (info == XLOG_HEAP_CONFIRM)
238  {
239  xl_heap_confirm *xlrec = (xl_heap_confirm *) rec;
240 
241  appendStringInfo(buf, "off: %u", xlrec->offnum);
242  }
243  else if (info == XLOG_HEAP_LOCK)
244  {
245  xl_heap_lock *xlrec = (xl_heap_lock *) rec;
246 
247  appendStringInfo(buf, "xmax: %u, off: %u, ",
248  xlrec->xmax, xlrec->offnum);
249  infobits_desc(buf, xlrec->infobits_set, "infobits");
250  appendStringInfo(buf, ", flags: 0x%02X", xlrec->flags);
251  }
252  else if (info == XLOG_HEAP_INPLACE)
253  {
254  xl_heap_inplace *xlrec = (xl_heap_inplace *) rec;
255 
256  appendStringInfo(buf, "off: %u", xlrec->offnum);
257  standby_desc_invalidations(buf, xlrec->nmsgs, xlrec->msgs,
258  xlrec->dbId, xlrec->tsId,
259  xlrec->relcacheInitFileInval);
260  }
261 }
#define XLOG_HEAP_HOT_UPDATE
Definition: heapam_xlog.h:37
#define XLOG_HEAP_DELETE
Definition: heapam_xlog.h:34
#define XLOG_HEAP_TRUNCATE
Definition: heapam_xlog.h:36
#define XLOG_HEAP_UPDATE
Definition: heapam_xlog.h:35
#define XLOG_HEAP_INPLACE
Definition: heapam_xlog.h:40
#define XLOG_HEAP_LOCK
Definition: heapam_xlog.h:39
#define XLOG_HEAP_INSERT
Definition: heapam_xlog.h:33
#define XLOG_HEAP_CONFIRM
Definition: heapam_xlog.h:38
static void truncate_flags_desc(StringInfo buf, uint8 flags)
Definition: heapdesc.c:55
unsigned int Oid
Definition: postgres_ext.h:31
void oid_elem_desc(StringInfo buf, void *relid, void *data)
void standby_desc_invalidations(StringInfo buf, int nmsgs, SharedInvalidationMessage *msgs, Oid dbId, Oid tsId, bool relcacheInitFileInval)
Definition: standbydesc.c:101
OffsetNumber offnum
Definition: heapam_xlog.h:420
TransactionId xmax
Definition: heapam_xlog.h:115
OffsetNumber offnum
Definition: heapam_xlog.h:116
uint8 infobits_set
Definition: heapam_xlog.h:117
OffsetNumber offnum
Definition: heapam_xlog.h:428
SharedInvalidationMessage msgs[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:433
bool relcacheInitFileInval
Definition: heapam_xlog.h:431
OffsetNumber offnum
Definition: heapam_xlog.h:162
uint8 infobits_set
Definition: heapam_xlog.h:400
OffsetNumber offnum
Definition: heapam_xlog.h:399
TransactionId xmax
Definition: heapam_xlog.h:398
Oid relids[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:139
TransactionId new_xmax
Definition: heapam_xlog.h:224
uint8 old_infobits_set
Definition: heapam_xlog.h:222
TransactionId old_xmax
Definition: heapam_xlog.h:220
OffsetNumber old_offnum
Definition: heapam_xlog.h:221
OffsetNumber new_offnum
Definition: heapam_xlog.h:225

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.

390 {
391  const char *id = NULL;
392 
393  switch (info & ~XLR_INFO_MASK)
394  {
395  case XLOG_HEAP_INSERT:
396  id = "INSERT";
397  break;
399  id = "INSERT+INIT";
400  break;
401  case XLOG_HEAP_DELETE:
402  id = "DELETE";
403  break;
404  case XLOG_HEAP_UPDATE:
405  id = "UPDATE";
406  break;
408  id = "UPDATE+INIT";
409  break;
411  id = "HOT_UPDATE";
412  break;
414  id = "HOT_UPDATE+INIT";
415  break;
416  case XLOG_HEAP_TRUNCATE:
417  id = "TRUNCATE";
418  break;
419  case XLOG_HEAP_CONFIRM:
420  id = "HEAP_CONFIRM";
421  break;
422  case XLOG_HEAP_LOCK:
423  id = "LOCK";
424  break;
425  case XLOG_HEAP_INPLACE:
426  id = "INPLACE";
427  break;
428  }
429 
430  return id;
431 }

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.

1268 {
1269  Page page = (Page) pagedata;
1270  OffsetNumber off;
1271 
1273 
1274  mask_page_hint_bits(page);
1275  mask_unused_space(page);
1276 
1277  for (off = 1; off <= PageGetMaxOffsetNumber(page); off++)
1278  {
1279  ItemId iid = PageGetItemId(page, off);
1280  char *page_item;
1281 
1282  page_item = (char *) (page + ItemIdGetOffset(iid));
1283 
1284  if (ItemIdIsNormal(iid))
1285  {
1286  HeapTupleHeader page_htup = (HeapTupleHeader) page_item;
1287 
1288  /*
1289  * If xmin of a tuple is not yet frozen, we should ignore
1290  * differences in hint bits, since they can be set without
1291  * emitting WAL.
1292  */
1293  if (!HeapTupleHeaderXminFrozen(page_htup))
1294  page_htup->t_infomask &= ~HEAP_XACT_MASK;
1295  else
1296  {
1297  /* Still we need to mask xmax hint bits. */
1298  page_htup->t_infomask &= ~HEAP_XMAX_INVALID;
1299  page_htup->t_infomask &= ~HEAP_XMAX_COMMITTED;
1300  }
1301 
1302  /*
1303  * During replay, we set Command Id to FirstCommandId. Hence, mask
1304  * it. See heap_xlog_insert() for details.
1305  */
1306  page_htup->t_choice.t_heap.t_field3.t_cid = MASK_MARKER;
1307 
1308  /*
1309  * For a speculative tuple, heap_insert() does not set ctid in the
1310  * caller-passed heap tuple itself, leaving the ctid field to
1311  * contain a speculative token value - a per-backend monotonically
1312  * increasing identifier. Besides, it does not WAL-log ctid under
1313  * any circumstances.
1314  *
1315  * During redo, heap_xlog_insert() sets t_ctid to current block
1316  * number and self offset number. It doesn't care about any
1317  * speculative insertions on the primary. Hence, we set t_ctid to
1318  * current block number and self offset number to ignore any
1319  * inconsistency.
1320  */
1321  if (HeapTupleHeaderIsSpeculative(page_htup))
1322  ItemPointerSet(&page_htup->t_ctid, blkno, off);
1323 
1324  /*
1325  * NB: Not ignoring ctid changes due to the tuple having moved
1326  * (i.e. HeapTupleHeaderIndicatesMovedPartitions), because that's
1327  * important information that needs to be in-sync between primary
1328  * and standby, and thus is WAL logged.
1329  */
1330  }
1331 
1332  /*
1333  * Ignore any padding bytes after the tuple, when the length of the
1334  * item is not MAXALIGNed.
1335  */
1336  if (ItemIdHasStorage(iid))
1337  {
1338  int len = ItemIdGetLength(iid);
1339  int padlen = MAXALIGN(len) - len;
1340 
1341  if (padlen > 0)
1342  memset(page_item + len, MASK_MARKER, padlen);
1343  }
1344  }
1345 }
void mask_page_lsn_and_checksum(Page page)
Definition: bufmask.c:31
void mask_unused_space(Page page)
Definition: bufmask.c:71
void mask_page_hint_bits(Page page)
Definition: bufmask.c:46
#define MASK_MARKER
Definition: bufmask.h:24
Pointer Page
Definition: bufpage.h:81
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:243
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:372
#define MAXALIGN(LEN)
Definition: c.h:765
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:207
#define HEAP_XACT_MASK
Definition: htup_details.h:215
#define HeapTupleHeaderXminFrozen(tup)
Definition: htup_details.h:331
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208
#define HeapTupleHeaderIsSpeculative(tup)
Definition: htup_details.h:428
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
#define ItemIdGetOffset(itemId)
Definition: itemid.h:65
#define ItemIdHasStorage(itemId)
Definition: itemid.h:120
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
const void size_t len
union HeapTupleFields::@45 t_field3
CommandId t_cid
Definition: htup_details.h:129
union HeapTupleHeaderData::@46 t_choice
ItemPointerData t_ctid
Definition: htup_details.h:161
HeapTupleFields t_heap
Definition: htup_details.h:157

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.

1183 {
1184  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
1185 
1186  /*
1187  * These operations don't overwrite MVCC data so no conflict processing is
1188  * required. The ones in heap2 rmgr do.
1189  */
1190 
1191  switch (info & XLOG_HEAP_OPMASK)
1192  {
1193  case XLOG_HEAP_INSERT:
1194  heap_xlog_insert(record);
1195  break;
1196  case XLOG_HEAP_DELETE:
1197  heap_xlog_delete(record);
1198  break;
1199  case XLOG_HEAP_UPDATE:
1200  heap_xlog_update(record, false);
1201  break;
1202  case XLOG_HEAP_TRUNCATE:
1203 
1204  /*
1205  * TRUNCATE is a no-op because the actions are already logged as
1206  * SMGR WAL records. TRUNCATE WAL record only exists for logical
1207  * decoding.
1208  */
1209  break;
1210  case XLOG_HEAP_HOT_UPDATE:
1211  heap_xlog_update(record, true);
1212  break;
1213  case XLOG_HEAP_CONFIRM:
1214  heap_xlog_confirm(record);
1215  break;
1216  case XLOG_HEAP_LOCK:
1217  heap_xlog_lock(record);
1218  break;
1219  case XLOG_HEAP_INPLACE:
1220  heap_xlog_inplace(record);
1221  break;
1222  default:
1223  elog(PANIC, "heap_redo: unknown op code %u", info);
1224  }
1225 }
static void heap_xlog_insert(XLogReaderState *record)
Definition: heapam_xlog.c:417
static void heap_xlog_update(XLogReaderState *record, bool hot_update)
Definition: heapam_xlog.c:684
static void heap_xlog_delete(XLogReaderState *record)
Definition: heapam_xlog.c:341
static void heap_xlog_lock(XLogReaderState *record)
Definition: heapam_xlog.c:998
static void heap_xlog_inplace(XLogReaderState *record)
Definition: heapam_xlog.c:1135
static void heap_xlog_confirm(XLogReaderState *record)
Definition: heapam_xlog.c:959

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.

111 {
112  if (flags & XLHP_HAS_FREEZE_PLANS)
113  {
114  xlhp_freeze_plans *freeze_plans = (xlhp_freeze_plans *) cursor;
115 
116  *nplans = freeze_plans->nplans;
117  Assert(*nplans > 0);
118  *plans = freeze_plans->plans;
119 
120  cursor += offsetof(xlhp_freeze_plans, plans);
121  cursor += sizeof(xlhp_freeze_plan) * *nplans;
122  }
123  else
124  {
125  *nplans = 0;
126  *plans = NULL;
127  }
128 
129  if (flags & XLHP_HAS_REDIRECTIONS)
130  {
131  xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
132 
133  *nredirected = subrecord->ntargets;
134  Assert(*nredirected > 0);
135  *redirected = &subrecord->data[0];
136 
137  cursor += offsetof(xlhp_prune_items, data);
138  cursor += sizeof(OffsetNumber[2]) * *nredirected;
139  }
140  else
141  {
142  *nredirected = 0;
143  *redirected = NULL;
144  }
145 
146  if (flags & XLHP_HAS_DEAD_ITEMS)
147  {
148  xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
149 
150  *ndead = subrecord->ntargets;
151  Assert(*ndead > 0);
152  *nowdead = subrecord->data;
153 
154  cursor += offsetof(xlhp_prune_items, data);
155  cursor += sizeof(OffsetNumber) * *ndead;
156  }
157  else
158  {
159  *ndead = 0;
160  *nowdead = NULL;
161  }
162 
163  if (flags & XLHP_HAS_NOW_UNUSED_ITEMS)
164  {
165  xlhp_prune_items *subrecord = (xlhp_prune_items *) cursor;
166 
167  *nunused = subrecord->ntargets;
168  Assert(*nunused > 0);
169  *nowunused = subrecord->data;
170 
171  cursor += offsetof(xlhp_prune_items, data);
172  cursor += sizeof(OffsetNumber) * *nunused;
173  }
174  else
175  {
176  *nunused = 0;
177  *nowunused = NULL;
178  }
179 
180  *frz_offsets = (OffsetNumber *) cursor;
181 }
#define Assert(condition)
Definition: c.h:812
struct xlhp_freeze_plan xlhp_freeze_plan
#define XLHP_HAS_FREEZE_PLANS
Definition: heapam_xlog.h:323
#define XLHP_HAS_NOW_UNUSED_ITEMS
Definition: heapam_xlog.h:332
#define XLHP_HAS_REDIRECTIONS
Definition: heapam_xlog.h:330
#define XLHP_HAS_DEAD_ITEMS
Definition: heapam_xlog.h:331
const void * data
xlhp_freeze_plan plans[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:368
OffsetNumber data[FLEXIBLE_ARRAY_MEMBER]
Definition: heapam_xlog.h:381

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.

1074 {
1075  char path[MAXPGPATH];
1076  int fd;
1077  xl_heap_rewrite_mapping *xlrec;
1078  uint32 len;
1079  char *data;
1080 
1081  xlrec = (xl_heap_rewrite_mapping *) XLogRecGetData(r);
1082 
1083  snprintf(path, MAXPGPATH,
1084  "%s/" LOGICAL_REWRITE_FORMAT,
1086  LSN_FORMAT_ARGS(xlrec->start_lsn),
1087  xlrec->mapped_xid, XLogRecGetXid(r));
1088 
1089  fd = OpenTransientFile(path,
1090  O_CREAT | O_WRONLY | PG_BINARY);
1091  if (fd < 0)
1092  ereport(ERROR,
1094  errmsg("could not create file \"%s\": %m", path)));
1095 
1096  /*
1097  * Truncate all data that's not guaranteed to have been safely fsynced (by
1098  * previous record or by the last checkpoint).
1099  */
1100  pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE);
1101  if (ftruncate(fd, xlrec->offset) != 0)
1102  ereport(ERROR,
1104  errmsg("could not truncate file \"%s\" to %u: %m",
1105  path, (uint32) xlrec->offset)));
1107 
1108  data = XLogRecGetData(r) + sizeof(*xlrec);
1109 
1110  len = xlrec->num_mappings * sizeof(LogicalRewriteMappingData);
1111 
1112  /* write out tail end of mapping file (again) */
1113  errno = 0;
1114  pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE);
1115  if (pg_pwrite(fd, data, len, xlrec->offset) != len)
1116  {
1117  /* if write didn't set errno, assume problem is no disk space */
1118  if (errno == 0)
1119  errno = ENOSPC;
1120  ereport(ERROR,
1122  errmsg("could not write to file \"%s\": %m", path)));
1123  }
1125 
1126  /*
1127  * Now fsync all previously written data. We could improve things and only
1128  * do this for the last write to a file, but the required bookkeeping
1129  * doesn't seem worth the trouble.
1130  */
1131  pgstat_report_wait_start(WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC);
1132  if (pg_fsync(fd) != 0)
1135  errmsg("could not fsync file \"%s\": %m", path)));
1137 
1138  if (CloseTransientFile(fd) != 0)
1139  ereport(ERROR,
1141  errmsg("could not close file \"%s\": %m", path)));
1142 }
#define PG_BINARY
Definition: c.h:1227
uint32_t uint32
Definition: c.h:485
int errcode_for_file_access(void)
Definition: elog.c:876
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
int CloseTransientFile(int fd)
Definition: fd.c:2831
int data_sync_elevel(int elevel)
Definition: fd.c:3959
int pg_fsync(int fd)
Definition: fd.c:385
int OpenTransientFile(const char *fileName, int fileFlags)
Definition: fd.c:2655
#define MAXPGPATH
#define pg_pwrite
Definition: port.h:226
#define snprintf
Definition: port.h:238
static int fd(const char *x, int i)
Definition: preproc-init.c:105
#define PG_LOGICAL_MAPPINGS_DIR
Definition: reorderbuffer.h:23
#define LOGICAL_REWRITE_FORMAT
Definition: rewriteheap.h:54
struct LogicalRewriteMappingData LogicalRewriteMappingData
TransactionId mapped_xid
Definition: heapam_xlog.h:475
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:85
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101
#define ftruncate(a, b)
Definition: win32_port.h:82
#define LSN_FORMAT_ARGS(lsn)
Definition: xlogdefs.h:43
#define XLogRecGetXid(decoder)
Definition: xlogreader.h:412

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.

7813 {
7814  TransactionId xmin = HeapTupleHeaderGetXmin(tuple);
7816  TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
7817 
7818  if (tuple->t_infomask & HEAP_MOVED)
7819  {
7820  if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
7821  *snapshotConflictHorizon = xvac;
7822  }
7823 
7824  /*
7825  * Ignore tuples inserted by an aborted transaction or if the tuple was
7826  * updated/deleted by the inserting transaction.
7827  *
7828  * Look for a committed hint bit, or if no xmin bit is set, check clog.
7829  */
7830  if (HeapTupleHeaderXminCommitted(tuple) ||
7832  {
7833  if (xmax != xmin &&
7834  TransactionIdFollows(xmax, *snapshotConflictHorizon))
7835  *snapshotConflictHorizon = xmax;
7836  }
7837 }
#define HeapTupleHeaderGetXvac(tup)
Definition: htup_details.h:411
#define HeapTupleHeaderGetXmin(tup)
Definition: htup_details.h:309
#define HEAP_MOVED
Definition: htup_details.h:213
#define HeapTupleHeaderXminCommitted(tup)
Definition: htup_details.h:320
#define HeapTupleHeaderGetUpdateXid(tup)
Definition: htup_details.h:361
#define HeapTupleHeaderXminInvalid(tup)
Definition: htup_details.h:325
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:126
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition: transam.c:314

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.

8644 {
8645  xl_heap_visible xlrec;
8646  XLogRecPtr recptr;
8647  uint8 flags;
8648 
8649  Assert(BufferIsValid(heap_buffer));
8650  Assert(BufferIsValid(vm_buffer));
8651 
8652  xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
8653  xlrec.flags = vmflags;
8656  XLogBeginInsert();
8657  XLogRegisterData((char *) &xlrec, SizeOfHeapVisible);
8658 
8659  XLogRegisterBuffer(0, vm_buffer, 0);
8660 
8661  flags = REGBUF_STANDARD;
8662  if (!XLogHintBitIsNeeded())
8663  flags |= REGBUF_NO_IMAGE;
8664  XLogRegisterBuffer(1, heap_buffer, flags);
8665 
8666  recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_VISIBLE);
8667 
8668  return recptr;
8669 }
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:351
#define SizeOfHeapVisible
Definition: heapam_xlog.h:450
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:684
#define VISIBILITYMAP_XLOG_CATALOG_REL
#define XLogHintBitIsNeeded()
Definition: xlog.h:120
uint64 XLogRecPtr
Definition: xlogdefs.h:21
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterData(const char *data, uint32 len)
Definition: xloginsert.c:364
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:242
void XLogBeginInsert(void)
Definition: xloginsert.c:149
#define REGBUF_STANDARD
Definition: xloginsert.h:34
#define REGBUF_NO_IMAGE
Definition: xloginsert.h:32

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