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,
383 appendStringInfo(buf, ", cmin: %u, cmax: %u, combo: %u",
384 xlrec->cmin, xlrec->cmax, xlrec->combocid);
385 }
386}
uint8_t uint8
Definition: c.h:500
uint32 TransactionId
Definition: c.h:623
size_t Size
Definition: c.h:576
#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:145
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:230
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:2035
#define XLogRecHasBlockData(decoder, block_id)
Definition: xlogreader.h:427
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLogRecGetData(decoder)
Definition: xlogreader.h:415

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, 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;
450 id = "VISIBLE";
451 break;
453 id = "MULTI_INSERT";
454 break;
456 id = "MULTI_INSERT+INIT";
457 break;
459 id = "LOCK_UPDATED";
460 break;
462 id = "NEW_CID";
463 break;
465 id = "REWRITE";
466 break;
467 }
468
469 return id;
470}
#define XLOG_HEAP2_REWRITE
Definition: heapam_xlog.h:59
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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:
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, and XLogRecGetInfo.

◆ 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
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);
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:32
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, 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;
417 id = "TRUNCATE";
418 break;
420 id = "HEAP_CONFIRM";
421 break;
422 case XLOG_HEAP_LOCK:
423 id = "LOCK";
424 break;
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 */
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
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
PageData * Page
Definition: bufpage.h:82
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
#define MAXALIGN(LEN)
Definition: c.h:782
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
static bool HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup)
Definition: htup_details.h:350
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:207
#define HEAP_XACT_MASK
Definition: htup_details.h:215
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208
static bool HeapTupleHeaderIsSpeculative(const HeapTupleHeaderData *tup)
Definition: htup_details.h:461
#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::@46 t_field3
CommandId t_cid
Definition: htup_details.h:129
union HeapTupleHeaderData::@47 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;
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, and XLogRecGetInfo.

◆ 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 {
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 {
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 {
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}
Assert(PointerIsAligned(start, uint64))
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;
1078 uint32 len;
1079 char *data;
1080
1082
1083 snprintf(path, MAXPGPATH,
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:1244
uint32_t uint32
Definition: c.h:502
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:227
#define snprintf
Definition: port.h:239
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 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(), 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 7962 of file heapam.c.

7964{
7968
7969 if (tuple->t_infomask & HEAP_MOVED)
7970 {
7971 if (TransactionIdPrecedes(*snapshotConflictHorizon, xvac))
7972 *snapshotConflictHorizon = xvac;
7973 }
7974
7975 /*
7976 * Ignore tuples inserted by an aborted transaction or if the tuple was
7977 * updated/deleted by the inserting transaction.
7978 *
7979 * Look for a committed hint bit, or if no xmin bit is set, check clog.
7980 */
7981 if (HeapTupleHeaderXminCommitted(tuple) ||
7983 {
7984 if (xmax != xmin &&
7985 TransactionIdFollows(xmax, *snapshotConflictHorizon))
7986 *snapshotConflictHorizon = xmax;
7987 }
7988}
static bool HeapTupleHeaderXminInvalid(const HeapTupleHeaderData *tup)
Definition: htup_details.h:343
static TransactionId HeapTupleHeaderGetXvac(const HeapTupleHeaderData *tup)
Definition: htup_details.h:442
#define HEAP_MOVED
Definition: htup_details.h:213
static TransactionId HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
Definition: htup_details.h:324
static TransactionId HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
Definition: htup_details.h:397
static bool HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
Definition: htup_details.h:337
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 8793 of file heapam.c.

8795{
8796 xl_heap_visible xlrec;
8797 XLogRecPtr recptr;
8798 uint8 flags;
8799
8800 Assert(BufferIsValid(heap_buffer));
8801 Assert(BufferIsValid(vm_buffer));
8802
8803 xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
8804 xlrec.flags = vmflags;
8809
8810 XLogRegisterBuffer(0, vm_buffer, 0);
8811
8812 flags = REGBUF_STANDARD;
8813 if (!XLogHintBitIsNeeded())
8814 flags |= REGBUF_NO_IMAGE;
8815 XLogRegisterBuffer(1, heap_buffer, flags);
8816
8817 recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_VISIBLE);
8818
8819 return recptr;
8820}
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:352
#define SizeOfHeapVisible
Definition: heapam_xlog.h:450
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:692
#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 void *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:35
#define REGBUF_NO_IMAGE
Definition: xloginsert.h:33

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