PostgreSQL Source Code  git master
heapam.c File Reference
#include "postgres.h"
#include "access/bufmask.h"
#include "access/heapam.h"
#include "access/heapam_xlog.h"
#include "access/heaptoast.h"
#include "access/hio.h"
#include "access/multixact.h"
#include "access/parallel.h"
#include "access/relscan.h"
#include "access/subtrans.h"
#include "access/syncscan.h"
#include "access/sysattr.h"
#include "access/tableam.h"
#include "access/transam.h"
#include "access/valid.h"
#include "access/visibilitymap.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "access/xloginsert.h"
#include "access/xlogutils.h"
#include "catalog/catalog.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "port/pg_bitutils.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
#include "storage/lmgr.h"
#include "storage/predicate.h"
#include "storage/procarray.h"
#include "storage/standby.h"
#include "utils/datum.h"
#include "utils/injection_point.h"
#include "utils/inval.h"
#include "utils/relcache.h"
#include "utils/snapmgr.h"
#include "utils/spccache.h"
Include dependency graph for heapam.c:

Go to the source code of this file.

Data Structures

struct  IndexDeleteCounts
 

Macros

#define LOCKMODE_from_mxstatus(status)    (tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock)
 
#define LockTupleTuplock(rel, tup, mode)    LockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
 
#define UnlockTupleTuplock(rel, tup, mode)    UnlockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
 
#define ConditionalLockTupleTuplock(rel, tup, mode)    ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)
 
#define BOTTOMUP_MAX_NBLOCKS   6
 
#define BOTTOMUP_TOLERANCE_NBLOCKS   3
 
#define TUPLOCK_from_mxstatus(status)    (MultiXactStatusLock[(status)])
 
#define FRM_NOOP   0x0001
 
#define FRM_INVALIDATE_XMAX   0x0002
 
#define FRM_RETURN_IS_XID   0x0004
 
#define FRM_RETURN_IS_MULTI   0x0008
 
#define FRM_MARK_COMMITTED   0x0010
 

Typedefs

typedef struct IndexDeleteCounts IndexDeleteCounts
 

Functions

static HeapTuple heap_prepare_insert (Relation relation, HeapTuple tup, TransactionId xid, CommandId cid, int options)
 
static XLogRecPtr log_heap_update (Relation reln, Buffer oldbuf, Buffer newbuf, HeapTuple oldtup, HeapTuple newtup, HeapTuple old_key_tuple, bool all_visible_cleared, bool new_all_visible_cleared)
 
static BitmapsetHeapDetermineColumnsInfo (Relation relation, Bitmapset *interesting_cols, Bitmapset *external_cols, HeapTuple oldtup, HeapTuple newtup, bool *has_external)
 
static bool heap_acquire_tuplock (Relation relation, ItemPointer tid, LockTupleMode mode, LockWaitPolicy wait_policy, bool *have_tuple_lock)
 
static BlockNumber heapgettup_advance_block (HeapScanDesc scan, BlockNumber block, ScanDirection dir)
 
static pg_noinline BlockNumber heapgettup_initial_block (HeapScanDesc scan, ScanDirection dir)
 
static void compute_new_xmax_infomask (TransactionId xmax, uint16 old_infomask, uint16 old_infomask2, TransactionId add_to_xmax, LockTupleMode mode, bool is_update, TransactionId *result_xmax, uint16 *result_infomask, uint16 *result_infomask2)
 
static TM_Result heap_lock_updated_tuple (Relation rel, HeapTuple tuple, ItemPointer ctid, TransactionId xid, LockTupleMode mode)
 
static void GetMultiXactIdHintBits (MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
 
static TransactionId MultiXactIdGetUpdateXid (TransactionId xmax, uint16 t_infomask)
 
static bool DoesMultiXactIdConflict (MultiXactId multi, uint16 infomask, LockTupleMode lockmode, bool *current_is_member)
 
static void MultiXactIdWait (MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
 
static bool ConditionalMultiXactIdWait (MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, int *remaining)
 
static void index_delete_sort (TM_IndexDeleteOp *delstate)
 
static int bottomup_sort_and_shrink (TM_IndexDeleteOp *delstate)
 
static XLogRecPtr log_heap_new_cid (Relation relation, HeapTuple tup)
 
static HeapTuple ExtractReplicaIdentity (Relation relation, HeapTuple tp, bool key_required, bool *copy)
 
static BlockNumber heap_scan_stream_read_next_parallel (ReadStream *stream, void *callback_private_data, void *per_buffer_data)
 
static BlockNumber heap_scan_stream_read_next_serial (ReadStream *stream, void *callback_private_data, void *per_buffer_data)
 
static void initscan (HeapScanDesc scan, ScanKey key, bool keep_startblock)
 
void heap_setscanlimits (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
 
static pg_attribute_always_inline int page_collect_tuples (HeapScanDesc scan, Snapshot snapshot, Page page, Buffer buffer, BlockNumber block, int lines, bool all_visible, bool check_serializable)
 
void heap_prepare_pagescan (TableScanDesc sscan)
 
static void heap_fetch_next_buffer (HeapScanDesc scan, ScanDirection dir)
 
static Page heapgettup_start_page (HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
 
static Page heapgettup_continue_page (HeapScanDesc scan, ScanDirection dir, int *linesleft, OffsetNumber *lineoff)
 
static void heapgettup (HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
 
static void heapgettup_pagemode (HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
 
TableScanDesc heap_beginscan (Relation relation, Snapshot snapshot, int nkeys, ScanKey key, ParallelTableScanDesc parallel_scan, uint32 flags)
 
void heap_rescan (TableScanDesc sscan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
 
void heap_endscan (TableScanDesc sscan)
 
HeapTuple heap_getnext (TableScanDesc sscan, ScanDirection direction)
 
bool heap_getnextslot (TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 
void heap_set_tidrange (TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
 
bool heap_getnextslot_tidrange (TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
 
bool heap_fetch (Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
 
bool heap_hot_search_buffer (ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
 
void heap_get_latest_tid (TableScanDesc sscan, ItemPointer tid)
 
static void UpdateXmaxHintBits (HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
 
BulkInsertState GetBulkInsertState (void)
 
void FreeBulkInsertState (BulkInsertState bistate)
 
void ReleaseBulkInsertStatePin (BulkInsertState bistate)
 
void heap_insert (Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
 
static int heap_multi_insert_pages (HeapTuple *heaptuples, int done, int ntuples, Size saveFreeSpace)
 
void heap_multi_insert (Relation relation, TupleTableSlot **slots, int ntuples, CommandId cid, int options, BulkInsertState bistate)
 
void simple_heap_insert (Relation relation, HeapTuple tup)
 
static uint8 compute_infobits (uint16 infomask, uint16 infomask2)
 
static bool xmax_infomask_changed (uint16 new_infomask, uint16 old_infomask)
 
TM_Result heap_delete (Relation relation, ItemPointer tid, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
 
void simple_heap_delete (Relation relation, ItemPointer tid)
 
TM_Result heap_update (Relation relation, ItemPointer otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
 
static bool heap_attr_equals (TupleDesc tupdesc, int attrnum, Datum value1, Datum value2, bool isnull1, bool isnull2)
 
void simple_heap_update (Relation relation, ItemPointer otid, HeapTuple tup, TU_UpdateIndexes *update_indexes)
 
static MultiXactStatus get_mxact_status_for_lock (LockTupleMode mode, bool is_update)
 
TM_Result heap_lock_tuple (Relation relation, HeapTuple tuple, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, bool follow_updates, Buffer *buffer, TM_FailureData *tmfd)
 
static TM_Result test_lockmode_for_conflict (MultiXactStatus status, TransactionId xid, LockTupleMode mode, HeapTuple tup, bool *needwait)
 
static TM_Result heap_lock_updated_tuple_rec (Relation rel, ItemPointer tid, TransactionId xid, LockTupleMode mode)
 
void heap_finish_speculative (Relation relation, ItemPointer tid)
 
void heap_abort_speculative (Relation relation, ItemPointer tid)
 
void heap_inplace_update (Relation relation, HeapTuple tuple)
 
static TransactionId FreezeMultiXactId (MultiXactId multi, uint16 t_infomask, const struct VacuumCutoffs *cutoffs, uint16 *flags, HeapPageFreeze *pagefrz)
 
bool heap_prepare_freeze_tuple (HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
 
static void heap_execute_freeze_tuple (HeapTupleHeader tuple, HeapTupleFreeze *frz)
 
void heap_pre_freeze_checks (Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
 
void heap_freeze_prepared_tuples (Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
 
bool heap_freeze_tuple (HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId FreezeLimit, TransactionId MultiXactCutoff)
 
TransactionId HeapTupleGetUpdateXid (HeapTupleHeader tuple)
 
static bool Do_MultiXactIdWait (MultiXactId multi, MultiXactStatus status, uint16 infomask, bool nowait, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
 
bool heap_tuple_needs_eventual_freeze (HeapTupleHeader tuple)
 
bool heap_tuple_should_freeze (HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
 
void HeapTupleHeaderAdvanceConflictHorizon (HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
 
static void index_delete_check_htid (TM_IndexDeleteOp *delstate, Page page, OffsetNumber maxoff, ItemPointer htid, TM_IndexStatus *istatus)
 
TransactionId heap_index_delete_tuples (Relation rel, TM_IndexDeleteOp *delstate)
 
static int index_delete_sort_cmp (TM_IndexDelete *deltid1, TM_IndexDelete *deltid2)
 
static int bottomup_nblocksfavorable (IndexDeleteCounts *blockgroups, int nblockgroups, TM_IndexDelete *deltids)
 
static int bottomup_sort_and_shrink_cmp (const void *arg1, const void *arg2)
 
XLogRecPtr log_heap_visible (Relation rel, Buffer heap_buffer, Buffer vm_buffer, TransactionId snapshotConflictHorizon, uint8 vmflags)
 
static void heap_xlog_prune_freeze (XLogReaderState *record)
 
static void heap_xlog_visible (XLogReaderState *record)
 
static void fix_infomask_from_infobits (uint8 infobits, uint16 *infomask, uint16 *infomask2)
 
static void heap_xlog_delete (XLogReaderState *record)
 
static void heap_xlog_insert (XLogReaderState *record)
 
static void heap_xlog_multi_insert (XLogReaderState *record)
 
static void heap_xlog_update (XLogReaderState *record, bool hot_update)
 
static void heap_xlog_confirm (XLogReaderState *record)
 
static void heap_xlog_lock (XLogReaderState *record)
 
static void heap_xlog_lock_updated (XLogReaderState *record)
 
static void heap_xlog_inplace (XLogReaderState *record)
 
void heap_redo (XLogReaderState *record)
 
void heap2_redo (XLogReaderState *record)
 
void heap_mask (char *pagedata, BlockNumber blkno)
 
void HeapCheckForSerializableConflictOut (bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
 

Variables

struct {
   LOCKMODE   hwlock
 
   int   lockstatus
 
   int   updstatus
 
tupleLockExtraInfo [MaxLockTupleMode+1]
 
static const int MultiXactStatusLock [MaxMultiXactStatus+1]
 

Macro Definition Documentation

◆ BOTTOMUP_MAX_NBLOCKS

#define BOTTOMUP_MAX_NBLOCKS   6

Definition at line 190 of file heapam.c.

◆ BOTTOMUP_TOLERANCE_NBLOCKS

#define BOTTOMUP_TOLERANCE_NBLOCKS   3

Definition at line 191 of file heapam.c.

◆ ConditionalLockTupleTuplock

#define ConditionalLockTupleTuplock (   rel,
  tup,
  mode 
)     ConditionalLockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)

Definition at line 172 of file heapam.c.

◆ FRM_INVALIDATE_XMAX

#define FRM_INVALIDATE_XMAX   0x0002

Definition at line 6148 of file heapam.c.

◆ FRM_MARK_COMMITTED

#define FRM_MARK_COMMITTED   0x0010

Definition at line 6151 of file heapam.c.

◆ FRM_NOOP

#define FRM_NOOP   0x0001

Definition at line 6147 of file heapam.c.

◆ FRM_RETURN_IS_MULTI

#define FRM_RETURN_IS_MULTI   0x0008

Definition at line 6150 of file heapam.c.

◆ FRM_RETURN_IS_XID

#define FRM_RETURN_IS_XID   0x0004

Definition at line 6149 of file heapam.c.

◆ LOCKMODE_from_mxstatus

#define LOCKMODE_from_mxstatus (   status)     (tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock)

Definition at line 160 of file heapam.c.

◆ LockTupleTuplock

#define LockTupleTuplock (   rel,
  tup,
  mode 
)     LockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)

Definition at line 168 of file heapam.c.

◆ TUPLOCK_from_mxstatus

#define TUPLOCK_from_mxstatus (   status)     (MultiXactStatusLock[(status)])

Definition at line 219 of file heapam.c.

◆ UnlockTupleTuplock

#define UnlockTupleTuplock (   rel,
  tup,
  mode 
)     UnlockTuple((rel), (tup), tupleLockExtraInfo[mode].hwlock)

Definition at line 170 of file heapam.c.

Typedef Documentation

◆ IndexDeleteCounts

Function Documentation

◆ bottomup_nblocksfavorable()

static int bottomup_nblocksfavorable ( IndexDeleteCounts blockgroups,
int  nblockgroups,
TM_IndexDelete deltids 
)
static

Definition at line 8078 of file heapam.c.

8080 {
8081  int64 lastblock = -1;
8082  int nblocksfavorable = 0;
8083 
8084  Assert(nblockgroups >= 1);
8085  Assert(nblockgroups <= BOTTOMUP_MAX_NBLOCKS);
8086 
8087  /*
8088  * We tolerate heap blocks that will be accessed only slightly out of
8089  * physical order. Small blips occur when a pair of almost-contiguous
8090  * blocks happen to fall into different buckets (perhaps due only to a
8091  * small difference in npromisingtids that the bucketing scheme didn't
8092  * quite manage to ignore). We effectively ignore these blips by applying
8093  * a small tolerance. The precise tolerance we use is a little arbitrary,
8094  * but it works well enough in practice.
8095  */
8096  for (int b = 0; b < nblockgroups; b++)
8097  {
8098  IndexDeleteCounts *group = blockgroups + b;
8099  TM_IndexDelete *firstdtid = deltids + group->ifirsttid;
8100  BlockNumber block = ItemPointerGetBlockNumber(&firstdtid->tid);
8101 
8102  if (lastblock != -1 &&
8103  ((int64) block < lastblock - BOTTOMUP_TOLERANCE_NBLOCKS ||
8104  (int64) block > lastblock + BOTTOMUP_TOLERANCE_NBLOCKS))
8105  break;
8106 
8107  nblocksfavorable++;
8108  lastblock = block;
8109  }
8110 
8111  /* Always indicate that there is at least 1 favorable block */
8112  Assert(nblocksfavorable >= 1);
8113 
8114  return nblocksfavorable;
8115 }
uint32 BlockNumber
Definition: block.h:31
#define Assert(condition)
Definition: c.h:858
#define BOTTOMUP_TOLERANCE_NBLOCKS
Definition: heapam.c:191
#define BOTTOMUP_MAX_NBLOCKS
Definition: heapam.c:190
int b
Definition: isn.c:70
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
int16 ifirsttid
Definition: heapam.c:201
ItemPointerData tid
Definition: tableam.h:213

References Assert, b, BOTTOMUP_MAX_NBLOCKS, BOTTOMUP_TOLERANCE_NBLOCKS, IndexDeleteCounts::ifirsttid, ItemPointerGetBlockNumber(), and TM_IndexDelete::tid.

Referenced by bottomup_sort_and_shrink().

◆ bottomup_sort_and_shrink()

static int bottomup_sort_and_shrink ( TM_IndexDeleteOp delstate)
static

Definition at line 8194 of file heapam.c.

8195 {
8196  IndexDeleteCounts *blockgroups;
8197  TM_IndexDelete *reordereddeltids;
8198  BlockNumber curblock = InvalidBlockNumber;
8199  int nblockgroups = 0;
8200  int ncopied = 0;
8201  int nblocksfavorable = 0;
8202 
8203  Assert(delstate->bottomup);
8204  Assert(delstate->ndeltids > 0);
8205 
8206  /* Calculate per-heap-block count of TIDs */
8207  blockgroups = palloc(sizeof(IndexDeleteCounts) * delstate->ndeltids);
8208  for (int i = 0; i < delstate->ndeltids; i++)
8209  {
8210  TM_IndexDelete *ideltid = &delstate->deltids[i];
8211  TM_IndexStatus *istatus = delstate->status + ideltid->id;
8212  ItemPointer htid = &ideltid->tid;
8213  bool promising = istatus->promising;
8214 
8215  if (curblock != ItemPointerGetBlockNumber(htid))
8216  {
8217  /* New block group */
8218  nblockgroups++;
8219 
8220  Assert(curblock < ItemPointerGetBlockNumber(htid) ||
8221  !BlockNumberIsValid(curblock));
8222 
8223  curblock = ItemPointerGetBlockNumber(htid);
8224  blockgroups[nblockgroups - 1].ifirsttid = i;
8225  blockgroups[nblockgroups - 1].ntids = 1;
8226  blockgroups[nblockgroups - 1].npromisingtids = 0;
8227  }
8228  else
8229  {
8230  blockgroups[nblockgroups - 1].ntids++;
8231  }
8232 
8233  if (promising)
8234  blockgroups[nblockgroups - 1].npromisingtids++;
8235  }
8236 
8237  /*
8238  * We're about ready to sort block groups to determine the optimal order
8239  * for visiting heap blocks. But before we do, round the number of
8240  * promising tuples for each block group up to the next power-of-two,
8241  * unless it is very low (less than 4), in which case we round up to 4.
8242  * npromisingtids is far too noisy to trust when choosing between a pair
8243  * of block groups that both have very low values.
8244  *
8245  * This scheme divides heap blocks/block groups into buckets. Each bucket
8246  * contains blocks that have _approximately_ the same number of promising
8247  * TIDs as each other. The goal is to ignore relatively small differences
8248  * in the total number of promising entries, so that the whole process can
8249  * give a little weight to heapam factors (like heap block locality)
8250  * instead. This isn't a trade-off, really -- we have nothing to lose. It
8251  * would be foolish to interpret small differences in npromisingtids
8252  * values as anything more than noise.
8253  *
8254  * We tiebreak on nhtids when sorting block group subsets that have the
8255  * same npromisingtids, but this has the same issues as npromisingtids,
8256  * and so nhtids is subject to the same power-of-two bucketing scheme. The
8257  * only reason that we don't fix nhtids in the same way here too is that
8258  * we'll need accurate nhtids values after the sort. We handle nhtids
8259  * bucketization dynamically instead (in the sort comparator).
8260  *
8261  * See bottomup_nblocksfavorable() for a full explanation of when and how
8262  * heap locality/favorable blocks can significantly influence when and how
8263  * heap blocks are accessed.
8264  */
8265  for (int b = 0; b < nblockgroups; b++)
8266  {
8267  IndexDeleteCounts *group = blockgroups + b;
8268 
8269  /* Better off falling back on nhtids with low npromisingtids */
8270  if (group->npromisingtids <= 4)
8271  group->npromisingtids = 4;
8272  else
8273  group->npromisingtids =
8275  }
8276 
8277  /* Sort groups and rearrange caller's deltids array */
8278  qsort(blockgroups, nblockgroups, sizeof(IndexDeleteCounts),
8280  reordereddeltids = palloc(delstate->ndeltids * sizeof(TM_IndexDelete));
8281 
8282  nblockgroups = Min(BOTTOMUP_MAX_NBLOCKS, nblockgroups);
8283  /* Determine number of favorable blocks at the start of final deltids */
8284  nblocksfavorable = bottomup_nblocksfavorable(blockgroups, nblockgroups,
8285  delstate->deltids);
8286 
8287  for (int b = 0; b < nblockgroups; b++)
8288  {
8289  IndexDeleteCounts *group = blockgroups + b;
8290  TM_IndexDelete *firstdtid = delstate->deltids + group->ifirsttid;
8291 
8292  memcpy(reordereddeltids + ncopied, firstdtid,
8293  sizeof(TM_IndexDelete) * group->ntids);
8294  ncopied += group->ntids;
8295  }
8296 
8297  /* Copy final grouped and sorted TIDs back into start of caller's array */
8298  memcpy(delstate->deltids, reordereddeltids,
8299  sizeof(TM_IndexDelete) * ncopied);
8300  delstate->ndeltids = ncopied;
8301 
8302  pfree(reordereddeltids);
8303  pfree(blockgroups);
8304 
8305  return nblocksfavorable;
8306 }
#define InvalidBlockNumber
Definition: block.h:33
static bool BlockNumberIsValid(BlockNumber blockNumber)
Definition: block.h:71
unsigned int uint32
Definition: c.h:506
#define Min(x, y)
Definition: c.h:1004
static int bottomup_nblocksfavorable(IndexDeleteCounts *blockgroups, int nblockgroups, TM_IndexDelete *deltids)
Definition: heapam.c:8078
static int bottomup_sort_and_shrink_cmp(const void *arg1, const void *arg2)
Definition: heapam.c:8121
int i
Definition: isn.c:73
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc(Size size)
Definition: mcxt.c:1317
static uint32 pg_nextpower2_32(uint32 num)
Definition: pg_bitutils.h:189
#define qsort(a, b, c, d)
Definition: port.h:449
int16 npromisingtids
Definition: heapam.c:199
TM_IndexStatus * status
Definition: tableam.h:255
TM_IndexDelete * deltids
Definition: tableam.h:254
bool promising
Definition: tableam.h:223

References Assert, b, BlockNumberIsValid(), TM_IndexDeleteOp::bottomup, BOTTOMUP_MAX_NBLOCKS, bottomup_nblocksfavorable(), bottomup_sort_and_shrink_cmp(), TM_IndexDeleteOp::deltids, i, TM_IndexDelete::id, IndexDeleteCounts::ifirsttid, InvalidBlockNumber, ItemPointerGetBlockNumber(), Min, TM_IndexDeleteOp::ndeltids, IndexDeleteCounts::npromisingtids, IndexDeleteCounts::ntids, palloc(), pfree(), pg_nextpower2_32(), TM_IndexStatus::promising, qsort, TM_IndexDeleteOp::status, and TM_IndexDelete::tid.

Referenced by heap_index_delete_tuples().

◆ bottomup_sort_and_shrink_cmp()

static int bottomup_sort_and_shrink_cmp ( const void *  arg1,
const void *  arg2 
)
static

Definition at line 8121 of file heapam.c.

8122 {
8123  const IndexDeleteCounts *group1 = (const IndexDeleteCounts *) arg1;
8124  const IndexDeleteCounts *group2 = (const IndexDeleteCounts *) arg2;
8125 
8126  /*
8127  * Most significant field is npromisingtids (which we invert the order of
8128  * so as to sort in desc order).
8129  *
8130  * Caller should have already normalized npromisingtids fields into
8131  * power-of-two values (buckets).
8132  */
8133  if (group1->npromisingtids > group2->npromisingtids)
8134  return -1;
8135  if (group1->npromisingtids < group2->npromisingtids)
8136  return 1;
8137 
8138  /*
8139  * Tiebreak: desc ntids sort order.
8140  *
8141  * We cannot expect power-of-two values for ntids fields. We should
8142  * behave as if they were already rounded up for us instead.
8143  */
8144  if (group1->ntids != group2->ntids)
8145  {
8146  uint32 ntids1 = pg_nextpower2_32((uint32) group1->ntids);
8147  uint32 ntids2 = pg_nextpower2_32((uint32) group2->ntids);
8148 
8149  if (ntids1 > ntids2)
8150  return -1;
8151  if (ntids1 < ntids2)
8152  return 1;
8153  }
8154 
8155  /*
8156  * Tiebreak: asc offset-into-deltids-for-block (offset to first TID for
8157  * block in deltids array) order.
8158  *
8159  * This is equivalent to sorting in ascending heap block number order
8160  * (among otherwise equal subsets of the array). This approach allows us
8161  * to avoid accessing the out-of-line TID. (We rely on the assumption
8162  * that the deltids array was sorted in ascending heap TID order when
8163  * these offsets to the first TID from each heap block group were formed.)
8164  */
8165  if (group1->ifirsttid > group2->ifirsttid)
8166  return 1;
8167  if (group1->ifirsttid < group2->ifirsttid)
8168  return -1;
8169 
8170  pg_unreachable();
8171 
8172  return 0;
8173 }
#define pg_unreachable()
Definition: c.h:296

References IndexDeleteCounts::ifirsttid, IndexDeleteCounts::npromisingtids, IndexDeleteCounts::ntids, pg_nextpower2_32(), and pg_unreachable.

Referenced by bottomup_sort_and_shrink().

◆ compute_infobits()

static uint8 compute_infobits ( uint16  infomask,
uint16  infomask2 
)
static

Definition at line 2638 of file heapam.c.

2639 {
2640  return
2641  ((infomask & HEAP_XMAX_IS_MULTI) != 0 ? XLHL_XMAX_IS_MULTI : 0) |
2642  ((infomask & HEAP_XMAX_LOCK_ONLY) != 0 ? XLHL_XMAX_LOCK_ONLY : 0) |
2643  ((infomask & HEAP_XMAX_EXCL_LOCK) != 0 ? XLHL_XMAX_EXCL_LOCK : 0) |
2644  /* note we ignore HEAP_XMAX_SHR_LOCK here */
2645  ((infomask & HEAP_XMAX_KEYSHR_LOCK) != 0 ? XLHL_XMAX_KEYSHR_LOCK : 0) |
2646  ((infomask2 & HEAP_KEYS_UPDATED) != 0 ?
2647  XLHL_KEYS_UPDATED : 0);
2648 }
#define XLHL_XMAX_KEYSHR_LOCK
Definition: heapam_xlog.h:388
#define XLHL_XMAX_IS_MULTI
Definition: heapam_xlog.h:385
#define XLHL_XMAX_LOCK_ONLY
Definition: heapam_xlog.h:386
#define XLHL_XMAX_EXCL_LOCK
Definition: heapam_xlog.h:387
#define XLHL_KEYS_UPDATED
Definition: heapam_xlog.h:389
#define HEAP_KEYS_UPDATED
Definition: htup_details.h:275
#define HEAP_XMAX_LOCK_ONLY
Definition: htup_details.h:197
#define HEAP_XMAX_IS_MULTI
Definition: htup_details.h:209
#define HEAP_XMAX_EXCL_LOCK
Definition: htup_details.h:196
#define HEAP_XMAX_KEYSHR_LOCK
Definition: htup_details.h:194

References HEAP_KEYS_UPDATED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, XLHL_KEYS_UPDATED, XLHL_XMAX_EXCL_LOCK, XLHL_XMAX_IS_MULTI, XLHL_XMAX_KEYSHR_LOCK, and XLHL_XMAX_LOCK_ONLY.

Referenced by heap_abort_speculative(), heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), and log_heap_update().

◆ compute_new_xmax_infomask()

static void compute_new_xmax_infomask ( TransactionId  xmax,
uint16  old_infomask,
uint16  old_infomask2,
TransactionId  add_to_xmax,
LockTupleMode  mode,
bool  is_update,
TransactionId result_xmax,
uint16 result_infomask,
uint16 result_infomask2 
)
static

Definition at line 5057 of file heapam.c.

5062 {
5063  TransactionId new_xmax;
5064  uint16 new_infomask,
5065  new_infomask2;
5066 
5068 
5069 l5:
5070  new_infomask = 0;
5071  new_infomask2 = 0;
5072  if (old_infomask & HEAP_XMAX_INVALID)
5073  {
5074  /*
5075  * No previous locker; we just insert our own TransactionId.
5076  *
5077  * Note that it's critical that this case be the first one checked,
5078  * because there are several blocks below that come back to this one
5079  * to implement certain optimizations; old_infomask might contain
5080  * other dirty bits in those cases, but we don't really care.
5081  */
5082  if (is_update)
5083  {
5084  new_xmax = add_to_xmax;
5085  if (mode == LockTupleExclusive)
5086  new_infomask2 |= HEAP_KEYS_UPDATED;
5087  }
5088  else
5089  {
5090  new_infomask |= HEAP_XMAX_LOCK_ONLY;
5091  switch (mode)
5092  {
5093  case LockTupleKeyShare:
5094  new_xmax = add_to_xmax;
5095  new_infomask |= HEAP_XMAX_KEYSHR_LOCK;
5096  break;
5097  case LockTupleShare:
5098  new_xmax = add_to_xmax;
5099  new_infomask |= HEAP_XMAX_SHR_LOCK;
5100  break;
5102  new_xmax = add_to_xmax;
5103  new_infomask |= HEAP_XMAX_EXCL_LOCK;
5104  break;
5105  case LockTupleExclusive:
5106  new_xmax = add_to_xmax;
5107  new_infomask |= HEAP_XMAX_EXCL_LOCK;
5108  new_infomask2 |= HEAP_KEYS_UPDATED;
5109  break;
5110  default:
5111  new_xmax = InvalidTransactionId; /* silence compiler */
5112  elog(ERROR, "invalid lock mode");
5113  }
5114  }
5115  }
5116  else if (old_infomask & HEAP_XMAX_IS_MULTI)
5117  {
5118  MultiXactStatus new_status;
5119 
5120  /*
5121  * Currently we don't allow XMAX_COMMITTED to be set for multis, so
5122  * cross-check.
5123  */
5124  Assert(!(old_infomask & HEAP_XMAX_COMMITTED));
5125 
5126  /*
5127  * A multixact together with LOCK_ONLY set but neither lock bit set
5128  * (i.e. a pg_upgraded share locked tuple) cannot possibly be running
5129  * anymore. This check is critical for databases upgraded by
5130  * pg_upgrade; both MultiXactIdIsRunning and MultiXactIdExpand assume
5131  * that such multis are never passed.
5132  */
5133  if (HEAP_LOCKED_UPGRADED(old_infomask))
5134  {
5135  old_infomask &= ~HEAP_XMAX_IS_MULTI;
5136  old_infomask |= HEAP_XMAX_INVALID;
5137  goto l5;
5138  }
5139 
5140  /*
5141  * If the XMAX is already a MultiXactId, then we need to expand it to
5142  * include add_to_xmax; but if all the members were lockers and are
5143  * all gone, we can do away with the IS_MULTI bit and just set
5144  * add_to_xmax as the only locker/updater. If all lockers are gone
5145  * and we have an updater that aborted, we can also do without a
5146  * multi.
5147  *
5148  * The cost of doing GetMultiXactIdMembers would be paid by
5149  * MultiXactIdExpand if we weren't to do this, so this check is not
5150  * incurring extra work anyhow.
5151  */
5152  if (!MultiXactIdIsRunning(xmax, HEAP_XMAX_IS_LOCKED_ONLY(old_infomask)))
5153  {
5154  if (HEAP_XMAX_IS_LOCKED_ONLY(old_infomask) ||
5156  old_infomask)))
5157  {
5158  /*
5159  * Reset these bits and restart; otherwise fall through to
5160  * create a new multi below.
5161  */
5162  old_infomask &= ~HEAP_XMAX_IS_MULTI;
5163  old_infomask |= HEAP_XMAX_INVALID;
5164  goto l5;
5165  }
5166  }
5167 
5168  new_status = get_mxact_status_for_lock(mode, is_update);
5169 
5170  new_xmax = MultiXactIdExpand((MultiXactId) xmax, add_to_xmax,
5171  new_status);
5172  GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5173  }
5174  else if (old_infomask & HEAP_XMAX_COMMITTED)
5175  {
5176  /*
5177  * It's a committed update, so we need to preserve him as updater of
5178  * the tuple.
5179  */
5180  MultiXactStatus status;
5181  MultiXactStatus new_status;
5182 
5183  if (old_infomask2 & HEAP_KEYS_UPDATED)
5184  status = MultiXactStatusUpdate;
5185  else
5186  status = MultiXactStatusNoKeyUpdate;
5187 
5188  new_status = get_mxact_status_for_lock(mode, is_update);
5189 
5190  /*
5191  * since it's not running, it's obviously impossible for the old
5192  * updater to be identical to the current one, so we need not check
5193  * for that case as we do in the block above.
5194  */
5195  new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5196  GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5197  }
5198  else if (TransactionIdIsInProgress(xmax))
5199  {
5200  /*
5201  * If the XMAX is a valid, in-progress TransactionId, then we need to
5202  * create a new MultiXactId that includes both the old locker or
5203  * updater and our own TransactionId.
5204  */
5205  MultiXactStatus new_status;
5206  MultiXactStatus old_status;
5207  LockTupleMode old_mode;
5208 
5209  if (HEAP_XMAX_IS_LOCKED_ONLY(old_infomask))
5210  {
5211  if (HEAP_XMAX_IS_KEYSHR_LOCKED(old_infomask))
5212  old_status = MultiXactStatusForKeyShare;
5213  else if (HEAP_XMAX_IS_SHR_LOCKED(old_infomask))
5214  old_status = MultiXactStatusForShare;
5215  else if (HEAP_XMAX_IS_EXCL_LOCKED(old_infomask))
5216  {
5217  if (old_infomask2 & HEAP_KEYS_UPDATED)
5218  old_status = MultiXactStatusForUpdate;
5219  else
5220  old_status = MultiXactStatusForNoKeyUpdate;
5221  }
5222  else
5223  {
5224  /*
5225  * LOCK_ONLY can be present alone only when a page has been
5226  * upgraded by pg_upgrade. But in that case,
5227  * TransactionIdIsInProgress() should have returned false. We
5228  * assume it's no longer locked in this case.
5229  */
5230  elog(WARNING, "LOCK_ONLY found for Xid in progress %u", xmax);
5231  old_infomask |= HEAP_XMAX_INVALID;
5232  old_infomask &= ~HEAP_XMAX_LOCK_ONLY;
5233  goto l5;
5234  }
5235  }
5236  else
5237  {
5238  /* it's an update, but which kind? */
5239  if (old_infomask2 & HEAP_KEYS_UPDATED)
5240  old_status = MultiXactStatusUpdate;
5241  else
5242  old_status = MultiXactStatusNoKeyUpdate;
5243  }
5244 
5245  old_mode = TUPLOCK_from_mxstatus(old_status);
5246 
5247  /*
5248  * If the lock to be acquired is for the same TransactionId as the
5249  * existing lock, there's an optimization possible: consider only the
5250  * strongest of both locks as the only one present, and restart.
5251  */
5252  if (xmax == add_to_xmax)
5253  {
5254  /*
5255  * Note that it's not possible for the original tuple to be
5256  * updated: we wouldn't be here because the tuple would have been
5257  * invisible and we wouldn't try to update it. As a subtlety,
5258  * this code can also run when traversing an update chain to lock
5259  * future versions of a tuple. But we wouldn't be here either,
5260  * because the add_to_xmax would be different from the original
5261  * updater.
5262  */
5263  Assert(HEAP_XMAX_IS_LOCKED_ONLY(old_infomask));
5264 
5265  /* acquire the strongest of both */
5266  if (mode < old_mode)
5267  mode = old_mode;
5268  /* mustn't touch is_update */
5269 
5270  old_infomask |= HEAP_XMAX_INVALID;
5271  goto l5;
5272  }
5273 
5274  /* otherwise, just fall back to creating a new multixact */
5275  new_status = get_mxact_status_for_lock(mode, is_update);
5276  new_xmax = MultiXactIdCreate(xmax, old_status,
5277  add_to_xmax, new_status);
5278  GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5279  }
5280  else if (!HEAP_XMAX_IS_LOCKED_ONLY(old_infomask) &&
5281  TransactionIdDidCommit(xmax))
5282  {
5283  /*
5284  * It's a committed update, so we gotta preserve him as updater of the
5285  * tuple.
5286  */
5287  MultiXactStatus status;
5288  MultiXactStatus new_status;
5289 
5290  if (old_infomask2 & HEAP_KEYS_UPDATED)
5291  status = MultiXactStatusUpdate;
5292  else
5293  status = MultiXactStatusNoKeyUpdate;
5294 
5295  new_status = get_mxact_status_for_lock(mode, is_update);
5296 
5297  /*
5298  * since it's not running, it's obviously impossible for the old
5299  * updater to be identical to the current one, so we need not check
5300  * for that case as we do in the block above.
5301  */
5302  new_xmax = MultiXactIdCreate(xmax, status, add_to_xmax, new_status);
5303  GetMultiXactIdHintBits(new_xmax, &new_infomask, &new_infomask2);
5304  }
5305  else
5306  {
5307  /*
5308  * Can get here iff the locking/updating transaction was running when
5309  * the infomask was extracted from the tuple, but finished before
5310  * TransactionIdIsInProgress got to run. Deal with it as if there was
5311  * no locker at all in the first place.
5312  */
5313  old_infomask |= HEAP_XMAX_INVALID;
5314  goto l5;
5315  }
5316 
5317  *result_infomask = new_infomask;
5318  *result_infomask2 = new_infomask2;
5319  *result_xmax = new_xmax;
5320 }
unsigned short uint16
Definition: c.h:505
TransactionId MultiXactId
Definition: c.h:662
uint32 TransactionId
Definition: c.h:652
#define WARNING
Definition: elog.h:36
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
static void GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask, uint16 *new_infomask2)
Definition: heapam.c:6966
#define TUPLOCK_from_mxstatus(status)
Definition: heapam.c:219
static TransactionId MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
Definition: heapam.c:7047
static MultiXactStatus get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
Definition: heapam.c:4262
#define HEAP_XMAX_IS_EXCL_LOCKED(infomask)
Definition: htup_details.h:261
#define HEAP_XMAX_SHR_LOCK
Definition: htup_details.h:200
#define HEAP_XMAX_IS_LOCKED_ONLY(infomask)
Definition: htup_details.h:227
#define HEAP_XMAX_IS_KEYSHR_LOCKED(infomask)
Definition: htup_details.h:263
#define HEAP_XMAX_COMMITTED
Definition: htup_details.h:207
#define HEAP_XMAX_INVALID
Definition: htup_details.h:208
#define HEAP_XMAX_IS_SHR_LOCKED(infomask)
Definition: htup_details.h:259
#define HEAP_LOCKED_UPGRADED(infomask)
Definition: htup_details.h:249
LockTupleMode
Definition: lockoptions.h:50
@ LockTupleExclusive
Definition: lockoptions.h:58
@ LockTupleNoKeyExclusive
Definition: lockoptions.h:56
@ LockTupleShare
Definition: lockoptions.h:54
@ LockTupleKeyShare
Definition: lockoptions.h:52
MultiXactId MultiXactIdExpand(MultiXactId multi, TransactionId xid, MultiXactStatus status)
Definition: multixact.c:486
bool MultiXactIdIsRunning(MultiXactId multi, bool isLockOnly)
Definition: multixact.c:598
MultiXactId MultiXactIdCreate(TransactionId xid1, MultiXactStatus status1, TransactionId xid2, MultiXactStatus status2)
Definition: multixact.c:433
MultiXactStatus
Definition: multixact.h:38
@ MultiXactStatusForShare
Definition: multixact.h:40
@ MultiXactStatusForNoKeyUpdate
Definition: multixact.h:41
@ MultiXactStatusNoKeyUpdate
Definition: multixact.h:44
@ MultiXactStatusUpdate
Definition: multixact.h:46
@ MultiXactStatusForUpdate
Definition: multixact.h:42
@ MultiXactStatusForKeyShare
Definition: multixact.h:39
static PgChecksumMode mode
Definition: pg_checksums.c:56
bool TransactionIdIsInProgress(TransactionId xid)
Definition: procarray.c:1402
bool TransactionIdDidCommit(TransactionId transactionId)
Definition: transam.c:126
#define InvalidTransactionId
Definition: transam.h:31
bool TransactionIdIsCurrentTransactionId(TransactionId xid)
Definition: xact.c:939

References Assert, elog, ERROR, get_mxact_status_for_lock(), GetMultiXactIdHintBits(), HEAP_KEYS_UPDATED, HEAP_LOCKED_UPGRADED, HEAP_XMAX_COMMITTED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_INVALID, HEAP_XMAX_IS_EXCL_LOCKED, HEAP_XMAX_IS_KEYSHR_LOCKED, HEAP_XMAX_IS_LOCKED_ONLY, HEAP_XMAX_IS_MULTI, HEAP_XMAX_IS_SHR_LOCKED, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HEAP_XMAX_SHR_LOCK, InvalidTransactionId, LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, mode, MultiXactIdCreate(), MultiXactIdExpand(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TUPLOCK_from_mxstatus, and WARNING.

Referenced by heap_delete(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), and heap_update().

◆ ConditionalMultiXactIdWait()

static bool ConditionalMultiXactIdWait ( MultiXactId  multi,
MultiXactStatus  status,
uint16  infomask,
Relation  rel,
int *  remaining 
)
static

Definition at line 7314 of file heapam.c.

7316 {
7317  return Do_MultiXactIdWait(multi, status, infomask, true,
7318  rel, NULL, XLTW_None, remaining);
7319 }
static bool Do_MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, bool nowait, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
Definition: heapam.c:7214
int remaining
Definition: informix.c:673
@ XLTW_None
Definition: lmgr.h:26

References Do_MultiXactIdWait(), remaining, and XLTW_None.

Referenced by heap_lock_tuple().

◆ Do_MultiXactIdWait()

static bool Do_MultiXactIdWait ( MultiXactId  multi,
MultiXactStatus  status,
uint16  infomask,
bool  nowait,
Relation  rel,
ItemPointer  ctid,
XLTW_Oper  oper,
int *  remaining 
)
static

Definition at line 7214 of file heapam.c.

7218 {
7219  bool result = true;
7220  MultiXactMember *members;
7221  int nmembers;
7222  int remain = 0;
7223 
7224  /* for pre-pg_upgrade tuples, no need to sleep at all */
7225  nmembers = HEAP_LOCKED_UPGRADED(infomask) ? -1 :
7226  GetMultiXactIdMembers(multi, &members, false,
7227  HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7228 
7229  if (nmembers >= 0)
7230  {
7231  int i;
7232 
7233  for (i = 0; i < nmembers; i++)
7234  {
7235  TransactionId memxid = members[i].xid;
7236  MultiXactStatus memstatus = members[i].status;
7237 
7239  {
7240  remain++;
7241  continue;
7242  }
7243 
7245  LOCKMODE_from_mxstatus(status)))
7246  {
7247  if (remaining && TransactionIdIsInProgress(memxid))
7248  remain++;
7249  continue;
7250  }
7251 
7252  /*
7253  * This member conflicts with our multi, so we have to sleep (or
7254  * return failure, if asked to avoid waiting.)
7255  *
7256  * Note that we don't set up an error context callback ourselves,
7257  * but instead we pass the info down to XactLockTableWait. This
7258  * might seem a bit wasteful because the context is set up and
7259  * tore down for each member of the multixact, but in reality it
7260  * should be barely noticeable, and it avoids duplicate code.
7261  */
7262  if (nowait)
7263  {
7264  result = ConditionalXactLockTableWait(memxid);
7265  if (!result)
7266  break;
7267  }
7268  else
7269  XactLockTableWait(memxid, rel, ctid, oper);
7270  }
7271 
7272  pfree(members);
7273  }
7274 
7275  if (remaining)
7276  *remaining = remain;
7277 
7278  return result;
7279 }
#define LOCKMODE_from_mxstatus(status)
Definition: heapam.c:160
void XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)
Definition: lmgr.c:657
bool ConditionalXactLockTableWait(TransactionId xid)
Definition: lmgr.c:730
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
Definition: lock.c:570
int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **members, bool from_pgupgrade, bool isLockOnly)
Definition: multixact.c:1293
Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)
Definition: parse_oper.c:370
TransactionId xid
Definition: multixact.h:58
MultiXactStatus status
Definition: multixact.h:59

References ConditionalXactLockTableWait(), DoLockModesConflict(), GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED, HEAP_XMAX_IS_LOCKED_ONLY, i, LOCKMODE_from_mxstatus, oper(), pfree(), remaining, MultiXactMember::status, TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), XactLockTableWait(), and MultiXactMember::xid.

Referenced by ConditionalMultiXactIdWait(), and MultiXactIdWait().

◆ DoesMultiXactIdConflict()

static bool DoesMultiXactIdConflict ( MultiXactId  multi,
uint16  infomask,
LockTupleMode  lockmode,
bool current_is_member 
)
static

Definition at line 7115 of file heapam.c.

7117 {
7118  int nmembers;
7119  MultiXactMember *members;
7120  bool result = false;
7121  LOCKMODE wanted = tupleLockExtraInfo[lockmode].hwlock;
7122 
7123  if (HEAP_LOCKED_UPGRADED(infomask))
7124  return false;
7125 
7126  nmembers = GetMultiXactIdMembers(multi, &members, false,
7127  HEAP_XMAX_IS_LOCKED_ONLY(infomask));
7128  if (nmembers >= 0)
7129  {
7130  int i;
7131 
7132  for (i = 0; i < nmembers; i++)
7133  {
7134  TransactionId memxid;
7135  LOCKMODE memlockmode;
7136 
7137  if (result && (current_is_member == NULL || *current_is_member))
7138  break;
7139 
7140  memlockmode = LOCKMODE_from_mxstatus(members[i].status);
7141 
7142  /* ignore members from current xact (but track their presence) */
7143  memxid = members[i].xid;
7145  {
7146  if (current_is_member != NULL)
7147  *current_is_member = true;
7148  continue;
7149  }
7150  else if (result)
7151  continue;
7152 
7153  /* ignore members that don't conflict with the lock we want */
7154  if (!DoLockModesConflict(memlockmode, wanted))
7155  continue;
7156 
7157  if (ISUPDATE_from_mxstatus(members[i].status))
7158  {
7159  /* ignore aborted updaters */
7160  if (TransactionIdDidAbort(memxid))
7161  continue;
7162  }
7163  else
7164  {
7165  /* ignore lockers-only that are no longer in progress */
7166  if (!TransactionIdIsInProgress(memxid))
7167  continue;
7168  }
7169 
7170  /*
7171  * Whatever remains are either live lockers that conflict with our
7172  * wanted lock, and updaters that are not aborted. Those conflict
7173  * with what we want. Set up to return true, but keep going to
7174  * look for the current transaction among the multixact members,
7175  * if needed.
7176  */
7177  result = true;
7178  }
7179  pfree(members);
7180  }
7181 
7182  return result;
7183 }
static const struct @15 tupleLockExtraInfo[MaxLockTupleMode+1]
int LOCKMODE
Definition: lockdefs.h:26
#define ISUPDATE_from_mxstatus(status)
Definition: multixact.h:52
bool TransactionIdDidAbort(TransactionId transactionId)
Definition: transam.c:188

References DoLockModesConflict(), GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED, HEAP_XMAX_IS_LOCKED_ONLY, i, ISUPDATE_from_mxstatus, LOCKMODE_from_mxstatus, pfree(), TransactionIdDidAbort(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), tupleLockExtraInfo, and MultiXactMember::xid.

Referenced by heap_delete(), heap_lock_tuple(), and heap_update().

◆ ExtractReplicaIdentity()

static HeapTuple ExtractReplicaIdentity ( Relation  relation,
HeapTuple  tp,
bool  key_required,
bool copy 
)
static

Definition at line 8660 of file heapam.c.

8662 {
8663  TupleDesc desc = RelationGetDescr(relation);
8664  char replident = relation->rd_rel->relreplident;
8665  Bitmapset *idattrs;
8666  HeapTuple key_tuple;
8667  bool nulls[MaxHeapAttributeNumber];
8669 
8670  *copy = false;
8671 
8672  if (!RelationIsLogicallyLogged(relation))
8673  return NULL;
8674 
8675  if (replident == REPLICA_IDENTITY_NOTHING)
8676  return NULL;
8677 
8678  if (replident == REPLICA_IDENTITY_FULL)
8679  {
8680  /*
8681  * When logging the entire old tuple, it very well could contain
8682  * toasted columns. If so, force them to be inlined.
8683  */
8684  if (HeapTupleHasExternal(tp))
8685  {
8686  *copy = true;
8687  tp = toast_flatten_tuple(tp, desc);
8688  }
8689  return tp;
8690  }
8691 
8692  /* if the key isn't required and we're only logging the key, we're done */
8693  if (!key_required)
8694  return NULL;
8695 
8696  /* find out the replica identity columns */
8697  idattrs = RelationGetIndexAttrBitmap(relation,
8699 
8700  /*
8701  * If there's no defined replica identity columns, treat as !key_required.
8702  * (This case should not be reachable from heap_update, since that should
8703  * calculate key_required accurately. But heap_delete just passes
8704  * constant true for key_required, so we can hit this case in deletes.)
8705  */
8706  if (bms_is_empty(idattrs))
8707  return NULL;
8708 
8709  /*
8710  * Construct a new tuple containing only the replica identity columns,
8711  * with nulls elsewhere. While we're at it, assert that the replica
8712  * identity columns aren't null.
8713  */
8714  heap_deform_tuple(tp, desc, values, nulls);
8715 
8716  for (int i = 0; i < desc->natts; i++)
8717  {
8719  idattrs))
8720  Assert(!nulls[i]);
8721  else
8722  nulls[i] = true;
8723  }
8724 
8725  key_tuple = heap_form_tuple(desc, values, nulls);
8726  *copy = true;
8727 
8728  bms_free(idattrs);
8729 
8730  /*
8731  * If the tuple, which by here only contains indexed columns, still has
8732  * toasted columns, force them to be inlined. This is somewhat unlikely
8733  * since there's limits on the size of indexed columns, so we don't
8734  * duplicate toast_flatten_tuple()s functionality in the above loop over
8735  * the indexed columns, even if it would be more efficient.
8736  */
8737  if (HeapTupleHasExternal(key_tuple))
8738  {
8739  HeapTuple oldtup = key_tuple;
8740 
8741  key_tuple = toast_flatten_tuple(oldtup, desc);
8742  heap_freetuple(oldtup);
8743  }
8744 
8745  return key_tuple;
8746 }
void bms_free(Bitmapset *a)
Definition: bitmapset.c:239
bool bms_is_member(int x, const Bitmapset *a)
Definition: bitmapset.c:510
#define bms_is_empty(a)
Definition: bitmapset.h:118
static Datum values[MAXATTR]
Definition: bootstrap.c:152
HeapTuple toast_flatten_tuple(HeapTuple tup, TupleDesc tupleDesc)
Definition: heaptoast.c:350
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition: heaptuple.c:1116
void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc, Datum *values, bool *isnull)
Definition: heaptuple.c:1345
void heap_freetuple(HeapTuple htup)
Definition: heaptuple.c:1434
#define HeapTupleHasExternal(tuple)
Definition: htup_details.h:671
#define MaxHeapAttributeNumber
Definition: htup_details.h:48
uintptr_t Datum
Definition: postgres.h:64
#define RelationIsLogicallyLogged(relation)
Definition: rel.h:701
#define RelationGetDescr(relation)
Definition: rel.h:531
Bitmapset * RelationGetIndexAttrBitmap(Relation relation, IndexAttrBitmapKind attrKind)
Definition: relcache.c:5244
@ INDEX_ATTR_BITMAP_IDENTITY_KEY
Definition: relcache.h:63
Form_pg_class rd_rel
Definition: rel.h:111
#define FirstLowInvalidHeapAttributeNumber
Definition: sysattr.h:27

References Assert, bms_free(), bms_is_empty, bms_is_member(), FirstLowInvalidHeapAttributeNumber, heap_deform_tuple(), heap_form_tuple(), heap_freetuple(), HeapTupleHasExternal, i, INDEX_ATTR_BITMAP_IDENTITY_KEY, MaxHeapAttributeNumber, TupleDescData::natts, RelationData::rd_rel, RelationGetDescr, RelationGetIndexAttrBitmap(), RelationIsLogicallyLogged, toast_flatten_tuple(), and values.

Referenced by heap_delete(), and heap_update().

◆ fix_infomask_from_infobits()

static void fix_infomask_from_infobits ( uint8  infobits,
uint16 infomask,
uint16 infomask2 
)
static

Definition at line 9039 of file heapam.c.

9040 {
9041  *infomask &= ~(HEAP_XMAX_IS_MULTI | HEAP_XMAX_LOCK_ONLY |
9043  *infomask2 &= ~HEAP_KEYS_UPDATED;
9044 
9045  if (infobits & XLHL_XMAX_IS_MULTI)
9046  *infomask |= HEAP_XMAX_IS_MULTI;
9047  if (infobits & XLHL_XMAX_LOCK_ONLY)
9048  *infomask |= HEAP_XMAX_LOCK_ONLY;
9049  if (infobits & XLHL_XMAX_EXCL_LOCK)
9050  *infomask |= HEAP_XMAX_EXCL_LOCK;
9051  /* note HEAP_XMAX_SHR_LOCK isn't considered here */
9052  if (infobits & XLHL_XMAX_KEYSHR_LOCK)
9053  *infomask |= HEAP_XMAX_KEYSHR_LOCK;
9054 
9055  if (infobits & XLHL_KEYS_UPDATED)
9056  *infomask2 |= HEAP_KEYS_UPDATED;
9057 }

References HEAP_KEYS_UPDATED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, XLHL_KEYS_UPDATED, XLHL_XMAX_EXCL_LOCK, XLHL_XMAX_IS_MULTI, XLHL_XMAX_KEYSHR_LOCK, and XLHL_XMAX_LOCK_ONLY.

Referenced by heap_xlog_delete(), heap_xlog_lock(), heap_xlog_lock_updated(), and heap_xlog_update().

◆ FreeBulkInsertState()

void FreeBulkInsertState ( BulkInsertState  bistate)

Definition at line 1944 of file heapam.c.

1945 {
1946  if (bistate->current_buf != InvalidBuffer)
1947  ReleaseBuffer(bistate->current_buf);
1948  FreeAccessStrategy(bistate->strategy);
1949  pfree(bistate);
1950 }
#define InvalidBuffer
Definition: buf.h:25
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4896
void FreeAccessStrategy(BufferAccessStrategy strategy)
Definition: freelist.c:681
BufferAccessStrategy strategy
Definition: hio.h:31
Buffer current_buf
Definition: hio.h:32

References BulkInsertStateData::current_buf, FreeAccessStrategy(), InvalidBuffer, pfree(), ReleaseBuffer(), and BulkInsertStateData::strategy.

Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferCleanup(), deleteSplitPartitionContext(), intorel_shutdown(), moveMergedTablesRows(), and transientrel_shutdown().

◆ FreezeMultiXactId()

static TransactionId FreezeMultiXactId ( MultiXactId  multi,
uint16  t_infomask,
const struct VacuumCutoffs cutoffs,
uint16 flags,
HeapPageFreeze pagefrz 
)
static

Definition at line 6200 of file heapam.c.

6203 {
6204  TransactionId newxmax;
6205  MultiXactMember *members;
6206  int nmembers;
6207  bool need_replace;
6208  int nnewmembers;
6209  MultiXactMember *newmembers;
6210  bool has_lockers;
6211  TransactionId update_xid;
6212  bool update_committed;
6213  TransactionId FreezePageRelfrozenXid;
6214 
6215  *flags = 0;
6216 
6217  /* We should only be called in Multis */
6218  Assert(t_infomask & HEAP_XMAX_IS_MULTI);
6219 
6220  if (!MultiXactIdIsValid(multi) ||
6221  HEAP_LOCKED_UPGRADED(t_infomask))
6222  {
6223  *flags |= FRM_INVALIDATE_XMAX;
6224  pagefrz->freeze_required = true;
6225  return InvalidTransactionId;
6226  }
6227  else if (MultiXactIdPrecedes(multi, cutoffs->relminmxid))
6228  ereport(ERROR,
6230  errmsg_internal("found multixact %u from before relminmxid %u",
6231  multi, cutoffs->relminmxid)));
6232  else if (MultiXactIdPrecedes(multi, cutoffs->OldestMxact))
6233  {
6234  TransactionId update_xact;
6235 
6236  /*
6237  * This old multi cannot possibly have members still running, but
6238  * verify just in case. If it was a locker only, it can be removed
6239  * without any further consideration; but if it contained an update,
6240  * we might need to preserve it.
6241  */
6242  if (MultiXactIdIsRunning(multi,
6243  HEAP_XMAX_IS_LOCKED_ONLY(t_infomask)))
6244  ereport(ERROR,
6246  errmsg_internal("multixact %u from before multi freeze cutoff %u found to be still running",
6247  multi, cutoffs->OldestMxact)));
6248 
6249  if (HEAP_XMAX_IS_LOCKED_ONLY(t_infomask))
6250  {
6251  *flags |= FRM_INVALIDATE_XMAX;
6252  pagefrz->freeze_required = true;
6253  return InvalidTransactionId;
6254  }
6255 
6256  /* replace multi with single XID for its updater? */
6257  update_xact = MultiXactIdGetUpdateXid(multi, t_infomask);
6258  if (TransactionIdPrecedes(update_xact, cutoffs->relfrozenxid))
6259  ereport(ERROR,
6261  errmsg_internal("multixact %u contains update XID %u from before relfrozenxid %u",
6262  multi, update_xact,
6263  cutoffs->relfrozenxid)));
6264  else if (TransactionIdPrecedes(update_xact, cutoffs->OldestXmin))
6265  {
6266  /*
6267  * Updater XID has to have aborted (otherwise the tuple would have
6268  * been pruned away instead, since updater XID is < OldestXmin).
6269  * Just remove xmax.
6270  */
6271  if (TransactionIdDidCommit(update_xact))
6272  ereport(ERROR,
6274  errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
6275  multi, update_xact,
6276  cutoffs->OldestXmin)));
6277  *flags |= FRM_INVALIDATE_XMAX;
6278  pagefrz->freeze_required = true;
6279  return InvalidTransactionId;
6280  }
6281 
6282  /* Have to keep updater XID as new xmax */
6283  *flags |= FRM_RETURN_IS_XID;
6284  pagefrz->freeze_required = true;
6285  return update_xact;
6286  }
6287 
6288  /*
6289  * Some member(s) of this Multi may be below FreezeLimit xid cutoff, so we
6290  * need to walk the whole members array to figure out what to do, if
6291  * anything.
6292  */
6293  nmembers =
6294  GetMultiXactIdMembers(multi, &members, false,
6295  HEAP_XMAX_IS_LOCKED_ONLY(t_infomask));
6296  if (nmembers <= 0)
6297  {
6298  /* Nothing worth keeping */
6299  *flags |= FRM_INVALIDATE_XMAX;
6300  pagefrz->freeze_required = true;
6301  return InvalidTransactionId;
6302  }
6303 
6304  /*
6305  * The FRM_NOOP case is the only case where we might need to ratchet back
6306  * FreezePageRelfrozenXid or FreezePageRelminMxid. It is also the only
6307  * case where our caller might ratchet back its NoFreezePageRelfrozenXid
6308  * or NoFreezePageRelminMxid "no freeze" trackers to deal with a multi.
6309  * FRM_NOOP handling should result in the NewRelfrozenXid/NewRelminMxid
6310  * trackers managed by VACUUM being ratcheting back by xmax to the degree
6311  * required to make it safe to leave xmax undisturbed, independent of
6312  * whether or not page freezing is triggered somewhere else.
6313  *
6314  * Our policy is to force freezing in every case other than FRM_NOOP,
6315  * which obviates the need to maintain either set of trackers, anywhere.
6316  * Every other case will reliably execute a freeze plan for xmax that
6317  * either replaces xmax with an XID/MXID >= OldestXmin/OldestMxact, or
6318  * sets xmax to an InvalidTransactionId XID, rendering xmax fully frozen.
6319  * (VACUUM's NewRelfrozenXid/NewRelminMxid trackers are initialized with
6320  * OldestXmin/OldestMxact, so later values never need to be tracked here.)
6321  */
6322  need_replace = false;
6323  FreezePageRelfrozenXid = pagefrz->FreezePageRelfrozenXid;
6324  for (int i = 0; i < nmembers; i++)
6325  {
6326  TransactionId xid = members[i].xid;
6327 
6328  Assert(!TransactionIdPrecedes(xid, cutoffs->relfrozenxid));
6329 
6330  if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
6331  {
6332  /* Can't violate the FreezeLimit postcondition */
6333  need_replace = true;
6334  break;
6335  }
6336  if (TransactionIdPrecedes(xid, FreezePageRelfrozenXid))
6337  FreezePageRelfrozenXid = xid;
6338  }
6339 
6340  /* Can't violate the MultiXactCutoff postcondition, either */
6341  if (!need_replace)
6342  need_replace = MultiXactIdPrecedes(multi, cutoffs->MultiXactCutoff);
6343 
6344  if (!need_replace)
6345  {
6346  /*
6347  * vacuumlazy.c might ratchet back NewRelminMxid, NewRelfrozenXid, or
6348  * both together to make it safe to retain this particular multi after
6349  * freezing its page
6350  */
6351  *flags |= FRM_NOOP;
6352  pagefrz->FreezePageRelfrozenXid = FreezePageRelfrozenXid;
6353  if (MultiXactIdPrecedes(multi, pagefrz->FreezePageRelminMxid))
6354  pagefrz->FreezePageRelminMxid = multi;
6355  pfree(members);
6356  return multi;
6357  }
6358 
6359  /*
6360  * Do a more thorough second pass over the multi to figure out which
6361  * member XIDs actually need to be kept. Checking the precise status of
6362  * individual members might even show that we don't need to keep anything.
6363  * That is quite possible even though the Multi must be >= OldestMxact,
6364  * since our second pass only keeps member XIDs when it's truly necessary;
6365  * even member XIDs >= OldestXmin often won't be kept by second pass.
6366  */
6367  nnewmembers = 0;
6368  newmembers = palloc(sizeof(MultiXactMember) * nmembers);
6369  has_lockers = false;
6370  update_xid = InvalidTransactionId;
6371  update_committed = false;
6372 
6373  /*
6374  * Determine whether to keep each member xid, or to ignore it instead
6375  */
6376  for (int i = 0; i < nmembers; i++)
6377  {
6378  TransactionId xid = members[i].xid;
6379  MultiXactStatus mstatus = members[i].status;
6380 
6381  Assert(!TransactionIdPrecedes(xid, cutoffs->relfrozenxid));
6382 
6383  if (!ISUPDATE_from_mxstatus(mstatus))
6384  {
6385  /*
6386  * Locker XID (not updater XID). We only keep lockers that are
6387  * still running.
6388  */
6391  {
6392  if (TransactionIdPrecedes(xid, cutoffs->OldestXmin))
6393  ereport(ERROR,
6395  errmsg_internal("multixact %u contains running locker XID %u from before removable cutoff %u",
6396  multi, xid,
6397  cutoffs->OldestXmin)));
6398  newmembers[nnewmembers++] = members[i];
6399  has_lockers = true;
6400  }
6401 
6402  continue;
6403  }
6404 
6405  /*
6406  * Updater XID (not locker XID). Should we keep it?
6407  *
6408  * Since the tuple wasn't totally removed when vacuum pruned, the
6409  * update Xid cannot possibly be older than OldestXmin cutoff unless
6410  * the updater XID aborted. If the updater transaction is known
6411  * aborted or crashed then it's okay to ignore it, otherwise not.
6412  *
6413  * In any case the Multi should never contain two updaters, whatever
6414  * their individual commit status. Check for that first, in passing.
6415  */
6416  if (TransactionIdIsValid(update_xid))
6417  ereport(ERROR,
6419  errmsg_internal("multixact %u has two or more updating members",
6420  multi),
6421  errdetail_internal("First updater XID=%u second updater XID=%u.",
6422  update_xid, xid)));
6423 
6424  /*
6425  * As with all tuple visibility routines, it's critical to test
6426  * TransactionIdIsInProgress before TransactionIdDidCommit, because of
6427  * race conditions explained in detail in heapam_visibility.c.
6428  */
6431  update_xid = xid;
6432  else if (TransactionIdDidCommit(xid))
6433  {
6434  /*
6435  * The transaction committed, so we can tell caller to set
6436  * HEAP_XMAX_COMMITTED. (We can only do this because we know the
6437  * transaction is not running.)
6438  */
6439  update_committed = true;
6440  update_xid = xid;
6441  }
6442  else
6443  {
6444  /*
6445  * Not in progress, not committed -- must be aborted or crashed;
6446  * we can ignore it.
6447  */
6448  continue;
6449  }
6450 
6451  /*
6452  * We determined that updater must be kept -- add it to pending new
6453  * members list
6454  */
6455  if (TransactionIdPrecedes(xid, cutoffs->OldestXmin))
6456  ereport(ERROR,
6458  errmsg_internal("multixact %u contains committed update XID %u from before removable cutoff %u",
6459  multi, xid, cutoffs->OldestXmin)));
6460  newmembers[nnewmembers++] = members[i];
6461  }
6462 
6463  pfree(members);
6464 
6465  /*
6466  * Determine what to do with caller's multi based on information gathered
6467  * during our second pass
6468  */
6469  if (nnewmembers == 0)
6470  {
6471  /* Nothing worth keeping */
6472  *flags |= FRM_INVALIDATE_XMAX;
6473  newxmax = InvalidTransactionId;
6474  }
6475  else if (TransactionIdIsValid(update_xid) && !has_lockers)
6476  {
6477  /*
6478  * If there's a single member and it's an update, pass it back alone
6479  * without creating a new Multi. (XXX we could do this when there's a
6480  * single remaining locker, too, but that would complicate the API too
6481  * much; moreover, the case with the single updater is more
6482  * interesting, because those are longer-lived.)
6483  */
6484  Assert(nnewmembers == 1);
6485  *flags |= FRM_RETURN_IS_XID;
6486  if (update_committed)
6487  *flags |= FRM_MARK_COMMITTED;
6488  newxmax = update_xid;
6489  }
6490  else
6491  {
6492  /*
6493  * Create a new multixact with the surviving members of the previous
6494  * one, to set as new Xmax in the tuple
6495  */
6496  newxmax = MultiXactIdCreateFromMembers(nnewmembers, newmembers);
6497  *flags |= FRM_RETURN_IS_MULTI;
6498  }
6499 
6500  pfree(newmembers);
6501 
6502  pagefrz->freeze_required = true;
6503  return newxmax;
6504 }
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1155
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1228
int errcode(int sqlerrcode)
Definition: elog.c:855
#define ereport(elevel,...)
Definition: elog.h:149
#define FRM_RETURN_IS_XID
Definition: heapam.c:6149
#define FRM_MARK_COMMITTED
Definition: heapam.c:6151
#define FRM_NOOP
Definition: heapam.c:6147
#define FRM_RETURN_IS_MULTI
Definition: heapam.c:6150
#define FRM_INVALIDATE_XMAX
Definition: heapam.c:6148
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition: multixact.c:3308
MultiXactId MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
Definition: multixact.c:814
#define MultiXactIdIsValid(multi)
Definition: multixact.h:28
#define ERRCODE_DATA_CORRUPTED
Definition: pg_basebackup.c:41
TransactionId FreezePageRelfrozenXid
Definition: heapam.h:207
bool freeze_required
Definition: heapam.h:181
MultiXactId FreezePageRelminMxid
Definition: heapam.h:208
TransactionId FreezeLimit
Definition: vacuum.h:277
TransactionId OldestXmin
Definition: vacuum.h:267
TransactionId relfrozenxid
Definition: vacuum.h:251
MultiXactId relminmxid
Definition: vacuum.h:252
MultiXactId MultiXactCutoff
Definition: vacuum.h:278
MultiXactId OldestMxact
Definition: vacuum.h:268
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define TransactionIdIsValid(xid)
Definition: transam.h:41

References Assert, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errdetail_internal(), errmsg_internal(), ERROR, HeapPageFreeze::freeze_required, VacuumCutoffs::FreezeLimit, HeapPageFreeze::FreezePageRelfrozenXid, HeapPageFreeze::FreezePageRelminMxid, FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, FRM_NOOP, FRM_RETURN_IS_MULTI, FRM_RETURN_IS_XID, GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED, HEAP_XMAX_IS_LOCKED_ONLY, HEAP_XMAX_IS_MULTI, i, InvalidTransactionId, ISUPDATE_from_mxstatus, VacuumCutoffs::MultiXactCutoff, MultiXactIdCreateFromMembers(), MultiXactIdGetUpdateXid(), MultiXactIdIsRunning(), MultiXactIdIsValid, MultiXactIdPrecedes(), VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, palloc(), pfree(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, MultiXactMember::status, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), TransactionIdIsValid, TransactionIdPrecedes(), and MultiXactMember::xid.

Referenced by heap_prepare_freeze_tuple().

◆ get_mxact_status_for_lock()

static MultiXactStatus get_mxact_status_for_lock ( LockTupleMode  mode,
bool  is_update 
)
static

Definition at line 4262 of file heapam.c.

4263 {
4264  int retval;
4265 
4266  if (is_update)
4267  retval = tupleLockExtraInfo[mode].updstatus;
4268  else
4269  retval = tupleLockExtraInfo[mode].lockstatus;
4270 
4271  if (retval == -1)
4272  elog(ERROR, "invalid lock tuple mode %d/%s", mode,
4273  is_update ? "true" : "false");
4274 
4275  return (MultiXactStatus) retval;
4276 }

References elog, ERROR, mode, and tupleLockExtraInfo.

Referenced by compute_new_xmax_infomask(), heap_lock_tuple(), and test_lockmode_for_conflict().

◆ GetBulkInsertState()

BulkInsertState GetBulkInsertState ( void  )

Definition at line 1927 of file heapam.c.

1928 {
1929  BulkInsertState bistate;
1930 
1931  bistate = (BulkInsertState) palloc(sizeof(BulkInsertStateData));
1933  bistate->current_buf = InvalidBuffer;
1934  bistate->next_free = InvalidBlockNumber;
1935  bistate->last_free = InvalidBlockNumber;
1936  bistate->already_extended_by = 0;
1937  return bistate;
1938 }
@ BAS_BULKWRITE
Definition: bufmgr.h:38
BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype)
Definition: freelist.c:541
struct BulkInsertStateData * BulkInsertState
Definition: heapam.h:44
BlockNumber last_free
Definition: hio.h:49
uint32 already_extended_by
Definition: hio.h:50
BlockNumber next_free
Definition: hio.h:48

References BulkInsertStateData::already_extended_by, BAS_BULKWRITE, BulkInsertStateData::current_buf, GetAccessStrategy(), InvalidBlockNumber, InvalidBuffer, BulkInsertStateData::last_free, BulkInsertStateData::next_free, palloc(), and BulkInsertStateData::strategy.

Referenced by ATRewriteTable(), CopyFrom(), CopyMultiInsertBufferInit(), createSplitPartitionContext(), intorel_startup(), moveMergedTablesRows(), and transientrel_startup().

◆ GetMultiXactIdHintBits()

static void GetMultiXactIdHintBits ( MultiXactId  multi,
uint16 new_infomask,
uint16 new_infomask2 
)
static

Definition at line 6966 of file heapam.c.

6968 {
6969  int nmembers;
6970  MultiXactMember *members;
6971  int i;
6972  uint16 bits = HEAP_XMAX_IS_MULTI;
6973  uint16 bits2 = 0;
6974  bool has_update = false;
6975  LockTupleMode strongest = LockTupleKeyShare;
6976 
6977  /*
6978  * We only use this in multis we just created, so they cannot be values
6979  * pre-pg_upgrade.
6980  */
6981  nmembers = GetMultiXactIdMembers(multi, &members, false, false);
6982 
6983  for (i = 0; i < nmembers; i++)
6984  {
6986 
6987  /*
6988  * Remember the strongest lock mode held by any member of the
6989  * multixact.
6990  */
6991  mode = TUPLOCK_from_mxstatus(members[i].status);
6992  if (mode > strongest)
6993  strongest = mode;
6994 
6995  /* See what other bits we need */
6996  switch (members[i].status)
6997  {
7001  break;
7002 
7004  bits2 |= HEAP_KEYS_UPDATED;
7005  break;
7006 
7008  has_update = true;
7009  break;
7010 
7011  case MultiXactStatusUpdate:
7012  bits2 |= HEAP_KEYS_UPDATED;
7013  has_update = true;
7014  break;
7015  }
7016  }
7017 
7018  if (strongest == LockTupleExclusive ||
7019  strongest == LockTupleNoKeyExclusive)
7020  bits |= HEAP_XMAX_EXCL_LOCK;
7021  else if (strongest == LockTupleShare)
7022  bits |= HEAP_XMAX_SHR_LOCK;
7023  else if (strongest == LockTupleKeyShare)
7024  bits |= HEAP_XMAX_KEYSHR_LOCK;
7025 
7026  if (!has_update)
7027  bits |= HEAP_XMAX_LOCK_ONLY;
7028 
7029  if (nmembers > 0)
7030  pfree(members);
7031 
7032  *new_infomask = bits;
7033  *new_infomask2 = bits2;
7034 }

References GetMultiXactIdMembers(), HEAP_KEYS_UPDATED, HEAP_XMAX_EXCL_LOCK, HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HEAP_XMAX_SHR_LOCK, i, LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, mode, MultiXactStatusForKeyShare, MultiXactStatusForNoKeyUpdate, MultiXactStatusForShare, MultiXactStatusForUpdate, MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, pfree(), and TUPLOCK_from_mxstatus.

Referenced by compute_new_xmax_infomask(), heap_prepare_freeze_tuple(), and heap_update().

◆ heap2_redo()

void heap2_redo ( XLogReaderState record)

Definition at line 9926 of file heapam.c.

9927 {
9928  uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
9929 
9930  switch (info & XLOG_HEAP_OPMASK)
9931  {
9935  heap_xlog_prune_freeze(record);
9936  break;
9937  case XLOG_HEAP2_VISIBLE:
9938  heap_xlog_visible(record);
9939  break;
9941  heap_xlog_multi_insert(record);
9942  break;
9944  heap_xlog_lock_updated(record);
9945  break;
9946  case XLOG_HEAP2_NEW_CID:
9947 
9948  /*
9949  * Nothing to do on a real replay, only used during logical
9950  * decoding.
9951  */
9952  break;
9953  case XLOG_HEAP2_REWRITE:
9954  heap_xlog_logical_rewrite(record);
9955  break;
9956  default:
9957  elog(PANIC, "heap2_redo: unknown op code %u", info);
9958  }
9959 }
unsigned char uint8
Definition: c.h:504
#define PANIC
Definition: elog.h:42
static void heap_xlog_prune_freeze(XLogReaderState *record)
Definition: heapam.c:8752
static void heap_xlog_lock_updated(XLogReaderState *record)
Definition: heapam.c:9779
static void heap_xlog_multi_insert(XLogReaderState *record)
Definition: heapam.c:9253
static void heap_xlog_visible(XLogReaderState *record)
Definition: heapam.c:8904
#define XLOG_HEAP2_MULTI_INSERT
Definition: heapam_xlog.h:63
#define XLOG_HEAP2_REWRITE
Definition: heapam_xlog.h:58
#define XLOG_HEAP_OPMASK
Definition: heapam_xlog.h:41
#define XLOG_HEAP2_PRUNE_VACUUM_SCAN
Definition: heapam_xlog.h:60
#define XLOG_HEAP2_LOCK_UPDATED
Definition: heapam_xlog.h:64
#define XLOG_HEAP2_PRUNE_ON_ACCESS
Definition: heapam_xlog.h:59
#define XLOG_HEAP2_NEW_CID
Definition: heapam_xlog.h:65
#define XLOG_HEAP2_PRUNE_VACUUM_CLEANUP
Definition: heapam_xlog.h:61
#define XLOG_HEAP2_VISIBLE
Definition: heapam_xlog.h:62
void heap_xlog_logical_rewrite(XLogReaderState *r)
Definition: rewriteheap.c:1073
#define XLogRecGetInfo(decoder)
Definition: xlogreader.h:410
#define XLR_INFO_MASK
Definition: xlogrecord.h:62

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

void heap_abort_speculative ( Relation  relation,
ItemPointer  tid 
)

Definition at line 5906 of file heapam.c.

5907 {
5909  ItemId lp;
5910  HeapTupleData tp;
5911  Page page;
5912  BlockNumber block;
5913  Buffer buffer;
5914 
5915  Assert(ItemPointerIsValid(tid));
5916 
5917  block = ItemPointerGetBlockNumber(tid);
5918  buffer = ReadBuffer(relation, block);
5919  page = BufferGetPage(buffer);
5920 
5922 
5923  /*
5924  * Page can't be all visible, we just inserted into it, and are still
5925  * running.
5926  */
5927  Assert(!PageIsAllVisible(page));
5928 
5929  lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
5930  Assert(ItemIdIsNormal(lp));
5931 
5932  tp.t_tableOid = RelationGetRelid(relation);
5933  tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
5934  tp.t_len = ItemIdGetLength(lp);
5935  tp.t_self = *tid;
5936 
5937  /*
5938  * Sanity check that the tuple really is a speculatively inserted tuple,
5939  * inserted by us.
5940  */
5941  if (tp.t_data->t_choice.t_heap.t_xmin != xid)
5942  elog(ERROR, "attempted to kill a tuple inserted by another transaction");
5943  if (!(IsToastRelation(relation) || HeapTupleHeaderIsSpeculative(tp.t_data)))
5944  elog(ERROR, "attempted to kill a non-speculative tuple");
5946 
5947  /*
5948  * No need to check for serializable conflicts here. There is never a
5949  * need for a combo CID, either. No need to extract replica identity, or
5950  * do anything special with infomask bits.
5951  */
5952 
5954 
5955  /*
5956  * The tuple will become DEAD immediately. Flag that this page is a
5957  * candidate for pruning by setting xmin to TransactionXmin. While not
5958  * immediately prunable, it is the oldest xid we can cheaply determine
5959  * that's safe against wraparound / being older than the table's
5960  * relfrozenxid. To defend against the unlikely case of a new relation
5961  * having a newer relfrozenxid than our TransactionXmin, use relfrozenxid
5962  * if so (vacuum can't subsequently move relfrozenxid to beyond
5963  * TransactionXmin, so there's no race here).
5964  */
5966  {
5967  TransactionId relfrozenxid = relation->rd_rel->relfrozenxid;
5968  TransactionId prune_xid;
5969 
5970  if (TransactionIdPrecedes(TransactionXmin, relfrozenxid))
5971  prune_xid = relfrozenxid;
5972  else
5973  prune_xid = TransactionXmin;
5974  PageSetPrunable(page, prune_xid);
5975  }
5976 
5977  /* store transaction information of xact deleting the tuple */
5980 
5981  /*
5982  * Set the tuple header xmin to InvalidTransactionId. This makes the
5983  * tuple immediately invisible everyone. (In particular, to any
5984  * transactions waiting on the speculative token, woken up later.)
5985  */
5987 
5988  /* Clear the speculative insertion token too */
5989  tp.t_data->t_ctid = tp.t_self;
5990 
5991  MarkBufferDirty(buffer);
5992 
5993  /*
5994  * XLOG stuff
5995  *
5996  * The WAL records generated here match heap_delete(). The same recovery
5997  * routines are used.
5998  */
5999  if (RelationNeedsWAL(relation))
6000  {
6001  xl_heap_delete xlrec;
6002  XLogRecPtr recptr;
6003 
6004  xlrec.flags = XLH_DELETE_IS_SUPER;
6006  tp.t_data->t_infomask2);
6008  xlrec.xmax = xid;
6009 
6010  XLogBeginInsert();
6011  XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
6012  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
6013 
6014  /* No replica identity & replication origin logged */
6015 
6016  recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE);
6017 
6018  PageSetLSN(page, recptr);
6019  }
6020 
6021  END_CRIT_SECTION();
6022 
6023  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
6024 
6025  if (HeapTupleHasExternal(&tp))
6026  {
6027  Assert(!IsToastRelation(relation));
6028  heap_toast_delete(relation, &tp, true);
6029  }
6030 
6031  /*
6032  * Never need to mark tuple for invalidation, since catalogs don't support
6033  * speculative insertion
6034  */
6035 
6036  /* Now we can release the buffer */
6037  ReleaseBuffer(buffer);
6038 
6039  /* count deletion, as we counted the insertion too */
6040  pgstat_count_heap_delete(relation);
6041 }
int Buffer
Definition: buf.h:23
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2520
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5131
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:745
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:193
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:404
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:195
Pointer Page
Definition: bufpage.h:78
static Item PageGetItem(Page page, ItemId itemId)
Definition: bufpage.h:351
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:240
static bool PageIsAllVisible(Page page)
Definition: bufpage.h:426
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:388
#define PageSetPrunable(page, xid)
Definition: bufpage.h:444
bool IsToastRelation(Relation relation)
Definition: catalog.c:166
static uint8 compute_infobits(uint16 infomask, uint16 infomask2)
Definition: heapam.c:2638
#define XLOG_HEAP_DELETE
Definition: heapam_xlog.h:33
#define SizeOfHeapDelete
Definition: heapam_xlog.h:120
#define XLH_DELETE_IS_SUPER
Definition: heapam_xlog.h:104
void heap_toast_delete(Relation rel, HeapTuple oldtup, bool is_speculative)
Definition: heaptoast.c:43
HeapTupleHeaderData * HeapTupleHeader
Definition: htup.h:23
#define HeapTupleHeaderIsHeapOnly(tup)
Definition: htup_details.h:499
#define HeapTupleHeaderSetXmin(tup, xid)
Definition: htup_details.h:315
#define HEAP_XMAX_BITS
Definition: htup_details.h:267
#define HEAP_MOVED
Definition: htup_details.h:213
#define HeapTupleHeaderIsSpeculative(tup)
Definition: htup_details.h:428
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
#define ItemIdIsNormal(itemId)
Definition: itemid.h:99
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
void pgstat_count_heap_delete(Relation rel)
#define RelationGetRelid(relation)
Definition: rel.h:505
#define RelationNeedsWAL(relation)
Definition: rel.h:628
TransactionId TransactionXmin
Definition: snapmgr.c:98
ItemPointerData t_self
Definition: htup.h:65
uint32 t_len
Definition: htup.h:64
HeapTupleHeader t_data
Definition: htup.h:68
Oid t_tableOid
Definition: htup.h:66
TransactionId t_xmin
Definition: htup_details.h:124
ItemPointerData t_ctid
Definition: htup_details.h:161
HeapTupleFields t_heap
Definition: htup_details.h:157
union HeapTupleHeaderData::@48 t_choice
TransactionId xmax
Definition: heapam_xlog.h:114
OffsetNumber offnum
Definition: heapam_xlog.h:115
uint8 infobits_set
Definition: heapam_xlog.h:116
TransactionId GetCurrentTransactionId(void)
Definition: xact.c:452
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
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

References Assert, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), compute_infobits(), elog, END_CRIT_SECTION, ERROR, xl_heap_delete::flags, GetCurrentTransactionId(), HEAP_KEYS_UPDATED, HEAP_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HeapTupleHasExternal, HeapTupleHeaderIsHeapOnly, HeapTupleHeaderIsSpeculative, HeapTupleHeaderSetXmin, xl_heap_delete::infobits_set, InvalidTransactionId, IsToastRelation(), ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), MarkBufferDirty(), xl_heap_delete::offnum, PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapDelete, START_CRIT_SECTION, HeapTupleHeaderData::t_choice, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_heap, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, HeapTupleFields::t_xmin, TransactionIdIsValid, TransactionIdPrecedes(), TransactionXmin, XLH_DELETE_IS_SUPER, XLOG_HEAP_DELETE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), and xl_heap_delete::xmax.

Referenced by heapam_tuple_complete_speculative(), and toast_delete_datum().

◆ heap_acquire_tuplock()

static bool heap_acquire_tuplock ( Relation  relation,
ItemPointer  tid,
LockTupleMode  mode,
LockWaitPolicy  wait_policy,
bool have_tuple_lock 
)
static

Definition at line 5008 of file heapam.c.

5010 {
5011  if (*have_tuple_lock)
5012  return true;
5013 
5014  switch (wait_policy)
5015  {
5016  case LockWaitBlock:
5017  LockTupleTuplock(relation, tid, mode);
5018  break;
5019 
5020  case LockWaitSkip:
5021  if (!ConditionalLockTupleTuplock(relation, tid, mode))
5022  return false;
5023  break;
5024 
5025  case LockWaitError:
5026  if (!ConditionalLockTupleTuplock(relation, tid, mode))
5027  ereport(ERROR,
5028  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
5029  errmsg("could not obtain lock on row in relation \"%s\"",
5030  RelationGetRelationName(relation))));
5031  break;
5032  }
5033  *have_tuple_lock = true;
5034 
5035  return true;
5036 }
int errmsg(const char *fmt,...)
Definition: elog.c:1068
#define ConditionalLockTupleTuplock(rel, tup, mode)
Definition: heapam.c:172
#define LockTupleTuplock(rel, tup, mode)
Definition: heapam.c:168
@ LockWaitSkip
Definition: lockoptions.h:41
@ LockWaitBlock
Definition: lockoptions.h:39
@ LockWaitError
Definition: lockoptions.h:43
#define RelationGetRelationName(relation)
Definition: rel.h:539

References ConditionalLockTupleTuplock, ereport, errcode(), errmsg(), ERROR, LockTupleTuplock, LockWaitBlock, LockWaitError, LockWaitSkip, mode, and RelationGetRelationName.

Referenced by heap_delete(), heap_lock_tuple(), and heap_update().

◆ heap_attr_equals()

static bool heap_attr_equals ( TupleDesc  tupdesc,
int  attrnum,
Datum  value1,
Datum  value2,
bool  isnull1,
bool  isnull2 
)
static

Definition at line 4080 of file heapam.c.

4082 {
4083  Form_pg_attribute att;
4084 
4085  /*
4086  * If one value is NULL and other is not, then they are certainly not
4087  * equal
4088  */
4089  if (isnull1 != isnull2)
4090  return false;
4091 
4092  /*
4093  * If both are NULL, they can be considered equal.
4094  */
4095  if (isnull1)
4096  return true;
4097 
4098  /*
4099  * We do simple binary comparison of the two datums. This may be overly
4100  * strict because there can be multiple binary representations for the
4101  * same logical value. But we should be OK as long as there are no false
4102  * positives. Using a type-specific equality operator is messy because
4103  * there could be multiple notions of equality in different operator
4104  * classes; furthermore, we cannot safely invoke user-defined functions
4105  * while holding exclusive buffer lock.
4106  */
4107  if (attrnum <= 0)
4108  {
4109  /* The only allowed system columns are OIDs, so do this */
4110  return (DatumGetObjectId(value1) == DatumGetObjectId(value2));
4111  }
4112  else
4113  {
4114  Assert(attrnum <= tupdesc->natts);
4115  att = TupleDescAttr(tupdesc, attrnum - 1);
4116  return datumIsEqual(value1, value2, att->attbyval, att->attlen);
4117  }
4118 }
bool datumIsEqual(Datum value1, Datum value2, bool typByVal, int typLen)
Definition: datum.c:223
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

References Assert, DatumGetObjectId(), datumIsEqual(), and TupleDescAttr.

Referenced by HeapDetermineColumnsInfo().

◆ heap_beginscan()

TableScanDesc heap_beginscan ( Relation  relation,
Snapshot  snapshot,
int  nkeys,
ScanKey  key,
ParallelTableScanDesc  parallel_scan,
uint32  flags 
)

Definition at line 1038 of file heapam.c.

1042 {
1043  HeapScanDesc scan;
1044 
1045  /*
1046  * increment relation ref count while scanning relation
1047  *
1048  * This is just to make really sure the relcache entry won't go away while
1049  * the scan has a pointer to it. Caller should be holding the rel open
1050  * anyway, so this is redundant in all normal scenarios...
1051  */
1053 
1054  /*
1055  * allocate and initialize scan descriptor
1056  */
1057  scan = (HeapScanDesc) palloc(sizeof(HeapScanDescData));
1058 
1059  scan->rs_base.rs_rd = relation;
1060  scan->rs_base.rs_snapshot = snapshot;
1061  scan->rs_base.rs_nkeys = nkeys;
1062  scan->rs_base.rs_flags = flags;
1063  scan->rs_base.rs_parallel = parallel_scan;
1064  scan->rs_strategy = NULL; /* set in initscan */
1065  scan->rs_vmbuffer = InvalidBuffer;
1066  scan->rs_empty_tuples_pending = 0;
1067 
1068  /*
1069  * Disable page-at-a-time mode if it's not a MVCC-safe snapshot.
1070  */
1071  if (!(snapshot && IsMVCCSnapshot(snapshot)))
1073 
1074  /*
1075  * For seqscan and sample scans in a serializable transaction, acquire a
1076  * predicate lock on the entire relation. This is required not only to
1077  * lock all the matching tuples, but also to conflict with new insertions
1078  * into the table. In an indexscan, we take page locks on the index pages
1079  * covering the range specified in the scan qual, but in a heap scan there
1080  * is nothing more fine-grained to lock. A bitmap scan is a different
1081  * story, there we have already scanned the index and locked the index
1082  * pages covering the predicate. But in that case we still have to lock
1083  * any matching heap tuples. For sample scan we could optimize the locking
1084  * to be at least page-level granularity, but we'd need to add per-tuple
1085  * locking for that.
1086  */
1088  {
1089  /*
1090  * Ensure a missing snapshot is noticed reliably, even if the
1091  * isolation mode means predicate locking isn't performed (and
1092  * therefore the snapshot isn't used here).
1093  */
1094  Assert(snapshot);
1095  PredicateLockRelation(relation, snapshot);
1096  }
1097 
1098  /* we only need to set this up once */
1099  scan->rs_ctup.t_tableOid = RelationGetRelid(relation);
1100 
1101  /*
1102  * Allocate memory to keep track of page allocation for parallel workers
1103  * when doing a parallel scan.
1104  */
1105  if (parallel_scan != NULL)
1107  else
1108  scan->rs_parallelworkerdata = NULL;
1109 
1110  /*
1111  * we do this here instead of in initscan() because heap_rescan also calls
1112  * initscan() and we don't want to allocate memory again
1113  */
1114  if (nkeys > 0)
1115  scan->rs_base.rs_key = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
1116  else
1117  scan->rs_base.rs_key = NULL;
1118 
1119  initscan(scan, key, false);
1120 
1121  scan->rs_read_stream = NULL;
1122 
1123  /*
1124  * Set up a read stream for sequential scans and TID range scans. This
1125  * should be done after initscan() because initscan() allocates the
1126  * BufferAccessStrategy object passed to the read stream API.
1127  */
1128  if (scan->rs_base.rs_flags & SO_TYPE_SEQSCAN ||
1130  {
1132 
1133  if (scan->rs_base.rs_parallel)
1135  else
1137 
1139  scan->rs_strategy,
1140  scan->rs_base.rs_rd,
1141  MAIN_FORKNUM,
1142  cb,
1143  scan,
1144  0);
1145  }
1146 
1147 
1148  return (TableScanDesc) scan;
1149 }
static BlockNumber heap_scan_stream_read_next_parallel(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:232
static BlockNumber heap_scan_stream_read_next_serial(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: heapam.c:270
static void initscan(HeapScanDesc scan, ScanKey key, bool keep_startblock)
Definition: heapam.c:294
struct HeapScanDescData * HeapScanDesc
Definition: heapam.h:109
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
void PredicateLockRelation(Relation relation, Snapshot snapshot)
Definition: predicate.c:2561
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
Definition: read_stream.c:410
BlockNumber(* ReadStreamBlockNumberCB)(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition: read_stream.h:48
#define READ_STREAM_SEQUENTIAL
Definition: read_stream.h:35
void RelationIncrementReferenceCount(Relation rel)
Definition: relcache.c:2159
@ MAIN_FORKNUM
Definition: relpath.h:50
ScanKeyData * ScanKey
Definition: skey.h:75
#define IsMVCCSnapshot(snapshot)
Definition: snapmgr.h:62
Buffer rs_vmbuffer
Definition: heapam.h:101
BufferAccessStrategy rs_strategy
Definition: heapam.h:70
ParallelBlockTableScanWorkerData * rs_parallelworkerdata
Definition: heapam.h:92
HeapTupleData rs_ctup
Definition: heapam.h:72
ReadStream * rs_read_stream
Definition: heapam.h:75
int rs_empty_tuples_pending
Definition: heapam.h:102
TableScanDescData rs_base
Definition: heapam.h:55
Relation rs_rd
Definition: relscan.h:34
uint32 rs_flags
Definition: relscan.h:47
struct ScanKeyData * rs_key
Definition: relscan.h:37
struct SnapshotData * rs_snapshot
Definition: relscan.h:35
struct ParallelTableScanDescData * rs_parallel
Definition: relscan.h:49
@ SO_TYPE_TIDRANGESCAN
Definition: tableam.h:53
@ SO_ALLOW_PAGEMODE
Definition: tableam.h:62
@ SO_TYPE_SAMPLESCAN
Definition: tableam.h:51
@ SO_TYPE_SEQSCAN
Definition: tableam.h:49

References Assert, heap_scan_stream_read_next_parallel(), heap_scan_stream_read_next_serial(), if(), initscan(), InvalidBuffer, IsMVCCSnapshot, sort-test::key, MAIN_FORKNUM, palloc(), PredicateLockRelation(), read_stream_begin_relation(), READ_STREAM_SEQUENTIAL, RelationGetRelid, RelationIncrementReferenceCount(), HeapScanDescData::rs_base, HeapScanDescData::rs_ctup, HeapScanDescData::rs_empty_tuples_pending, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_parallel, HeapScanDescData::rs_parallelworkerdata, TableScanDescData::rs_rd, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, HeapScanDescData::rs_vmbuffer, SO_ALLOW_PAGEMODE, SO_TYPE_SAMPLESCAN, SO_TYPE_SEQSCAN, SO_TYPE_TIDRANGESCAN, and HeapTupleData::t_tableOid.

◆ heap_delete()

TM_Result heap_delete ( Relation  relation,
ItemPointer  tid,
CommandId  cid,
Snapshot  crosscheck,
bool  wait,
TM_FailureData tmfd,
bool  changingPart 
)

Definition at line 2683 of file heapam.c.

2686 {
2687  TM_Result result;
2689  ItemId lp;
2690  HeapTupleData tp;
2691  Page page;
2692  BlockNumber block;
2693  Buffer buffer;
2694  Buffer vmbuffer = InvalidBuffer;
2695  TransactionId new_xmax;
2696  uint16 new_infomask,
2697  new_infomask2;
2698  bool have_tuple_lock = false;
2699  bool iscombo;
2700  bool all_visible_cleared = false;
2701  HeapTuple old_key_tuple = NULL; /* replica identity of the tuple */
2702  bool old_key_copied = false;
2703 
2704  Assert(ItemPointerIsValid(tid));
2705 
2706  /*
2707  * Forbid this during a parallel operation, lest it allocate a combo CID.
2708  * Other workers might need that combo CID for visibility checks, and we
2709  * have no provision for broadcasting it to them.
2710  */
2711  if (IsInParallelMode())
2712  ereport(ERROR,
2713  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
2714  errmsg("cannot delete tuples during a parallel operation")));
2715 
2716  block = ItemPointerGetBlockNumber(tid);
2717  buffer = ReadBuffer(relation, block);
2718  page = BufferGetPage(buffer);
2719 
2720  /*
2721  * Before locking the buffer, pin the visibility map page if it appears to
2722  * be necessary. Since we haven't got the lock yet, someone else might be
2723  * in the middle of changing this, so we'll need to recheck after we have
2724  * the lock.
2725  */
2726  if (PageIsAllVisible(page))
2727  visibilitymap_pin(relation, block, &vmbuffer);
2728 
2730 
2731  lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
2732  Assert(ItemIdIsNormal(lp));
2733 
2734  tp.t_tableOid = RelationGetRelid(relation);
2735  tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
2736  tp.t_len = ItemIdGetLength(lp);
2737  tp.t_self = *tid;
2738 
2739 l1:
2740 
2741  /*
2742  * If we didn't pin the visibility map page and the page has become all
2743  * visible while we were busy locking the buffer, we'll have to unlock and
2744  * re-lock, to avoid holding the buffer lock across an I/O. That's a bit
2745  * unfortunate, but hopefully shouldn't happen often.
2746  */
2747  if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
2748  {
2749  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
2750  visibilitymap_pin(relation, block, &vmbuffer);
2752  }
2753 
2754  result = HeapTupleSatisfiesUpdate(&tp, cid, buffer);
2755 
2756  if (result == TM_Invisible)
2757  {
2758  UnlockReleaseBuffer(buffer);
2759  ereport(ERROR,
2760  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
2761  errmsg("attempted to delete invisible tuple")));
2762  }
2763  else if (result == TM_BeingModified && wait)
2764  {
2765  TransactionId xwait;
2766  uint16 infomask;
2767 
2768  /* must copy state data before unlocking buffer */
2769  xwait = HeapTupleHeaderGetRawXmax(tp.t_data);
2770  infomask = tp.t_data->t_infomask;
2771 
2772  /*
2773  * Sleep until concurrent transaction ends -- except when there's a
2774  * single locker and it's our own transaction. Note we don't care
2775  * which lock mode the locker has, because we need the strongest one.
2776  *
2777  * Before sleeping, we need to acquire tuple lock to establish our
2778  * priority for the tuple (see heap_lock_tuple). LockTuple will
2779  * release us when we are next-in-line for the tuple.
2780  *
2781  * If we are forced to "start over" below, we keep the tuple lock;
2782  * this arranges that we stay at the head of the line while rechecking
2783  * tuple state.
2784  */
2785  if (infomask & HEAP_XMAX_IS_MULTI)
2786  {
2787  bool current_is_member = false;
2788 
2789  if (DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
2790  LockTupleExclusive, &current_is_member))
2791  {
2792  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
2793 
2794  /*
2795  * Acquire the lock, if necessary (but skip it when we're
2796  * requesting a lock and already have one; avoids deadlock).
2797  */
2798  if (!current_is_member)
2800  LockWaitBlock, &have_tuple_lock);
2801 
2802  /* wait for multixact */
2804  relation, &(tp.t_self), XLTW_Delete,
2805  NULL);
2807 
2808  /*
2809  * If xwait had just locked the tuple then some other xact
2810  * could update this tuple before we get to this point. Check
2811  * for xmax change, and start over if so.
2812  *
2813  * We also must start over if we didn't pin the VM page, and
2814  * the page has become all visible.
2815  */
2816  if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
2817  xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
2819  xwait))
2820  goto l1;
2821  }
2822 
2823  /*
2824  * You might think the multixact is necessarily done here, but not
2825  * so: it could have surviving members, namely our own xact or
2826  * other subxacts of this backend. It is legal for us to delete
2827  * the tuple in either case, however (the latter case is
2828  * essentially a situation of upgrading our former shared lock to
2829  * exclusive). We don't bother changing the on-disk hint bits
2830  * since we are about to overwrite the xmax altogether.
2831  */
2832  }
2833  else if (!TransactionIdIsCurrentTransactionId(xwait))
2834  {
2835  /*
2836  * Wait for regular transaction to end; but first, acquire tuple
2837  * lock.
2838  */
2839  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
2841  LockWaitBlock, &have_tuple_lock);
2842  XactLockTableWait(xwait, relation, &(tp.t_self), XLTW_Delete);
2844 
2845  /*
2846  * xwait is done, but if xwait had just locked the tuple then some
2847  * other xact could update this tuple before we get to this point.
2848  * Check for xmax change, and start over if so.
2849  *
2850  * We also must start over if we didn't pin the VM page, and the
2851  * page has become all visible.
2852  */
2853  if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
2854  xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
2856  xwait))
2857  goto l1;
2858 
2859  /* Otherwise check if it committed or aborted */
2860  UpdateXmaxHintBits(tp.t_data, buffer, xwait);
2861  }
2862 
2863  /*
2864  * We may overwrite if previous xmax aborted, or if it committed but
2865  * only locked the tuple without updating it.
2866  */
2867  if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
2870  result = TM_Ok;
2871  else if (!ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
2872  result = TM_Updated;
2873  else
2874  result = TM_Deleted;
2875  }
2876 
2877  /* sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
2878  if (result != TM_Ok)
2879  {
2880  Assert(result == TM_SelfModified ||
2881  result == TM_Updated ||
2882  result == TM_Deleted ||
2883  result == TM_BeingModified);
2885  Assert(result != TM_Updated ||
2886  !ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid));
2887  }
2888 
2889  if (crosscheck != InvalidSnapshot && result == TM_Ok)
2890  {
2891  /* Perform additional check for transaction-snapshot mode RI updates */
2892  if (!HeapTupleSatisfiesVisibility(&tp, crosscheck, buffer))
2893  result = TM_Updated;
2894  }
2895 
2896  if (result != TM_Ok)
2897  {
2898  tmfd->ctid = tp.t_data->t_ctid;
2900  if (result == TM_SelfModified)
2901  tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
2902  else
2903  tmfd->cmax = InvalidCommandId;
2904  UnlockReleaseBuffer(buffer);
2905  if (have_tuple_lock)
2906  UnlockTupleTuplock(relation, &(tp.t_self), LockTupleExclusive);
2907  if (vmbuffer != InvalidBuffer)
2908  ReleaseBuffer(vmbuffer);
2909  return result;
2910  }
2911 
2912  /*
2913  * We're about to do the actual delete -- check for conflict first, to
2914  * avoid possibly having to roll back work we've just done.
2915  *
2916  * This is safe without a recheck as long as there is no possibility of
2917  * another process scanning the page between this check and the delete
2918  * being visible to the scan (i.e., an exclusive buffer content lock is
2919  * continuously held from this point until the tuple delete is visible).
2920  */
2921  CheckForSerializableConflictIn(relation, tid, BufferGetBlockNumber(buffer));
2922 
2923  /* replace cid with a combo CID if necessary */
2924  HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
2925 
2926  /*
2927  * Compute replica identity tuple before entering the critical section so
2928  * we don't PANIC upon a memory allocation failure.
2929  */
2930  old_key_tuple = ExtractReplicaIdentity(relation, &tp, true, &old_key_copied);
2931 
2932  /*
2933  * If this is the first possibly-multixact-able operation in the current
2934  * transaction, set my per-backend OldestMemberMXactId setting. We can be
2935  * certain that the transaction will never become a member of any older
2936  * MultiXactIds than that. (We have to do this even if we end up just
2937  * using our own TransactionId below, since some other backend could
2938  * incorporate our XID into a MultiXact immediately afterwards.)
2939  */
2941 
2944  xid, LockTupleExclusive, true,
2945  &new_xmax, &new_infomask, &new_infomask2);
2946 
2948 
2949  /*
2950  * If this transaction commits, the tuple will become DEAD sooner or
2951  * later. Set flag that this page is a candidate for pruning once our xid
2952  * falls below the OldestXmin horizon. If the transaction finally aborts,
2953  * the subsequent page pruning will be a no-op and the hint will be
2954  * cleared.
2955  */
2956  PageSetPrunable(page, xid);
2957 
2958  if (PageIsAllVisible(page))
2959  {
2960  all_visible_cleared = true;
2961  PageClearAllVisible(page);
2962  visibilitymap_clear(relation, BufferGetBlockNumber(buffer),
2963  vmbuffer, VISIBILITYMAP_VALID_BITS);
2964  }
2965 
2966  /* store transaction information of xact deleting the tuple */
2969  tp.t_data->t_infomask |= new_infomask;
2970  tp.t_data->t_infomask2 |= new_infomask2;
2972  HeapTupleHeaderSetXmax(tp.t_data, new_xmax);
2973  HeapTupleHeaderSetCmax(tp.t_data, cid, iscombo);
2974  /* Make sure there is no forward chain link in t_ctid */
2975  tp.t_data->t_ctid = tp.t_self;
2976 
2977  /* Signal that this is actually a move into another partition */
2978  if (changingPart)
2980 
2981  MarkBufferDirty(buffer);
2982 
2983  /*
2984  * XLOG stuff
2985  *
2986  * NB: heap_abort_speculative() uses the same xlog record and replay
2987  * routines.
2988  */
2989  if (RelationNeedsWAL(relation))
2990  {
2991  xl_heap_delete xlrec;
2992  xl_heap_header xlhdr;
2993  XLogRecPtr recptr;
2994 
2995  /*
2996  * For logical decode we need combo CIDs to properly decode the
2997  * catalog
2998  */
3000  log_heap_new_cid(relation, &tp);
3001 
3002  xlrec.flags = 0;
3003  if (all_visible_cleared)
3005  if (changingPart)
3008  tp.t_data->t_infomask2);
3010  xlrec.xmax = new_xmax;
3011 
3012  if (old_key_tuple != NULL)
3013  {
3014  if (relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
3016  else
3018  }
3019 
3020  XLogBeginInsert();
3021  XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
3022 
3023  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
3024 
3025  /*
3026  * Log replica identity of the deleted tuple if there is one
3027  */
3028  if (old_key_tuple != NULL)
3029  {
3030  xlhdr.t_infomask2 = old_key_tuple->t_data->t_infomask2;
3031  xlhdr.t_infomask = old_key_tuple->t_data->t_infomask;
3032  xlhdr.t_hoff = old_key_tuple->t_data->t_hoff;
3033 
3034  XLogRegisterData((char *) &xlhdr, SizeOfHeapHeader);
3035  XLogRegisterData((char *) old_key_tuple->t_data
3037  old_key_tuple->t_len
3039  }
3040 
3041  /* filtering by origin on a row level is much more efficient */
3043 
3044  recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE);
3045 
3046  PageSetLSN(page, recptr);
3047  }
3048 
3049  END_CRIT_SECTION();
3050 
3051  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
3052 
3053  if (vmbuffer != InvalidBuffer)
3054  ReleaseBuffer(vmbuffer);
3055 
3056  /*
3057  * If the tuple has toasted out-of-line attributes, we need to delete
3058  * those items too. We have to do this before releasing the buffer
3059  * because we need to look at the contents of the tuple, but it's OK to
3060  * release the content lock on the buffer first.
3061  */
3062  if (relation->rd_rel->relkind != RELKIND_RELATION &&
3063  relation->rd_rel->relkind != RELKIND_MATVIEW)
3064  {
3065  /* toast table entries should never be recursively toasted */
3067  }
3068  else if (HeapTupleHasExternal(&tp))
3069  heap_toast_delete(relation, &tp, false);
3070 
3071  /*
3072  * Mark tuple for invalidation from system caches at next command
3073  * boundary. We have to do this before releasing the buffer because we
3074  * need to look at the contents of the tuple.
3075  */
3076  CacheInvalidateHeapTuple(relation, &tp, NULL);
3077 
3078  /* Now we can release the buffer */
3079  ReleaseBuffer(buffer);
3080 
3081  /*
3082  * Release the lmgr tuple lock, if we had it.
3083  */
3084  if (have_tuple_lock)
3085  UnlockTupleTuplock(relation, &(tp.t_self), LockTupleExclusive);
3086 
3087  pgstat_count_heap_delete(relation);
3088 
3089  if (old_key_tuple != NULL && old_key_copied)
3090  heap_freetuple(old_key_tuple);
3091 
3092  return TM_Ok;
3093 }
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:3713
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4913
static void PageClearAllVisible(Page page)
Definition: bufpage.h:436
#define InvalidCommandId
Definition: c.h:669
void HeapTupleHeaderAdjustCmax(HeapTupleHeader tup, CommandId *cmax, bool *iscombo)
Definition: combocid.c:153
CommandId HeapTupleHeaderGetCmax(HeapTupleHeader tup)
Definition: combocid.c:118
static bool DoesMultiXactIdConflict(MultiXactId multi, uint16 infomask, LockTupleMode lockmode, bool *current_is_member)
Definition: heapam.c:7115
static XLogRecPtr log_heap_new_cid(Relation relation, HeapTuple tup)
Definition: heapam.c:8579
static void compute_new_xmax_infomask(TransactionId xmax, uint16 old_infomask, uint16 old_infomask2, TransactionId add_to_xmax, LockTupleMode mode, bool is_update, TransactionId *result_xmax, uint16 *result_infomask, uint16 *result_infomask2)
Definition: heapam.c:5057
static HeapTuple ExtractReplicaIdentity(Relation relation, HeapTuple tp, bool key_required, bool *copy)
Definition: heapam.c:8660
static bool heap_acquire_tuplock(Relation relation, ItemPointer tid, LockTupleMode mode, LockWaitPolicy wait_policy, bool *have_tuple_lock)
Definition: heapam.c:5008
static void MultiXactIdWait(MultiXactId multi, MultiXactStatus status, uint16 infomask, Relation rel, ItemPointer ctid, XLTW_Oper oper, int *remaining)
Definition: heapam.c:7292
static bool xmax_infomask_changed(uint16 new_infomask, uint16 old_infomask)
Definition: heapam.c:2660
#define UnlockTupleTuplock(rel, tup, mode)
Definition: heapam.c:170
static void UpdateXmaxHintBits(HeapTupleHeader tuple, Buffer buffer, TransactionId xid)
Definition: heapam.c:1905
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
TM_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
#define XLH_DELETE_CONTAINS_OLD_KEY
Definition: heapam_xlog.h:103
#define XLH_DELETE_ALL_VISIBLE_CLEARED
Definition: heapam_xlog.h:101
#define SizeOfHeapHeader
Definition: heapam_xlog.h:156
#define XLH_DELETE_IS_PARTITION_MOVE
Definition: heapam_xlog.h:105
#define XLH_DELETE_CONTAINS_OLD_TUPLE
Definition: heapam_xlog.h:102
#define SizeofHeapTupleHeader
Definition: htup_details.h:185
#define HeapTupleHeaderSetXmax(tup, xid)
Definition: htup_details.h:376
#define HeapTupleHeaderClearHotUpdated(tup)
Definition: htup_details.h:494
#define HeapTupleHeaderSetMovedPartitions(tup)
Definition: htup_details.h:447
#define HeapTupleHeaderGetRawXmax(tup)
Definition: htup_details.h:371
#define HeapTupleHeaderGetUpdateXid(tup)
Definition: htup_details.h:361
#define HeapTupleHeaderSetCmax(tup, cid, iscombo)
Definition: htup_details.h:401
void CacheInvalidateHeapTuple(Relation relation, HeapTuple tuple, HeapTuple newtuple)
Definition: inval.c:1204
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
Definition: itemptr.c:35
@ XLTW_Delete
Definition: lmgr.h:28
void MultiXactIdSetOldestMember(void)
Definition: multixact.c:672
void CheckForSerializableConflictIn(Relation relation, ItemPointer tid, BlockNumber blkno)
Definition: predicate.c:4321
#define RelationIsAccessibleInLogicalDecoding(relation)
Definition: rel.h:684
#define InvalidSnapshot
Definition: snapshot.h:123
TransactionId xmax
Definition: tableam.h:151
CommandId cmax
Definition: tableam.h:152
ItemPointerData ctid
Definition: tableam.h:150
uint16 t_infomask
Definition: heapam_xlog.h:152
uint16 t_infomask2
Definition: heapam_xlog.h:151
TM_Result
Definition: tableam.h:80
@ TM_Ok
Definition: tableam.h:85
@ TM_BeingModified
Definition: tableam.h:107
@ TM_Deleted
Definition: tableam.h:100
@ TM_Updated
Definition: tableam.h:97
@ TM_SelfModified
Definition: tableam.h:91
@ TM_Invisible
Definition: tableam.h:88
#define TransactionIdEquals(id1, id2)
Definition: transam.h:43
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)
void visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
#define VISIBILITYMAP_VALID_BITS
bool IsInParallelMode(void)
Definition: xact.c:1087
#define XLOG_INCLUDE_ORIGIN
Definition: xlog.h:152
void XLogSetRecordFlags(uint8 flags)
Definition: xloginsert.c:456

References Assert, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), TM_FailureData::cmax, compute_infobits(), compute_new_xmax_infomask(), TM_FailureData::ctid, DoesMultiXactIdConflict(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, ExtractReplicaIdentity(), xl_heap_delete::flags, GetCurrentTransactionId(), heap_acquire_tuplock(), heap_freetuple(), HEAP_KEYS_UPDATED, HEAP_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY, HEAP_XMAX_IS_MULTI, HeapTupleHasExternal, HeapTupleHeaderAdjustCmax(), HeapTupleHeaderClearHotUpdated, HeapTupleHeaderGetCmax(), HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetCmax, HeapTupleHeaderSetMovedPartitions, HeapTupleHeaderSetXmax, HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVisibility(), xl_heap_delete::infobits_set, InvalidBuffer, InvalidCommandId, InvalidSnapshot, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockWaitBlock, log_heap_new_cid(), MarkBufferDirty(), MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusUpdate, xl_heap_delete::offnum, PageClearAllVisible(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapDelete, SizeOfHeapHeader, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), UnlockReleaseBuffer(), UnlockTupleTuplock, UpdateXmaxHintBits(), visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XactLockTableWait(), XLH_DELETE_ALL_VISIBLE_CLEARED, XLH_DELETE_CONTAINS_OLD_KEY, XLH_DELETE_CONTAINS_OLD_TUPLE, XLH_DELETE_IS_PARTITION_MOVE, XLOG_HEAP_DELETE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLogSetRecordFlags(), XLTW_Delete, xl_heap_delete::xmax, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_delete(), and simple_heap_delete().

◆ heap_endscan()

void heap_endscan ( TableScanDesc  sscan)

Definition at line 1210 of file heapam.c.

1211 {
1212  HeapScanDesc scan = (HeapScanDesc) sscan;
1213 
1214  /* Note: no locking manipulations needed */
1215 
1216  /*
1217  * unpin scan buffers
1218  */
1219  if (BufferIsValid(scan->rs_cbuf))
1220  ReleaseBuffer(scan->rs_cbuf);
1221 
1222  if (BufferIsValid(scan->rs_vmbuffer))
1223  ReleaseBuffer(scan->rs_vmbuffer);
1224 
1225  /*
1226  * Must free the read stream before freeing the BufferAccessStrategy.
1227  */
1228  if (scan->rs_read_stream)
1230 
1231  /*
1232  * decrement relation reference count and free scan descriptor storage
1233  */
1235 
1236  if (scan->rs_base.rs_key)
1237  pfree(scan->rs_base.rs_key);
1238 
1239  if (scan->rs_strategy != NULL)
1241 
1242  if (scan->rs_parallelworkerdata != NULL)
1244 
1245  if (scan->rs_base.rs_flags & SO_TEMP_SNAPSHOT)
1247 
1248  pfree(scan);
1249 }
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:355
void read_stream_end(ReadStream *stream)
Definition: read_stream.c:802
void RelationDecrementReferenceCount(Relation rel)
Definition: relcache.c:2172
void UnregisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:836
Buffer rs_cbuf
Definition: heapam.h:67
@ SO_TEMP_SNAPSHOT
Definition: tableam.h:65

References BufferIsValid(), FreeAccessStrategy(), pfree(), read_stream_end(), RelationDecrementReferenceCount(), ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, TableScanDescData::rs_key, HeapScanDescData::rs_parallelworkerdata, TableScanDescData::rs_rd, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, HeapScanDescData::rs_vmbuffer, SO_TEMP_SNAPSHOT, and UnregisterSnapshot().

◆ heap_execute_freeze_tuple()

static void heap_execute_freeze_tuple ( HeapTupleHeader  tuple,
HeapTupleFreeze frz 
)
inlinestatic

Definition at line 6824 of file heapam.c.

6825 {
6826  HeapTupleHeaderSetXmax(tuple, frz->xmax);
6827 
6828  if (frz->frzflags & XLH_FREEZE_XVAC)
6830 
6831  if (frz->frzflags & XLH_INVALID_XVAC)
6833 
6834  tuple->t_infomask = frz->t_infomask;
6835  tuple->t_infomask2 = frz->t_infomask2;
6836 }
#define XLH_INVALID_XVAC
Definition: heapam_xlog.h:339
#define XLH_FREEZE_XVAC
Definition: heapam_xlog.h:338
#define HeapTupleHeaderSetXvac(tup, xid)
Definition: htup_details.h:419
uint8 frzflags
Definition: heapam.h:146
uint16 t_infomask2
Definition: heapam.h:144
TransactionId xmax
Definition: heapam.h:143
uint16 t_infomask
Definition: heapam.h:145
#define FrozenTransactionId
Definition: transam.h:33

References FrozenTransactionId, HeapTupleFreeze::frzflags, HeapTupleHeaderSetXmax, HeapTupleHeaderSetXvac, InvalidTransactionId, HeapTupleFreeze::t_infomask, HeapTupleHeaderData::t_infomask, HeapTupleFreeze::t_infomask2, HeapTupleHeaderData::t_infomask2, XLH_FREEZE_XVAC, XLH_INVALID_XVAC, and HeapTupleFreeze::xmax.

Referenced by heap_freeze_prepared_tuples(), heap_freeze_tuple(), and heap_xlog_prune_freeze().

◆ heap_fetch()

bool heap_fetch ( Relation  relation,
Snapshot  snapshot,
HeapTuple  tuple,
Buffer userbuf,
bool  keep_buf 
)

Definition at line 1511 of file heapam.c.

1516 {
1517  ItemPointer tid = &(tuple->t_self);
1518  ItemId lp;
1519  Buffer buffer;
1520  Page page;
1521  OffsetNumber offnum;
1522  bool valid;
1523 
1524  /*
1525  * Fetch and pin the appropriate page of the relation.
1526  */
1527  buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
1528 
1529  /*
1530  * Need share lock on buffer to examine tuple commit status.
1531  */
1532  LockBuffer(buffer, BUFFER_LOCK_SHARE);
1533  page = BufferGetPage(buffer);
1534 
1535  /*
1536  * We'd better check for out-of-range offnum in case of VACUUM since the
1537  * TID was obtained.
1538  */
1539  offnum = ItemPointerGetOffsetNumber(tid);
1540  if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
1541  {
1542  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
1543  ReleaseBuffer(buffer);
1544  *userbuf = InvalidBuffer;
1545  tuple->t_data = NULL;
1546  return false;
1547  }
1548 
1549  /*
1550  * get the item line pointer corresponding to the requested tid
1551  */
1552  lp = PageGetItemId(page, offnum);
1553 
1554  /*
1555  * Must check for deleted tuple.
1556  */
1557  if (!ItemIdIsNormal(lp))
1558  {
1559  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
1560  ReleaseBuffer(buffer);
1561  *userbuf = InvalidBuffer;
1562  tuple->t_data = NULL;
1563  return false;
1564  }
1565 
1566  /*
1567  * fill in *tuple fields
1568  */
1569  tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
1570  tuple->t_len = ItemIdGetLength(lp);
1571  tuple->t_tableOid = RelationGetRelid(relation);
1572 
1573  /*
1574  * check tuple visibility, then release lock
1575  */
1576  valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
1577 
1578  if (valid)
1579  PredicateLockTID(relation, &(tuple->t_self), snapshot,
1580  HeapTupleHeaderGetXmin(tuple->t_data));
1581 
1582  HeapCheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
1583 
1584  LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
1585 
1586  if (valid)
1587  {
1588  /*
1589  * All checks passed, so return the tuple as valid. Caller is now
1590  * responsible for releasing the buffer.
1591  */
1592  *userbuf = buffer;
1593 
1594  return true;
1595  }
1596 
1597  /* Tuple failed time qual, but maybe caller wants to see it anyway. */
1598  if (keep_buf)
1599  *userbuf = buffer;
1600  else
1601  {
1602  ReleaseBuffer(buffer);
1603  *userbuf = InvalidBuffer;
1604  tuple->t_data = NULL;
1605  }
1606 
1607  return false;
1608 }
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:194
static OffsetNumber PageGetMaxOffsetNumber(Page page)
Definition: bufpage.h:369
void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
Definition: heapam.c:10061
#define HeapTupleHeaderGetXmin(tup)
Definition: htup_details.h:309
uint16 OffsetNumber
Definition: off.h:24
void PredicateLockTID(Relation relation, ItemPointer tid, Snapshot snapshot, TransactionId tuple_xid)
Definition: predicate.c:2606

References BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetXmin, HeapTupleSatisfiesVisibility(), InvalidBuffer, ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), ReadBuffer(), RelationGetRelid, ReleaseBuffer(), HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by heap_lock_updated_tuple_rec(), heapam_fetch_row_version(), and heapam_tuple_lock().

◆ heap_fetch_next_buffer()

static void heap_fetch_next_buffer ( HeapScanDesc  scan,
ScanDirection  dir 
)
inlinestatic

Definition at line 585 of file heapam.c.

586 {
587  Assert(scan->rs_read_stream);
588 
589  /* release previous scan buffer, if any */
590  if (BufferIsValid(scan->rs_cbuf))
591  {
592  ReleaseBuffer(scan->rs_cbuf);
593  scan->rs_cbuf = InvalidBuffer;
594  }
595 
596  /*
597  * Be sure to check for interrupts at least once per page. Checks at
598  * higher code levels won't be able to stop a seqscan that encounters many
599  * pages' worth of consecutive dead tuples.
600  */
602 
603  /*
604  * If the scan direction is changing, reset the prefetch block to the
605  * current block. Otherwise, we will incorrectly prefetch the blocks
606  * between the prefetch block and the current block again before
607  * prefetching blocks in the new, correct scan direction.
608  */
609  if (unlikely(scan->rs_dir != dir))
610  {
611  scan->rs_prefetch_block = scan->rs_cblock;
613  }
614 
615  scan->rs_dir = dir;
616 
617  scan->rs_cbuf = read_stream_next_buffer(scan->rs_read_stream, NULL);
618  if (BufferIsValid(scan->rs_cbuf))
619  scan->rs_cblock = BufferGetBlockNumber(scan->rs_cbuf);
620 }
#define unlikely(x)
Definition: c.h:311
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
void read_stream_reset(ReadStream *stream)
Definition: read_stream.c:775
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
Definition: read_stream.c:572
ScanDirection rs_dir
Definition: heapam.h:85
BlockNumber rs_prefetch_block
Definition: heapam.h:86
BlockNumber rs_cblock
Definition: heapam.h:66

References Assert, BufferGetBlockNumber(), BufferIsValid(), CHECK_FOR_INTERRUPTS, InvalidBuffer, read_stream_next_buffer(), read_stream_reset(), ReleaseBuffer(), HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_dir, HeapScanDescData::rs_prefetch_block, HeapScanDescData::rs_read_stream, and unlikely.

Referenced by heapgettup(), and heapgettup_pagemode().

◆ heap_finish_speculative()

void heap_finish_speculative ( Relation  relation,
ItemPointer  tid 
)

Definition at line 5819 of file heapam.c.

5820 {
5821  Buffer buffer;
5822  Page page;
5823  OffsetNumber offnum;
5824  ItemId lp = NULL;
5825  HeapTupleHeader htup;
5826 
5827  buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
5829  page = (Page) BufferGetPage(buffer);
5830 
5831  offnum = ItemPointerGetOffsetNumber(tid);
5832  if (PageGetMaxOffsetNumber(page) >= offnum)
5833  lp = PageGetItemId(page, offnum);
5834 
5835  if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
5836  elog(ERROR, "invalid lp");
5837 
5838  htup = (HeapTupleHeader) PageGetItem(page, lp);
5839 
5840  /* NO EREPORT(ERROR) from here till changes are logged */
5842 
5844 
5845  MarkBufferDirty(buffer);
5846 
5847  /*
5848  * Replace the speculative insertion token with a real t_ctid, pointing to
5849  * itself like it does on regular tuples.
5850  */
5851  htup->t_ctid = *tid;
5852 
5853  /* XLOG stuff */
5854  if (RelationNeedsWAL(relation))
5855  {
5856  xl_heap_confirm xlrec;
5857  XLogRecPtr recptr;
5858 
5859  xlrec.offnum = ItemPointerGetOffsetNumber(tid);
5860 
5861  XLogBeginInsert();
5862 
5863  /* We want the same filtering on this as on a plain insert */
5865 
5866  XLogRegisterData((char *) &xlrec, SizeOfHeapConfirm);
5867  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
5868 
5869  recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_CONFIRM);
5870 
5871  PageSetLSN(page, recptr);
5872  }
5873 
5874  END_CRIT_SECTION();
5875 
5876  UnlockReleaseBuffer(buffer);
5877 }
#define SizeOfHeapConfirm
Definition: heapam_xlog.h:422
#define XLOG_HEAP_CONFIRM
Definition: heapam_xlog.h:37
OffsetNumber offnum
Definition: heapam_xlog.h:419

References Assert, BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), elog, END_CRIT_SECTION, ERROR, HeapTupleHeaderIsSpeculative, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), MarkBufferDirty(), xl_heap_confirm::offnum, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetLSN(), ReadBuffer(), REGBUF_STANDARD, RelationNeedsWAL, SizeOfHeapConfirm, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, UnlockReleaseBuffer(), XLOG_HEAP_CONFIRM, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().

Referenced by heapam_tuple_complete_speculative().

◆ heap_freeze_prepared_tuples()

void heap_freeze_prepared_tuples ( Buffer  buffer,
HeapTupleFreeze tuples,
int  ntuples 
)

Definition at line 6900 of file heapam.c.

6901 {
6902  Page page = BufferGetPage(buffer);
6903 
6904  for (int i = 0; i < ntuples; i++)
6905  {
6906  HeapTupleFreeze *frz = tuples + i;
6907  ItemId itemid = PageGetItemId(page, frz->offset);
6908  HeapTupleHeader htup;
6909 
6910  htup = (HeapTupleHeader) PageGetItem(page, itemid);
6911  heap_execute_freeze_tuple(htup, frz);
6912  }
6913 }
static void heap_execute_freeze_tuple(HeapTupleHeader tuple, HeapTupleFreeze *frz)
Definition: heapam.c:6824
OffsetNumber offset
Definition: heapam.h:151

References BufferGetPage(), heap_execute_freeze_tuple(), i, HeapTupleFreeze::offset, PageGetItem(), and PageGetItemId().

Referenced by heap_page_prune_and_freeze().

◆ heap_freeze_tuple()

bool heap_freeze_tuple ( HeapTupleHeader  tuple,
TransactionId  relfrozenxid,
TransactionId  relminmxid,
TransactionId  FreezeLimit,
TransactionId  MultiXactCutoff 
)

Definition at line 6922 of file heapam.c.

6925 {
6926  HeapTupleFreeze frz;
6927  bool do_freeze;
6928  bool totally_frozen;
6929  struct VacuumCutoffs cutoffs;
6930  HeapPageFreeze pagefrz;
6931 
6932  cutoffs.relfrozenxid = relfrozenxid;
6933  cutoffs.relminmxid = relminmxid;
6934  cutoffs.OldestXmin = FreezeLimit;
6935  cutoffs.OldestMxact = MultiXactCutoff;
6936  cutoffs.FreezeLimit = FreezeLimit;
6937  cutoffs.MultiXactCutoff = MultiXactCutoff;
6938 
6939  pagefrz.freeze_required = true;
6940  pagefrz.FreezePageRelfrozenXid = FreezeLimit;
6941  pagefrz.FreezePageRelminMxid = MultiXactCutoff;
6942  pagefrz.NoFreezePageRelfrozenXid = FreezeLimit;
6943  pagefrz.NoFreezePageRelminMxid = MultiXactCutoff;
6944 
6945  do_freeze = heap_prepare_freeze_tuple(tuple, &cutoffs,
6946  &pagefrz, &frz, &totally_frozen);
6947 
6948  /*
6949  * Note that because this is not a WAL-logged operation, we don't need to
6950  * fill in the offset in the freeze record.
6951  */
6952 
6953  if (do_freeze)
6954  heap_execute_freeze_tuple(tuple, &frz);
6955  return do_freeze;
6956 }
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:6550

References VacuumCutoffs::FreezeLimit, heap_execute_freeze_tuple(), heap_prepare_freeze_tuple(), VacuumCutoffs::MultiXactCutoff, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumCutoffs::relfrozenxid, and VacuumCutoffs::relminmxid.

Referenced by rewrite_heap_tuple().

◆ heap_get_latest_tid()

void heap_get_latest_tid ( TableScanDesc  sscan,
ItemPointer  tid 
)

Definition at line 1783 of file heapam.c.

1785 {
1786  Relation relation = sscan->rs_rd;
1787  Snapshot snapshot = sscan->rs_snapshot;
1788  ItemPointerData ctid;
1789  TransactionId priorXmax;
1790 
1791  /*
1792  * table_tuple_get_latest_tid() verified that the passed in tid is valid.
1793  * Assume that t_ctid links are valid however - there shouldn't be invalid
1794  * ones in the table.
1795  */
1796  Assert(ItemPointerIsValid(tid));
1797 
1798  /*
1799  * Loop to chase down t_ctid links. At top of loop, ctid is the tuple we
1800  * need to examine, and *tid is the TID we will return if ctid turns out
1801  * to be bogus.
1802  *
1803  * Note that we will loop until we reach the end of the t_ctid chain.
1804  * Depending on the snapshot passed, there might be at most one visible
1805  * version of the row, but we don't try to optimize for that.
1806  */
1807  ctid = *tid;
1808  priorXmax = InvalidTransactionId; /* cannot check first XMIN */
1809  for (;;)
1810  {
1811  Buffer buffer;
1812  Page page;
1813  OffsetNumber offnum;
1814  ItemId lp;
1815  HeapTupleData tp;
1816  bool valid;
1817 
1818  /*
1819  * Read, pin, and lock the page.
1820  */
1821  buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&ctid));
1822  LockBuffer(buffer, BUFFER_LOCK_SHARE);
1823  page = BufferGetPage(buffer);
1824 
1825  /*
1826  * Check for bogus item number. This is not treated as an error
1827  * condition because it can happen while following a t_ctid link. We
1828  * just assume that the prior tid is OK and return it unchanged.
1829  */
1830  offnum = ItemPointerGetOffsetNumber(&ctid);
1831  if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
1832  {
1833  UnlockReleaseBuffer(buffer);
1834  break;
1835  }
1836  lp = PageGetItemId(page, offnum);
1837  if (!ItemIdIsNormal(lp))
1838  {
1839  UnlockReleaseBuffer(buffer);
1840  break;
1841  }
1842 
1843  /* OK to access the tuple */
1844  tp.t_self = ctid;
1845  tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
1846  tp.t_len = ItemIdGetLength(lp);
1847  tp.t_tableOid = RelationGetRelid(relation);
1848 
1849  /*
1850  * After following a t_ctid link, we might arrive at an unrelated
1851  * tuple. Check for XMIN match.
1852  */
1853  if (TransactionIdIsValid(priorXmax) &&
1855  {
1856  UnlockReleaseBuffer(buffer);
1857  break;
1858  }
1859 
1860  /*
1861  * Check tuple visibility; if visible, set it as the new result
1862  * candidate.
1863  */
1864  valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
1865  HeapCheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
1866  if (valid)
1867  *tid = ctid;
1868 
1869  /*
1870  * If there's a valid t_ctid link, follow it, else we're done.
1871  */
1872  if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
1876  {
1877  UnlockReleaseBuffer(buffer);
1878  break;
1879  }
1880 
1881  ctid = tp.t_data->t_ctid;
1882  priorXmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
1883  UnlockReleaseBuffer(buffer);
1884  } /* end of loop */
1885 }
#define HeapTupleHeaderIndicatesMovedPartitions(tup)
Definition: htup_details.h:444

References Assert, BUFFER_LOCK_SHARE, BufferGetPage(), HEAP_XMAX_INVALID, HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleHeaderIndicatesMovedPartitions, HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), ReadBuffer(), RelationGetRelid, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().

◆ heap_getnext()

HeapTuple heap_getnext ( TableScanDesc  sscan,
ScanDirection  direction 
)

Definition at line 1252 of file heapam.c.

1253 {
1254  HeapScanDesc scan = (HeapScanDesc) sscan;
1255 
1256  /*
1257  * This is still widely used directly, without going through table AM, so
1258  * add a safety check. It's possible we should, at a later point,
1259  * downgrade this to an assert. The reason for checking the AM routine,
1260  * rather than the AM oid, is that this allows to write regression tests
1261  * that create another AM reusing the heap handler.
1262  */
1264  ereport(ERROR,
1265  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1266  errmsg_internal("only heap AM is supported")));
1267 
1268  /*
1269  * We don't expect direct calls to heap_getnext with valid CheckXidAlive
1270  * for catalog or regular tables. See detailed comments in xact.c where
1271  * these variables are declared. Normally we have such a check at tableam
1272  * level API but this is called from many places so we need to ensure it
1273  * here.
1274  */
1276  elog(ERROR, "unexpected heap_getnext call during logical decoding");
1277 
1278  /* Note: no locking manipulations needed */
1279 
1280  if (scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)
1281  heapgettup_pagemode(scan, direction,
1282  scan->rs_base.rs_nkeys, scan->rs_base.rs_key);
1283  else
1284  heapgettup(scan, direction,
1285  scan->rs_base.rs_nkeys, scan->rs_base.rs_key);
1286 
1287  if (scan->rs_ctup.t_data == NULL)
1288  return NULL;
1289 
1290  /*
1291  * if we get here it means we have a new current scan tuple, so point to
1292  * the proper return buffer and return the tuple.
1293  */
1294 
1296 
1297  return &scan->rs_ctup;
1298 }
static void heapgettup(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:838
static void heapgettup_pagemode(HeapScanDesc scan, ScanDirection dir, int nkeys, ScanKey key)
Definition: heapam.c:948
const TableAmRoutine * GetHeapamTableAmRoutine(void)
#define pgstat_count_heap_getnext(rel)
Definition: pgstat.h:615
const struct TableAmRoutine * rd_tableam
Definition: rel.h:189
bool bsysscan
Definition: xact.c:98
TransactionId CheckXidAlive
Definition: xact.c:97

References bsysscan, CheckXidAlive, elog, ereport, errcode(), errmsg_internal(), ERROR, GetHeapamTableAmRoutine(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, RelationData::rd_tableam, HeapScanDescData::rs_base, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, HeapTupleData::t_data, TransactionIdIsValid, and unlikely.

Referenced by AlterTableMoveAll(), AlterTableSpaceOptions(), check_db_file_conflict(), CreateDatabaseUsingFileCopy(), do_autovacuum(), DropSetting(), DropTableSpace(), find_typed_table_dependencies(), get_all_vacuum_rels(), get_database_list(), get_subscription_list(), get_tables_to_cluster(), get_tablespace_name(), get_tablespace_oid(), GetAllTablesPublicationRelations(), getRelationsInNamespace(), GetSchemaPublicationRelations(), heapam_index_build_range_scan(), heapam_index_validate_scan(), index_update_stats(), objectsInSchemaToOids(), pgrowlocks(), pgstat_heap(), populate_typ_list(), ReindexMultipleTables(), remove_dbtablespaces(), RemoveSubscriptionRel(), RenameTableSpace(), ThereIsAtLeastOneRole(), and vac_truncate_clog().

◆ heap_getnextslot()

bool heap_getnextslot ( TableScanDesc  sscan,
ScanDirection  direction,
TupleTableSlot slot 
)

Definition at line 1301 of file heapam.c.

1302 {
1303  HeapScanDesc scan = (HeapScanDesc) sscan;
1304 
1305  /* Note: no locking manipulations needed */
1306 
1307  if (sscan->rs_flags & SO_ALLOW_PAGEMODE)
1308  heapgettup_pagemode(scan, direction, sscan->rs_nkeys, sscan->rs_key);
1309  else
1310  heapgettup(scan, direction, sscan->rs_nkeys, sscan->rs_key);
1311 
1312  if (scan->rs_ctup.t_data == NULL)
1313  {
1314  ExecClearTuple(slot);
1315  return false;
1316  }
1317 
1318  /*
1319  * if we get here it means we have a new current scan tuple, so point to
1320  * the proper return buffer and return the tuple.
1321  */
1322 
1324 
1325  ExecStoreBufferHeapTuple(&scan->rs_ctup, slot,
1326  scan->rs_cbuf);
1327  return true;
1328 }
TupleTableSlot * ExecStoreBufferHeapTuple(HeapTuple tuple, TupleTableSlot *slot, Buffer buffer)
Definition: execTuples.c:1479
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: tuptable.h:454

References ExecClearTuple(), ExecStoreBufferHeapTuple(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, and HeapTupleData::t_data.

◆ heap_getnextslot_tidrange()

bool heap_getnextslot_tidrange ( TableScanDesc  sscan,
ScanDirection  direction,
TupleTableSlot slot 
)

Definition at line 1404 of file heapam.c.

1406 {
1407  HeapScanDesc scan = (HeapScanDesc) sscan;
1408  ItemPointer mintid = &sscan->rs_mintid;
1409  ItemPointer maxtid = &sscan->rs_maxtid;
1410 
1411  /* Note: no locking manipulations needed */
1412  for (;;)
1413  {
1414  if (sscan->rs_flags & SO_ALLOW_PAGEMODE)
1415  heapgettup_pagemode(scan, direction, sscan->rs_nkeys, sscan->rs_key);
1416  else
1417  heapgettup(scan, direction, sscan->rs_nkeys, sscan->rs_key);
1418 
1419  if (scan->rs_ctup.t_data == NULL)
1420  {
1421  ExecClearTuple(slot);
1422  return false;
1423  }
1424 
1425  /*
1426  * heap_set_tidrange will have used heap_setscanlimits to limit the
1427  * range of pages we scan to only ones that can contain the TID range
1428  * we're scanning for. Here we must filter out any tuples from these
1429  * pages that are outside of that range.
1430  */
1431  if (ItemPointerCompare(&scan->rs_ctup.t_self, mintid) < 0)
1432  {
1433  ExecClearTuple(slot);
1434 
1435  /*
1436  * When scanning backwards, the TIDs will be in descending order.
1437  * Future tuples in this direction will be lower still, so we can
1438  * just return false to indicate there will be no more tuples.
1439  */
1440  if (ScanDirectionIsBackward(direction))
1441  return false;
1442 
1443  continue;
1444  }
1445 
1446  /*
1447  * Likewise for the final page, we must filter out TIDs greater than
1448  * maxtid.
1449  */
1450  if (ItemPointerCompare(&scan->rs_ctup.t_self, maxtid) > 0)
1451  {
1452  ExecClearTuple(slot);
1453 
1454  /*
1455  * When scanning forward, the TIDs will be in ascending order.
1456  * Future tuples in this direction will be higher still, so we can
1457  * just return false to indicate there will be no more tuples.
1458  */
1459  if (ScanDirectionIsForward(direction))
1460  return false;
1461  continue;
1462  }
1463 
1464  break;
1465  }
1466 
1467  /*
1468  * if we get here it means we have a new current scan tuple, so point to
1469  * the proper return buffer and return the tuple.
1470  */
1472 
1473  ExecStoreBufferHeapTuple(&scan->rs_ctup, slot, scan->rs_cbuf);
1474  return true;
1475 }
int32 ItemPointerCompare(ItemPointer arg1, ItemPointer arg2)
Definition: itemptr.c:51
#define ScanDirectionIsForward(direction)
Definition: sdir.h:64
#define ScanDirectionIsBackward(direction)
Definition: sdir.h:50
ItemPointerData rs_mintid
Definition: relscan.h:40
ItemPointerData rs_maxtid
Definition: relscan.h:41

References ExecClearTuple(), ExecStoreBufferHeapTuple(), heapgettup(), heapgettup_pagemode(), ItemPointerCompare(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_maxtid, TableScanDescData::rs_mintid, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, ScanDirectionIsBackward, ScanDirectionIsForward, SO_ALLOW_PAGEMODE, HeapTupleData::t_data, and HeapTupleData::t_self.

◆ heap_hot_search_buffer()

bool heap_hot_search_buffer ( ItemPointer  tid,
Relation  relation,
Buffer  buffer,
Snapshot  snapshot,
HeapTuple  heapTuple,
bool all_dead,
bool  first_call 
)

Definition at line 1631 of file heapam.c.

1634 {
1635  Page page = BufferGetPage(buffer);
1636  TransactionId prev_xmax = InvalidTransactionId;
1637  BlockNumber blkno;
1638  OffsetNumber offnum;
1639  bool at_chain_start;
1640  bool valid;
1641  bool skip;
1642  GlobalVisState *vistest = NULL;
1643 
1644  /* If this is not the first call, previous call returned a (live!) tuple */
1645  if (all_dead)
1646  *all_dead = first_call;
1647 
1648  blkno = ItemPointerGetBlockNumber(tid);
1649  offnum = ItemPointerGetOffsetNumber(tid);
1650  at_chain_start = first_call;
1651  skip = !first_call;
1652 
1653  /* XXX: we should assert that a snapshot is pushed or registered */
1655  Assert(BufferGetBlockNumber(buffer) == blkno);
1656 
1657  /* Scan through possible multiple members of HOT-chain */
1658  for (;;)
1659  {
1660  ItemId lp;
1661 
1662  /* check for bogus TID */
1663  if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
1664  break;
1665 
1666  lp = PageGetItemId(page, offnum);
1667 
1668  /* check for unused, dead, or redirected items */
1669  if (!ItemIdIsNormal(lp))
1670  {
1671  /* We should only see a redirect at start of chain */
1672  if (ItemIdIsRedirected(lp) && at_chain_start)
1673  {
1674  /* Follow the redirect */
1675  offnum = ItemIdGetRedirect(lp);
1676  at_chain_start = false;
1677  continue;
1678  }
1679  /* else must be end of chain */
1680  break;
1681  }
1682 
1683  /*
1684  * Update heapTuple to point to the element of the HOT chain we're
1685  * currently investigating. Having t_self set correctly is important
1686  * because the SSI checks and the *Satisfies routine for historical
1687  * MVCC snapshots need the correct tid to decide about the visibility.
1688  */
1689  heapTuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
1690  heapTuple->t_len = ItemIdGetLength(lp);
1691  heapTuple->t_tableOid = RelationGetRelid(relation);
1692  ItemPointerSet(&heapTuple->t_self, blkno, offnum);
1693 
1694  /*
1695  * Shouldn't see a HEAP_ONLY tuple at chain start.
1696  */
1697  if (at_chain_start && HeapTupleIsHeapOnly(heapTuple))
1698  break;
1699 
1700  /*
1701  * The xmin should match the previous xmax value, else chain is
1702  * broken.
1703  */
1704  if (TransactionIdIsValid(prev_xmax) &&
1705  !TransactionIdEquals(prev_xmax,
1706  HeapTupleHeaderGetXmin(heapTuple->t_data)))
1707  break;
1708 
1709  /*
1710  * When first_call is true (and thus, skip is initially false) we'll
1711  * return the first tuple we find. But on later passes, heapTuple
1712  * will initially be pointing to the tuple we returned last time.
1713  * Returning it again would be incorrect (and would loop forever), so
1714  * we skip it and return the next match we find.
1715  */
1716  if (!skip)
1717  {
1718  /* If it's visible per the snapshot, we must return it */
1719  valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
1720  HeapCheckForSerializableConflictOut(valid, relation, heapTuple,
1721  buffer, snapshot);
1722 
1723  if (valid)
1724  {
1725  ItemPointerSetOffsetNumber(tid, offnum);
1726  PredicateLockTID(relation, &heapTuple->t_self, snapshot,
1727  HeapTupleHeaderGetXmin(heapTuple->t_data));
1728  if (all_dead)
1729  *all_dead = false;
1730  return true;
1731  }
1732  }
1733  skip = false;
1734 
1735  /*
1736  * If we can't see it, maybe no one else can either. At caller
1737  * request, check whether all chain members are dead to all
1738  * transactions.
1739  *
1740  * Note: if you change the criterion here for what is "dead", fix the
1741  * planner's get_actual_variable_range() function to match.
1742  */
1743  if (all_dead && *all_dead)
1744  {
1745  if (!vistest)
1746  vistest = GlobalVisTestFor(relation);
1747 
1748  if (!HeapTupleIsSurelyDead(heapTuple, vistest))
1749  *all_dead = false;
1750  }
1751 
1752  /*
1753  * Check to see if HOT chain continues past this tuple; if so fetch
1754  * the next offnum and loop around.
1755  */
1756  if (HeapTupleIsHotUpdated(heapTuple))
1757  {
1759  blkno);
1760  offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
1761  at_chain_start = false;
1762  prev_xmax = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
1763  }
1764  else
1765  break; /* end of chain */
1766  }
1767 
1768  return false;
1769 }
bool HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
#define HeapTupleIsHeapOnly(tuple)
Definition: htup_details.h:683
#define HeapTupleIsHotUpdated(tuple)
Definition: htup_details.h:674
#define ItemIdGetRedirect(itemId)
Definition: itemid.h:78
#define ItemIdIsRedirected(itemId)
Definition: itemid.h:106
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static void ItemPointerSetOffsetNumber(ItemPointerData *pointer, OffsetNumber offsetNumber)
Definition: itemptr.h:158
static const struct exclude_list_item skip[]
Definition: pg_checksums.c:108
GlobalVisState * GlobalVisTestFor(Relation rel)
Definition: procarray.c:4111
TransactionId RecentXmin
Definition: snapmgr.c:99

References Assert, BufferGetBlockNumber(), BufferGetPage(), GlobalVisTestFor(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleIsHeapOnly, HeapTupleIsHotUpdated, HeapTupleIsSurelyDead(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerSet(), ItemPointerSetOffsetNumber(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), RecentXmin, RelationGetRelid, skip, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdEquals, and TransactionIdIsValid.

Referenced by heap_index_delete_tuples(), heapam_index_fetch_tuple(), and heapam_scan_bitmap_next_block().

◆ heap_index_delete_tuples()

TransactionId heap_index_delete_tuples ( Relation  rel,
TM_IndexDeleteOp delstate 
)

Definition at line 7636 of file heapam.c.

7637 {
7638  /* Initial assumption is that earlier pruning took care of conflict */
7639  TransactionId snapshotConflictHorizon = InvalidTransactionId;
7642  Page page = NULL;
7644  TransactionId priorXmax;
7645 #ifdef USE_PREFETCH
7646  IndexDeletePrefetchState prefetch_state;
7647  int prefetch_distance;
7648 #endif
7649  SnapshotData SnapshotNonVacuumable;
7650  int finalndeltids = 0,
7651  nblocksaccessed = 0;
7652 
7653  /* State that's only used in bottom-up index deletion case */
7654  int nblocksfavorable = 0;
7655  int curtargetfreespace = delstate->bottomupfreespace,
7656  lastfreespace = 0,
7657  actualfreespace = 0;
7658  bool bottomup_final_block = false;
7659 
7660  InitNonVacuumableSnapshot(SnapshotNonVacuumable, GlobalVisTestFor(rel));
7661 
7662  /* Sort caller's deltids array by TID for further processing */
7663  index_delete_sort(delstate);
7664 
7665  /*
7666  * Bottom-up case: resort deltids array in an order attuned to where the
7667  * greatest number of promising TIDs are to be found, and determine how
7668  * many blocks from the start of sorted array should be considered
7669  * favorable. This will also shrink the deltids array in order to
7670  * eliminate completely unfavorable blocks up front.
7671  */
7672  if (delstate->bottomup)
7673  nblocksfavorable = bottomup_sort_and_shrink(delstate);
7674 
7675 #ifdef USE_PREFETCH
7676  /* Initialize prefetch state. */
7677  prefetch_state.cur_hblkno = InvalidBlockNumber;
7678  prefetch_state.next_item = 0;
7679  prefetch_state.ndeltids = delstate->ndeltids;
7680  prefetch_state.deltids = delstate->deltids;
7681 
7682  /*
7683  * Determine the prefetch distance that we will attempt to maintain.
7684  *
7685  * Since the caller holds a buffer lock somewhere in rel, we'd better make
7686  * sure that isn't a catalog relation before we call code that does
7687  * syscache lookups, to avoid risk of deadlock.
7688  */
7689  if (IsCatalogRelation(rel))
7690  prefetch_distance = maintenance_io_concurrency;
7691  else
7692  prefetch_distance =
7694 
7695  /* Cap initial prefetch distance for bottom-up deletion caller */
7696  if (delstate->bottomup)
7697  {
7698  Assert(nblocksfavorable >= 1);
7699  Assert(nblocksfavorable <= BOTTOMUP_MAX_NBLOCKS);
7700  prefetch_distance = Min(prefetch_distance, nblocksfavorable);
7701  }
7702 
7703  /* Start prefetching. */
7704  index_delete_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
7705 #endif
7706 
7707  /* Iterate over deltids, determine which to delete, check their horizon */
7708  Assert(delstate->ndeltids > 0);
7709  for (int i = 0; i < delstate->ndeltids; i++)
7710  {
7711  TM_IndexDelete *ideltid = &delstate->deltids[i];
7712  TM_IndexStatus *istatus = delstate->status + ideltid->id;
7713  ItemPointer htid = &ideltid->tid;
7714  OffsetNumber offnum;
7715 
7716  /*
7717  * Read buffer, and perform required extra steps each time a new block
7718  * is encountered. Avoid refetching if it's the same block as the one
7719  * from the last htid.
7720  */
7721  if (blkno == InvalidBlockNumber ||
7722  ItemPointerGetBlockNumber(htid) != blkno)
7723  {
7724  /*
7725  * Consider giving up early for bottom-up index deletion caller
7726  * first. (Only prefetch next-next block afterwards, when it
7727  * becomes clear that we're at least going to access the next
7728  * block in line.)
7729  *
7730  * Sometimes the first block frees so much space for bottom-up
7731  * caller that the deletion process can end without accessing any
7732  * more blocks. It is usually necessary to access 2 or 3 blocks
7733  * per bottom-up deletion operation, though.
7734  */
7735  if (delstate->bottomup)
7736  {
7737  /*
7738  * We often allow caller to delete a few additional items
7739  * whose entries we reached after the point that space target
7740  * from caller was satisfied. The cost of accessing the page
7741  * was already paid at that point, so it made sense to finish
7742  * it off. When that happened, we finalize everything here
7743  * (by finishing off the whole bottom-up deletion operation
7744  * without needlessly paying the cost of accessing any more
7745  * blocks).
7746  */
7747  if (bottomup_final_block)
7748  break;
7749 
7750  /*
7751  * Give up when we didn't enable our caller to free any
7752  * additional space as a result of processing the page that we
7753  * just finished up with. This rule is the main way in which
7754  * we keep the cost of bottom-up deletion under control.
7755  */
7756  if (nblocksaccessed >= 1 && actualfreespace == lastfreespace)
7757  break;
7758  lastfreespace = actualfreespace; /* for next time */
7759 
7760  /*
7761  * Deletion operation (which is bottom-up) will definitely
7762  * access the next block in line. Prepare for that now.
7763  *
7764  * Decay target free space so that we don't hang on for too
7765  * long with a marginal case. (Space target is only truly
7766  * helpful when it allows us to recognize that we don't need
7767  * to access more than 1 or 2 blocks to satisfy caller due to
7768  * agreeable workload characteristics.)
7769  *
7770  * We are a bit more patient when we encounter contiguous
7771  * blocks, though: these are treated as favorable blocks. The
7772  * decay process is only applied when the next block in line
7773  * is not a favorable/contiguous block. This is not an
7774  * exception to the general rule; we still insist on finding
7775  * at least one deletable item per block accessed. See
7776  * bottomup_nblocksfavorable() for full details of the theory
7777  * behind favorable blocks and heap block locality in general.
7778  *
7779  * Note: The first block in line is always treated as a
7780  * favorable block, so the earliest possible point that the
7781  * decay can be applied is just before we access the second
7782  * block in line. The Assert() verifies this for us.
7783  */
7784  Assert(nblocksaccessed > 0 || nblocksfavorable > 0);
7785  if (nblocksfavorable > 0)
7786  nblocksfavorable--;
7787  else
7788  curtargetfreespace /= 2;
7789  }
7790 
7791  /* release old buffer */
7792  if (BufferIsValid(buf))
7794 
7795  blkno = ItemPointerGetBlockNumber(htid);
7796  buf = ReadBuffer(rel, blkno);
7797  nblocksaccessed++;
7798  Assert(!delstate->bottomup ||
7799  nblocksaccessed <= BOTTOMUP_MAX_NBLOCKS);
7800 
7801 #ifdef USE_PREFETCH
7802 
7803  /*
7804  * To maintain the prefetch distance, prefetch one more page for
7805  * each page we read.
7806  */
7807  index_delete_prefetch_buffer(rel, &prefetch_state, 1);
7808 #endif
7809 
7811 
7812  page = BufferGetPage(buf);
7813  maxoff = PageGetMaxOffsetNumber(page);
7814  }
7815 
7816  /*
7817  * In passing, detect index corruption involving an index page with a
7818  * TID that points to a location in the heap that couldn't possibly be
7819  * correct. We only do this with actual TIDs from caller's index page
7820  * (not items reached by traversing through a HOT chain).
7821  */
7822  index_delete_check_htid(delstate, page, maxoff, htid, istatus);
7823 
7824  if (istatus->knowndeletable)
7825  Assert(!delstate->bottomup && !istatus->promising);
7826  else
7827  {
7828  ItemPointerData tmp = *htid;
7829  HeapTupleData heapTuple;
7830 
7831  /* Are any tuples from this HOT chain non-vacuumable? */
7832  if (heap_hot_search_buffer(&tmp, rel, buf, &SnapshotNonVacuumable,
7833  &heapTuple, NULL, true))
7834  continue; /* can't delete entry */
7835 
7836  /* Caller will delete, since whole HOT chain is vacuumable */
7837  istatus->knowndeletable = true;
7838 
7839  /* Maintain index free space info for bottom-up deletion case */
7840  if (delstate->bottomup)
7841  {
7842  Assert(istatus->freespace > 0);
7843  actualfreespace += istatus->freespace;
7844  if (actualfreespace >= curtargetfreespace)
7845  bottomup_final_block = true;
7846  }
7847  }
7848 
7849  /*
7850  * Maintain snapshotConflictHorizon value for deletion operation as a
7851  * whole by advancing current value using heap tuple headers. This is
7852  * loosely based on the logic for pruning a HOT chain.
7853  */
7854  offnum = ItemPointerGetOffsetNumber(htid);
7855  priorXmax = InvalidTransactionId; /* cannot check first XMIN */
7856  for (;;)
7857  {
7858  ItemId lp;
7859  HeapTupleHeader htup;
7860 
7861  /* Sanity check (pure paranoia) */
7862  if (offnum < FirstOffsetNumber)
7863  break;
7864 
7865  /*
7866  * An offset past the end of page's line pointer array is possible
7867  * when the array was truncated
7868  */
7869  if (offnum > maxoff)
7870  break;
7871 
7872  lp = PageGetItemId(page, offnum);
7873  if (ItemIdIsRedirected(lp))
7874  {
7875  offnum = ItemIdGetRedirect(lp);
7876  continue;
7877  }
7878 
7879  /*
7880  * We'll often encounter LP_DEAD line pointers (especially with an
7881  * entry marked knowndeletable by our caller up front). No heap
7882  * tuple headers get examined for an htid that leads us to an
7883  * LP_DEAD item. This is okay because the earlier pruning
7884  * operation that made the line pointer LP_DEAD in the first place
7885  * must have considered the original tuple header as part of
7886  * generating its own snapshotConflictHorizon value.
7887  *
7888  * Relying on XLOG_HEAP2_PRUNE_VACUUM_SCAN records like this is
7889  * the same strategy that index vacuuming uses in all cases. Index
7890  * VACUUM WAL records don't even have a snapshotConflictHorizon
7891  * field of their own for this reason.
7892  */
7893  if (!ItemIdIsNormal(lp))
7894  break;
7895 
7896  htup = (HeapTupleHeader) PageGetItem(page, lp);
7897 
7898  /*
7899  * Check the tuple XMIN against prior XMAX, if any
7900  */
7901  if (TransactionIdIsValid(priorXmax) &&
7902  !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
7903  break;
7904 
7906  &snapshotConflictHorizon);
7907 
7908  /*
7909  * If the tuple is not HOT-updated, then we are at the end of this
7910  * HOT-chain. No need to visit later tuples from the same update
7911  * chain (they get their own index entries) -- just move on to
7912  * next htid from index AM caller.
7913  */
7914  if (!HeapTupleHeaderIsHotUpdated(htup))
7915  break;
7916 
7917  /* Advance to next HOT chain member */
7918  Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blkno);
7919  offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
7920  priorXmax = HeapTupleHeaderGetUpdateXid(htup);
7921  }
7922 
7923  /* Enable further/final shrinking of deltids for caller */
7924  finalndeltids = i + 1;
7925  }
7926 
7928 
7929  /*
7930  * Shrink deltids array to exclude non-deletable entries at the end. This
7931  * is not just a minor optimization. Final deltids array size might be
7932  * zero for a bottom-up caller. Index AM is explicitly allowed to rely on
7933  * ndeltids being zero in all cases with zero total deletable entries.
7934  */
7935  Assert(finalndeltids > 0 || delstate->bottomup);
7936  delstate->ndeltids = finalndeltids;
7937 
7938  return snapshotConflictHorizon;
7939 }
int maintenance_io_concurrency
Definition: bufmgr.c:157
bool IsCatalogRelation(Relation relation)
Definition: catalog.c:103
static int bottomup_sort_and_shrink(TM_IndexDeleteOp *delstate)
Definition: heapam.c:8194
void HeapTupleHeaderAdvanceConflictHorizon(HeapTupleHeader tuple, TransactionId *snapshotConflictHorizon)
Definition: heapam.c:7491
static void index_delete_check_htid(TM_IndexDeleteOp *delstate, Page page, OffsetNumber maxoff, ItemPointer htid, TM_IndexStatus *istatus)
Definition: heapam.c:7576
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
Definition: heapam.c:1631
static void index_delete_sort(TM_IndexDeleteOp *delstate)
Definition: heapam.c:7981
#define HeapTupleHeaderIsHotUpdated(tup)
Definition: htup_details.h:482
#define InvalidOffsetNumber
Definition: off.h:26
#define FirstOffsetNumber
Definition: off.h:27
static char * buf
Definition: pg_test_fsync.c:73
#define InitNonVacuumableSnapshot(snapshotdata, vistestp)
Definition: snapmgr.h:48
int get_tablespace_maintenance_io_concurrency(Oid spcid)
Definition: spccache.c:229
int bottomupfreespace
Definition: tableam.h:250
bool knowndeletable
Definition: tableam.h:220
int16 freespace
Definition: tableam.h:224

References Assert, TM_IndexDeleteOp::bottomup, BOTTOMUP_MAX_NBLOCKS, bottomup_sort_and_shrink(), TM_IndexDeleteOp::bottomupfreespace, buf, BUFFER_LOCK_SHARE, BufferGetPage(), BufferIsValid(), TM_IndexDeleteOp::deltids, FirstOffsetNumber, TM_IndexStatus::freespace, get_tablespace_maintenance_io_concurrency(), GlobalVisTestFor(), heap_hot_search_buffer(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleHeaderIsHotUpdated, i, TM_IndexDelete::id, index_delete_check_htid(), index_delete_sort(), InitNonVacuumableSnapshot, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, IsCatalogRelation(), ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), TM_IndexStatus::knowndeletable, LockBuffer(), maintenance_io_concurrency, Min, TM_IndexDeleteOp::ndeltids, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), TM_IndexStatus::promising, RelationData::rd_rel, ReadBuffer(), TM_IndexDeleteOp::status, HeapTupleHeaderData::t_ctid, TM_IndexDelete::tid, TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().

◆ heap_inplace_update()

void heap_inplace_update ( Relation  relation,
HeapTuple  tuple 
)

Definition at line 6063 of file heapam.c.

6064 {
6065  Buffer buffer;
6066  Page page;
6067  OffsetNumber offnum;
6068  ItemId lp = NULL;
6069  HeapTupleHeader htup;
6070  uint32 oldlen;
6071  uint32 newlen;
6072 
6073  /*
6074  * For now, we don't allow parallel updates. Unlike a regular update,
6075  * this should never create a combo CID, so it might be possible to relax
6076  * this restriction, but not without more thought and testing. It's not
6077  * clear that it would be useful, anyway.
6078  */
6079  if (IsInParallelMode())
6080  ereport(ERROR,
6081  (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
6082  errmsg("cannot update tuples during a parallel operation")));
6083 
6084  INJECTION_POINT("inplace-before-pin");
6085  buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&(tuple->t_self)));
6087  page = (Page) BufferGetPage(buffer);
6088 
6089  offnum = ItemPointerGetOffsetNumber(&(tuple->t_self));
6090  if (PageGetMaxOffsetNumber(page) >= offnum)
6091  lp = PageGetItemId(page, offnum);
6092 
6093  if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
6094  elog(ERROR, "invalid lp");
6095 
6096  htup = (HeapTupleHeader) PageGetItem(page, lp);
6097 
6098  oldlen = ItemIdGetLength(lp) - htup->t_hoff;
6099  newlen = tuple->t_len - tuple->t_data->t_hoff;
6100  if (oldlen != newlen || htup->t_hoff != tuple->t_data->t_hoff)
6101  elog(ERROR, "wrong tuple length");
6102 
6103  /* NO EREPORT(ERROR) from here till changes are logged */
6105 
6106  memcpy((char *) htup + htup->t_hoff,
6107  (char *) tuple->t_data + tuple->t_data->t_hoff,
6108  newlen);
6109 
6110  MarkBufferDirty(buffer);
6111 
6112  /* XLOG stuff */
6113  if (RelationNeedsWAL(relation))
6114  {
6115  xl_heap_inplace xlrec;
6116  XLogRecPtr recptr;
6117 
6118  xlrec.offnum = ItemPointerGetOffsetNumber(&tuple->t_self);
6119 
6120  XLogBeginInsert();
6121  XLogRegisterData((char *) &xlrec, SizeOfHeapInplace);
6122 
6123  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
6124  XLogRegisterBufData(0, (char *) htup + htup->t_hoff, newlen);
6125 
6126  /* inplace updates aren't decoded atm, don't log the origin */
6127 
6128  recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_INPLACE);
6129 
6130  PageSetLSN(page, recptr);
6131  }
6132 
6133  END_CRIT_SECTION();
6134 
6135  UnlockReleaseBuffer(buffer);
6136 
6137  /*
6138  * Send out shared cache inval if necessary. Note that because we only
6139  * pass the new version of the tuple, this mustn't be used for any
6140  * operations that could change catcache lookup keys. But we aren't
6141  * bothering with index updates either, so that's true a fortiori.
6142  */
6144  CacheInvalidateHeapTuple(relation, tuple, NULL);
6145 }
#define SizeOfHeapInplace
Definition: heapam_xlog.h:430
#define XLOG_HEAP_INPLACE
Definition: heapam_xlog.h:39
#define INJECTION_POINT(name)
#define IsBootstrapProcessingMode()
Definition: miscadmin.h:454
OffsetNumber offnum
Definition: heapam_xlog.h:427
void XLogRegisterBufData(uint8 block_id, char *data, uint32 len)
Definition: xloginsert.c:405

References BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), CacheInvalidateHeapTuple(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, INJECTION_POINT, IsBootstrapProcessingMode, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), MarkBufferDirty(), xl_heap_inplace::offnum, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageSetLSN(), ReadBuffer(), REGBUF_STANDARD, RelationNeedsWAL, SizeOfHeapInplace, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, HeapTupleData::t_len, HeapTupleData::t_self, UnlockReleaseBuffer(), XLOG_HEAP_INPLACE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by create_toast_table(), dropdb(), EventTriggerOnLogin(), index_update_stats(), vac_update_datfrozenxid(), and vac_update_relstats().

◆ heap_insert()

void heap_insert ( Relation  relation,
HeapTuple  tup,
CommandId  cid,
int  options,
BulkInsertState  bistate 
)

Definition at line 1994 of file heapam.c.

1996 {
1998  HeapTuple heaptup;
1999  Buffer buffer;
2000  Buffer vmbuffer = InvalidBuffer;
2001  bool all_visible_cleared = false;
2002 
2003  /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
2005  RelationGetNumberOfAttributes(relation));
2006 
2007  /*
2008  * Fill in tuple header fields and toast the tuple if necessary.
2009  *
2010  * Note: below this point, heaptup is the data we actually intend to store
2011  * into the relation; tup is the caller's original untoasted data.
2012  */
2013  heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
2014 
2015  /*
2016  * Find buffer to insert this tuple into. If the page is all visible,
2017  * this will also pin the requisite visibility map page.
2018  */
2019  buffer = RelationGetBufferForTuple(relation, heaptup->t_len,
2020  InvalidBuffer, options, bistate,
2021  &vmbuffer, NULL,
2022  0);
2023 
2024  /*
2025  * We're about to do the actual insert -- but check for conflict first, to
2026  * avoid possibly having to roll back work we've just done.
2027  *
2028  * This is safe without a recheck as long as there is no possibility of
2029  * another process scanning the page between this check and the insert
2030  * being visible to the scan (i.e., an exclusive buffer content lock is
2031  * continuously held from this point until the tuple insert is visible).
2032  *
2033  * For a heap insert, we only need to check for table-level SSI locks. Our
2034  * new tuple can't possibly conflict with existing tuple locks, and heap
2035  * page locks are only consolidated versions of tuple locks; they do not
2036  * lock "gaps" as index page locks do. So we don't need to specify a
2037  * buffer when making the call, which makes for a faster check.
2038  */
2040 
2041  /* NO EREPORT(ERROR) from here till changes are logged */
2043 
2044  RelationPutHeapTuple(relation, buffer, heaptup,
2045  (options & HEAP_INSERT_SPECULATIVE) != 0);
2046 
2047  if (PageIsAllVisible(BufferGetPage(buffer)))
2048  {
2049  all_visible_cleared = true;
2051  visibilitymap_clear(relation,
2052  ItemPointerGetBlockNumber(&(heaptup->t_self)),
2053  vmbuffer, VISIBILITYMAP_VALID_BITS);
2054  }
2055 
2056  /*
2057  * XXX Should we set PageSetPrunable on this page ?
2058  *
2059  * The inserting transaction may eventually abort thus making this tuple
2060  * DEAD and hence available for pruning. Though we don't want to optimize
2061  * for aborts, if no other tuple in this page is UPDATEd/DELETEd, the
2062  * aborted tuple will never be pruned until next vacuum is triggered.
2063  *
2064  * If you do add PageSetPrunable here, add it in heap_xlog_insert too.
2065  */
2066 
2067  MarkBufferDirty(buffer);
2068 
2069  /* XLOG stuff */
2070  if (RelationNeedsWAL(relation))
2071  {
2072  xl_heap_insert xlrec;
2073  xl_heap_header xlhdr;
2074  XLogRecPtr recptr;
2075  Page page = BufferGetPage(buffer);
2076  uint8 info = XLOG_HEAP_INSERT;
2077  int bufflags = 0;
2078 
2079  /*
2080  * If this is a catalog, we need to transmit combo CIDs to properly
2081  * decode, so log that as well.
2082  */
2084  log_heap_new_cid(relation, heaptup);
2085 
2086  /*
2087  * If this is the single and first tuple on page, we can reinit the
2088  * page instead of restoring the whole thing. Set flag, and hide
2089  * buffer references from XLogInsert.
2090  */
2091  if (ItemPointerGetOffsetNumber(&(heaptup->t_self)) == FirstOffsetNumber &&
2093  {
2094  info |= XLOG_HEAP_INIT_PAGE;
2095  bufflags |= REGBUF_WILL_INIT;
2096  }
2097 
2098  xlrec.offnum = ItemPointerGetOffsetNumber(&heaptup->t_self);
2099  xlrec.flags = 0;
2100  if (all_visible_cleared)
2105 
2106  /*
2107  * For logical decoding, we need the tuple even if we're doing a full
2108  * page write, so make sure it's included even if we take a full-page
2109  * image. (XXX We could alternatively store a pointer into the FPW).
2110  */
2111  if (RelationIsLogicallyLogged(relation) &&
2113  {
2115  bufflags |= REGBUF_KEEP_DATA;
2116 
2117  if (IsToastRelation(relation))
2119  }
2120 
2121  XLogBeginInsert();
2122  XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
2123 
2124  xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
2125  xlhdr.t_infomask = heaptup->t_data->t_infomask;
2126  xlhdr.t_hoff = heaptup->t_data->t_hoff;
2127 
2128  /*
2129  * note we mark xlhdr as belonging to buffer; if XLogInsert decides to
2130  * write the whole page to the xlog, we don't need to store
2131  * xl_heap_header in the xlog.
2132  */
2133  XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
2134  XLogRegisterBufData(0, (char *) &xlhdr, SizeOfHeapHeader);
2135  /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
2137  (char *) heaptup->t_data + SizeofHeapTupleHeader,
2138  heaptup->t_len - SizeofHeapTupleHeader);
2139 
2140  /* filtering by origin on a row level is much more efficient */
2142 
2143  recptr = XLogInsert(RM_HEAP_ID, info);
2144 
2145  PageSetLSN(page, recptr);
2146  }
2147 
2148  END_CRIT_SECTION();
2149 
2150  UnlockReleaseBuffer(buffer);
2151  if (vmbuffer != InvalidBuffer)
2152  ReleaseBuffer(vmbuffer);
2153 
2154  /*
2155  * If tuple is cachable, mark it for invalidation from the caches in case
2156  * we abort. Note it is OK to do this after releasing the buffer, because
2157  * the heaptup data structure is all in local memory, not in the shared
2158  * buffer.
2159  */
2160  CacheInvalidateHeapTuple(relation, heaptup, NULL);
2161 
2162  /* Note: speculative insertions are counted too, even if aborted later */
2163  pgstat_count_heap_insert(relation, 1);
2164 
2165  /*
2166  * If heaptup is a private copy, release it. Don't forget to copy t_self
2167  * back to the caller's image, too.
2168  */
2169  if (heaptup != tup)
2170  {
2171  tup->t_self = heaptup->t_self;
2172  heap_freetuple(heaptup);
2173  }
2174 }
static HeapTuple heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid, CommandId cid, int options)
Definition: heapam.c:2183
#define HEAP_INSERT_SPECULATIVE
Definition: heapam.h:38
#define HEAP_INSERT_NO_LOGICAL
Definition: heapam.h:37
#define XLH_INSERT_ON_TOAST_RELATION
Definition: heapam_xlog.h:75
#define XLH_INSERT_IS_SPECULATIVE
Definition: heapam_xlog.h:73
#define XLH_INSERT_ALL_VISIBLE_CLEARED
Definition: heapam_xlog.h:71
#define XLOG_HEAP_INSERT
Definition: heapam_xlog.h:32
#define SizeOfHeapInsert
Definition: heapam_xlog.h:167
#define XLH_INSERT_CONTAINS_NEW_TUPLE
Definition: heapam_xlog.h:74
#define XLOG_HEAP_INIT_PAGE
Definition: heapam_xlog.h:46
void RelationPutHeapTuple(Relation relation, Buffer buffer, HeapTuple tuple, bool token)
Definition: hio.c:35
Buffer RelationGetBufferForTuple(Relation relation, Size len, Buffer otherBuffer, int options, BulkInsertState bistate, Buffer *vmbuffer, Buffer *vmbuffer_other, int num_pages)
Definition: hio.c:502
#define HeapTupleHeaderGetNatts(tup)
Definition: htup_details.h:529
void pgstat_count_heap_insert(Relation rel, PgStat_Counter n)
#define RelationGetNumberOfAttributes(relation)
Definition: rel.h:511
OffsetNumber offnum
Definition: heapam_xlog.h:161
#define REGBUF_KEEP_DATA
Definition: xloginsert.h:35
#define REGBUF_WILL_INIT
Definition: xloginsert.h:33

References Assert, BufferGetBlockNumber(), BufferGetPage(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), END_CRIT_SECTION, FirstOffsetNumber, xl_heap_insert::flags, GetCurrentTransactionId(), heap_freetuple(), HEAP_INSERT_NO_LOGICAL, HEAP_INSERT_SPECULATIVE, heap_prepare_insert(), HeapTupleHeaderGetNatts, InvalidBlockNumber, InvalidBuffer, IsToastRelation(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), log_heap_new_cid(), MarkBufferDirty(), xl_heap_insert::offnum, PageClearAllVisible(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetLSN(), pgstat_count_heap_insert(), REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetNumberOfAttributes, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SizeOfHeapHeader, SizeOfHeapInsert, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, UnlockReleaseBuffer(), visibilitymap_clear(), VISIBILITYMAP_VALID_BITS, XLH_INSERT_ALL_VISIBLE_CLEARED, XLH_INSERT_CONTAINS_NEW_TUPLE, XLH_INSERT_IS_SPECULATIVE, XLH_INSERT_ON_TOAST_RELATION, XLOG_HEAP_INIT_PAGE, XLOG_HEAP_INSERT, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().

Referenced by heapam_tuple_insert(), heapam_tuple_insert_speculative(), simple_heap_insert(), and toast_save_datum().

◆ heap_lock_tuple()

TM_Result heap_lock_tuple ( Relation  relation,
HeapTuple  tuple,
CommandId  cid,
LockTupleMode  mode,
LockWaitPolicy  wait_policy,
bool  follow_updates,
Buffer buffer,
TM_FailureData tmfd 
)

Definition at line 4310 of file heapam.c.

4314 {
4315  TM_Result result;
4316  ItemPointer tid = &(tuple->t_self);
4317  ItemId lp;
4318  Page page;
4319  Buffer vmbuffer = InvalidBuffer;
4320  BlockNumber block;
4321  TransactionId xid,
4322  xmax;
4323  uint16 old_infomask,
4324  new_infomask,
4325  new_infomask2;
4326  bool first_time = true;
4327  bool skip_tuple_lock = false;
4328  bool have_tuple_lock = false;
4329  bool cleared_all_frozen = false;
4330 
4331  *buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
4332  block = ItemPointerGetBlockNumber(tid);
4333 
4334  /*
4335  * Before locking the buffer, pin the visibility map page if it appears to
4336  * be necessary. Since we haven't got the lock yet, someone else might be
4337  * in the middle of changing this, so we'll need to recheck after we have
4338  * the lock.
4339  */
4340  if (PageIsAllVisible(BufferGetPage(*buffer)))
4341  visibilitymap_pin(relation, block, &vmbuffer);
4342 
4344 
4345  page = BufferGetPage(*buffer);
4346  lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
4347  Assert(ItemIdIsNormal(lp));
4348 
4349  tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
4350  tuple->t_len = ItemIdGetLength(lp);
4351  tuple->t_tableOid = RelationGetRelid(relation);
4352 
4353 l3:
4354  result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
4355 
4356  if (result == TM_Invisible)
4357  {
4358  /*
4359  * This is possible, but only when locking a tuple for ON CONFLICT
4360  * UPDATE. We return this value here rather than throwing an error in
4361  * order to give that case the opportunity to throw a more specific
4362  * error.
4363  */
4364  result = TM_Invisible;
4365  goto out_locked;
4366  }
4367  else if (result == TM_BeingModified ||
4368  result == TM_Updated ||
4369  result == TM_Deleted)
4370  {
4371  TransactionId xwait;
4372  uint16 infomask;
4373  uint16 infomask2;
4374  bool require_sleep;
4375  ItemPointerData t_ctid;
4376 
4377  /* must copy state data before unlocking buffer */
4378  xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
4379  infomask = tuple->t_data->t_infomask;
4380  infomask2 = tuple->t_data->t_infomask2;
4381  ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
4382 
4383  LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
4384 
4385  /*
4386  * If any subtransaction of the current top transaction already holds
4387  * a lock as strong as or stronger than what we're requesting, we
4388  * effectively hold the desired lock already. We *must* succeed
4389  * without trying to take the tuple lock, else we will deadlock
4390  * against anyone wanting to acquire a stronger lock.
4391  *
4392  * Note we only do this the first time we loop on the HTSU result;
4393  * there is no point in testing in subsequent passes, because
4394  * evidently our own transaction cannot have acquired a new lock after
4395  * the first time we checked.
4396  */
4397  if (first_time)
4398  {
4399  first_time = false;
4400 
4401  if (infomask & HEAP_XMAX_IS_MULTI)
4402  {
4403  int i;
4404  int nmembers;
4405  MultiXactMember *members;
4406 
4407  /*
4408  * We don't need to allow old multixacts here; if that had
4409  * been the case, HeapTupleSatisfiesUpdate would have returned
4410  * MayBeUpdated and we wouldn't be here.
4411  */
4412  nmembers =
4413  GetMultiXactIdMembers(xwait, &members, false,
4414  HEAP_XMAX_IS_LOCKED_ONLY(infomask));
4415 
4416  for (i = 0; i < nmembers; i++)
4417  {
4418  /* only consider members of our own transaction */
4419  if (!TransactionIdIsCurrentTransactionId(members[i].xid))
4420  continue;
4421 
4422  if (TUPLOCK_from_mxstatus(members[i].status) >= mode)
4423  {
4424  pfree(members);
4425  result = TM_Ok;
4426  goto out_unlocked;
4427  }
4428  else
4429  {
4430  /*
4431  * Disable acquisition of the heavyweight tuple lock.
4432  * Otherwise, when promoting a weaker lock, we might
4433  * deadlock with another locker that has acquired the
4434  * heavyweight tuple lock and is waiting for our
4435  * transaction to finish.
4436  *
4437  * Note that in this case we still need to wait for
4438  * the multixact if required, to avoid acquiring
4439  * conflicting locks.
4440  */
4441  skip_tuple_lock = true;
4442  }
4443  }
4444 
4445  if (members)
4446  pfree(members);
4447  }
4448  else if (TransactionIdIsCurrentTransactionId(xwait))
4449  {
4450  switch (mode)
4451  {
4452  case LockTupleKeyShare:
4453  Assert(HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) ||
4454  HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
4455  HEAP_XMAX_IS_EXCL_LOCKED(infomask));
4456  result = TM_Ok;
4457  goto out_unlocked;
4458  case LockTupleShare:
4459  if (HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
4460  HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4461  {
4462  result = TM_Ok;
4463  goto out_unlocked;
4464  }
4465  break;
4467  if (HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4468  {
4469  result = TM_Ok;
4470  goto out_unlocked;
4471  }
4472  break;
4473  case LockTupleExclusive:
4474  if (HEAP_XMAX_IS_EXCL_LOCKED(infomask) &&
4475  infomask2 & HEAP_KEYS_UPDATED)
4476  {
4477  result = TM_Ok;
4478  goto out_unlocked;
4479  }
4480  break;
4481  }
4482  }
4483  }
4484 
4485  /*
4486  * Initially assume that we will have to wait for the locking
4487  * transaction(s) to finish. We check various cases below in which
4488  * this can be turned off.
4489  */
4490  require_sleep = true;
4491  if (mode == LockTupleKeyShare)
4492  {
4493  /*
4494  * If we're requesting KeyShare, and there's no update present, we
4495  * don't need to wait. Even if there is an update, we can still
4496  * continue if the key hasn't been modified.
4497  *
4498  * However, if there are updates, we need to walk the update chain
4499  * to mark future versions of the row as locked, too. That way,
4500  * if somebody deletes that future version, we're protected
4501  * against the key going away. This locking of future versions
4502  * could block momentarily, if a concurrent transaction is
4503  * deleting a key; or it could return a value to the effect that
4504  * the transaction deleting the key has already committed. So we
4505  * do this before re-locking the buffer; otherwise this would be
4506  * prone to deadlocks.
4507  *
4508  * Note that the TID we're locking was grabbed before we unlocked
4509  * the buffer. For it to change while we're not looking, the
4510  * other properties we're testing for below after re-locking the
4511  * buffer would also change, in which case we would restart this
4512  * loop above.
4513  */
4514  if (!(infomask2 & HEAP_KEYS_UPDATED))
4515  {
4516  bool updated;
4517 
4518  updated = !HEAP_XMAX_IS_LOCKED_ONLY(infomask);
4519 
4520  /*
4521  * If there are updates, follow the update chain; bail out if
4522  * that cannot be done.
4523  */
4524  if (follow_updates && updated)
4525  {
4526  TM_Result res;
4527 
4528  res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
4530  mode);
4531  if (res != TM_Ok)
4532  {
4533  result = res;
4534  /* recovery code expects to have buffer lock held */
4536  goto failed;
4537  }
4538  }
4539 
4541 
4542  /*
4543  * Make sure it's still an appropriate lock, else start over.
4544  * Also, if it wasn't updated before we released the lock, but
4545  * is updated now, we start over too; the reason is that we
4546  * now need to follow the update chain to lock the new
4547  * versions.
4548  */
4549  if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
4550  ((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
4551  !updated))
4552  goto l3;
4553 
4554  /* Things look okay, so we can skip sleeping */
4555  require_sleep = false;
4556 
4557  /*
4558  * Note we allow Xmax to change here; other updaters/lockers
4559  * could have modified it before we grabbed the buffer lock.
4560  * However, this is not a problem, because with the recheck we
4561  * just did we ensure that they still don't conflict with the
4562  * lock we want.
4563  */
4564  }
4565  }
4566  else if (mode == LockTupleShare)
4567  {
4568  /*
4569  * If we're requesting Share, we can similarly avoid sleeping if
4570  * there's no update and no exclusive lock present.
4571  */
4572  if (HEAP_XMAX_IS_LOCKED_ONLY(infomask) &&
4573  !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
4574  {
4576 
4577  /*
4578  * Make sure it's still an appropriate lock, else start over.
4579  * See above about allowing xmax to change.
4580  */
4581  if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
4583  goto l3;
4584  require_sleep = false;
4585  }
4586  }
4587  else if (mode == LockTupleNoKeyExclusive)
4588  {
4589  /*
4590  * If we're requesting NoKeyExclusive, we might also be able to
4591  * avoid sleeping; just ensure that there no conflicting lock
4592  * already acquired.
4593  */
4594  if (infomask & HEAP_XMAX_IS_MULTI)
4595  {
4596  if (!DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
4597  mode, NULL))
4598  {
4599  /*
4600  * No conflict, but if the xmax changed under us in the
4601  * meantime, start over.
4602  */
4604  if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
4606  xwait))
4607  goto l3;
4608 
4609  /* otherwise, we're good */
4610  require_sleep = false;
4611  }
4612  }
4613  else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
4614  {
4616 
4617  /* if the xmax changed in the meantime, start over */
4618  if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
4620  xwait))
4621  goto l3;
4622  /* otherwise, we're good */
4623  require_sleep = false;
4624  }
4625  }
4626 
4627  /*
4628  * As a check independent from those above, we can also avoid sleeping
4629  * if the current transaction is the sole locker of the tuple. Note
4630  * that the strength of the lock already held is irrelevant; this is
4631  * not about recording the lock in Xmax (which will be done regardless
4632  * of this optimization, below). Also, note that the cases where we
4633  * hold a lock stronger than we are requesting are already handled
4634  * above by not doing anything.
4635  *
4636  * Note we only deal with the non-multixact case here; MultiXactIdWait
4637  * is well equipped to deal with this situation on its own.
4638  */
4639  if (require_sleep && !(infomask & HEAP_XMAX_IS_MULTI) &&
4641  {
4642  /* ... but if the xmax changed in the meantime, start over */
4644  if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
4646  xwait))
4647  goto l3;
4649  require_sleep = false;
4650  }
4651 
4652  /*
4653  * Time to sleep on the other transaction/multixact, if necessary.
4654  *
4655  * If the other transaction is an update/delete that's already
4656  * committed, then sleeping cannot possibly do any good: if we're
4657  * required to sleep, get out to raise an error instead.
4658  *
4659  * By here, we either have already acquired the buffer exclusive lock,
4660  * or we must wait for the locking transaction or multixact; so below
4661  * we ensure that we grab buffer lock after the sleep.
4662  */
4663  if (require_sleep && (result == TM_Updated || result == TM_Deleted))
4664  {
4666  goto failed;
4667  }
4668  else if (require_sleep)
4669  {
4670  /*
4671  * Acquire tuple lock to establish our priority for the tuple, or
4672  * die trying. LockTuple will release us when we are next-in-line
4673  * for the tuple. We must do this even if we are share-locking,
4674  * but not if we already have a weaker lock on the tuple.
4675  *
4676  * If we are forced to "start over" below, we keep the tuple lock;
4677  * this arranges that we stay at the head of the line while
4678  * rechecking tuple state.
4679  */
4680  if (!skip_tuple_lock &&
4681  !heap_acquire_tuplock(relation, tid, mode, wait_policy,
4682  &have_tuple_lock))
4683  {
4684  /*
4685  * This can only happen if wait_policy is Skip and the lock
4686  * couldn't be obtained.
4687  */
4688  result = TM_WouldBlock;
4689  /* recovery code expects to have buffer lock held */
4691  goto failed;
4692  }
4693 
4694  if (infomask & HEAP_XMAX_IS_MULTI)
4695  {
4697 
4698  /* We only ever lock tuples, never update them */
4699  if (status >= MultiXactStatusNoKeyUpdate)
4700  elog(ERROR, "invalid lock mode in heap_lock_tuple");
4701 
4702  /* wait for multixact to end, or die trying */
4703  switch (wait_policy)
4704  {
4705  case LockWaitBlock:
4706  MultiXactIdWait((MultiXactId) xwait, status, infomask,
4707  relation, &tuple->t_self, XLTW_Lock, NULL);
4708  break;
4709  case LockWaitSkip:
4711  status, infomask, relation,
4712  NULL))
4713  {
4714  result = TM_WouldBlock;
4715  /* recovery code expects to have buffer lock held */
4717  goto failed;
4718  }
4719  break;
4720  case LockWaitError:
4722  status, infomask, relation,
4723  NULL))
4724  ereport(ERROR,
4725  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
4726  errmsg("could not obtain lock on row in relation \"%s\"",
4727  RelationGetRelationName(relation))));
4728 
4729  break;
4730  }
4731 
4732  /*
4733  * Of course, the multixact might not be done here: if we're
4734  * requesting a light lock mode, other transactions with light
4735  * locks could still be alive, as well as locks owned by our
4736  * own xact or other subxacts of this backend. We need to
4737  * preserve the surviving MultiXact members. Note that it
4738  * isn't absolutely necessary in the latter case, but doing so
4739  * is simpler.
4740  */
4741  }
4742  else
4743  {
4744  /* wait for regular transaction to end, or die trying */
4745  switch (wait_policy)
4746  {
4747  case LockWaitBlock:
4748  XactLockTableWait(xwait, relation, &tuple->t_self,
4749  XLTW_Lock);
4750  break;
4751  case LockWaitSkip:
4752  if (!ConditionalXactLockTableWait(xwait))
4753  {
4754  result = TM_WouldBlock;
4755  /* recovery code expects to have buffer lock held */
4757  goto failed;
4758  }
4759  break;
4760  case LockWaitError:
4761  if (!ConditionalXactLockTableWait(xwait))
4762  ereport(ERROR,
4763  (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
4764  errmsg("could not obtain lock on row in relation \"%s\"",
4765  RelationGetRelationName(relation))));
4766  break;
4767  }
4768  }
4769 
4770  /* if there are updates, follow the update chain */
4771  if (follow_updates && !HEAP_XMAX_IS_LOCKED_ONLY(infomask))
4772  {
4773  TM_Result res;
4774 
4775  res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
4777  mode);
4778  if (res != TM_Ok)
4779  {
4780  result = res;
4781  /* recovery code expects to have buffer lock held */
4783  goto failed;