#include "access/relation.h"
#include "access/relscan.h"
#include "access/sdir.h"
#include "access/skey.h"
#include "access/table.h"
#include "access/tableam.h"
#include "nodes/lockoptions.h"
#include "nodes/primnodes.h"
#include "storage/bufpage.h"
#include "storage/lockdefs.h"
#include "utils/relcache.h"
#include "utils/snapshot.h"

Include dependency graph for heapam.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	HeapScanDescData

struct	IndexFetchHeapData

Macros
#define	HEAP_INSERT_SKIP_WAL TABLE_INSERT_SKIP_WAL

#define	HEAP_INSERT_SKIP_FSM TABLE_INSERT_SKIP_FSM

#define	HEAP_INSERT_FROZEN TABLE_INSERT_FROZEN

#define	HEAP_INSERT_NO_LOGICAL TABLE_INSERT_NO_LOGICAL

#define	HEAP_INSERT_SPECULATIVE 0x0010

#define	MaxLockTupleMode LockTupleExclusive

#define	HeapScanIsValid(scan) PointerIsValid(scan)

Typedefs
typedef struct BulkInsertStateData *	BulkInsertState

typedef struct HeapScanDescData	HeapScanDescData

typedef struct HeapScanDescData *	HeapScanDesc

typedef struct IndexFetchHeapData	IndexFetchHeapData

Enumerations
enum	HTSV_Result { HEAPTUPLE_DEAD, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_DELETE_IN_PROGRESS }

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

void	heap_setscanlimits (TableScanDesc scan, BlockNumber startBlk, BlockNumber numBlks)

void	heapgetpage (TableScanDesc scan, BlockNumber page)

void	heap_rescan (TableScanDesc scan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)

void	heap_endscan (TableScanDesc scan)

HeapTuple	heap_getnext (TableScanDesc scan, ScanDirection direction)

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

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

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 scan, ItemPointer tid)

void	setLastTid (const ItemPointer tid)

BulkInsertState	GetBulkInsertState (void)

void	FreeBulkInsertState (BulkInsertState)

void	ReleaseBulkInsertStatePin (BulkInsertState bistate)

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

void	heap_multi_insert (Relation relation, struct TupleTableSlot **slots, int ntuples, CommandId cid, int options, BulkInsertState bistate)

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

void	heap_finish_speculative (Relation relation, ItemPointer tid)

void	heap_abort_speculative (Relation relation, ItemPointer tid)

TM_Result	heap_update (Relation relation, ItemPointer otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, struct TM_FailureData tmfd, LockTupleMode lockmode)

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

void	heap_inplace_update (Relation relation, HeapTuple tuple)

bool	heap_freeze_tuple (HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId cutoff_xid, TransactionId cutoff_multi)

bool	heap_tuple_needs_freeze (HeapTupleHeader tuple, TransactionId cutoff_xid, MultiXactId cutoff_multi, Buffer buf)

bool	heap_tuple_needs_eventual_freeze (HeapTupleHeader tuple)

void	simple_heap_insert (Relation relation, HeapTuple tup)

void	simple_heap_delete (Relation relation, ItemPointer tid)

void	simple_heap_update (Relation relation, ItemPointer otid, HeapTuple tup)

void	heap_sync (Relation relation)

TransactionId	heap_compute_xid_horizon_for_tuples (Relation rel, ItemPointerData *items, int nitems)

void	heap_page_prune_opt (Relation relation, Buffer buffer)

int	heap_page_prune (Relation relation, Buffer buffer, TransactionId OldestXmin, bool report_stats, TransactionId *latestRemovedXid)

void	heap_page_prune_execute (Buffer buffer, OffsetNumber redirected, int nredirected, OffsetNumber nowdead, int ndead, OffsetNumber *nowunused, int nunused)

void	heap_get_root_tuples (Page page, OffsetNumber *root_offsets)

void	ss_report_location (Relation rel, BlockNumber location)

BlockNumber	ss_get_location (Relation rel, BlockNumber relnblocks)

void	SyncScanShmemInit (void)

Size	SyncScanShmemSize (void)

void	heap_vacuum_rel (Relation onerel, struct VacuumParams *params, BufferAccessStrategy bstrategy)

bool	HeapTupleSatisfiesVisibility (HeapTuple stup, Snapshot snapshot, Buffer buffer)

TM_Result	HeapTupleSatisfiesUpdate (HeapTuple stup, CommandId curcid, Buffer buffer)

HTSV_Result	HeapTupleSatisfiesVacuum (HeapTuple stup, TransactionId OldestXmin, Buffer buffer)

void	HeapTupleSetHintBits (HeapTupleHeader tuple, Buffer buffer, uint16 infomask, TransactionId xid)

bool	HeapTupleHeaderIsOnlyLocked (HeapTupleHeader tuple)

bool	XidInMVCCSnapshot (TransactionId xid, Snapshot snapshot)

bool	HeapTupleIsSurelyDead (HeapTuple htup, TransactionId OldestXmin)

bool	ResolveCminCmaxDuringDecoding (struct HTAB tuplecid_data, Snapshot snapshot, HeapTuple htup, Buffer buffer, CommandId cmin, CommandId *cmax)

Macro Definition Documentation

◆ HEAP_INSERT_FROZEN

#define HEAP_INSERT_FROZEN TABLE_INSERT_FROZEN

Definition at line 34 of file heapam.h.

Referenced by heap_prepare_insert().

◆ HEAP_INSERT_NO_LOGICAL

#define HEAP_INSERT_NO_LOGICAL TABLE_INSERT_NO_LOGICAL

Definition at line 35 of file heapam.h.

Referenced by heap_insert(), heap_multi_insert(), and raw_heap_insert().

◆ HEAP_INSERT_SKIP_FSM

#define HEAP_INSERT_SKIP_FSM TABLE_INSERT_SKIP_FSM

Definition at line 33 of file heapam.h.

Referenced by raw_heap_insert(), and RelationGetBufferForTuple().

◆ HEAP_INSERT_SKIP_WAL

#define HEAP_INSERT_SKIP_WAL TABLE_INSERT_SKIP_WAL

Definition at line 32 of file heapam.h.

Referenced by heap_insert(), heap_multi_insert(), heapam_finish_bulk_insert(), and raw_heap_insert().

◆ HEAP_INSERT_SPECULATIVE

#define HEAP_INSERT_SPECULATIVE 0x0010

Definition at line 36 of file heapam.h.

Referenced by heap_insert(), heap_toast_insert_or_update(), and heapam_tuple_insert_speculative().

◆ HeapScanIsValid

#define HeapScanIsValid ( scan ) PointerIsValid(scan)

Definition at line 108 of file heapam.h.

◆ MaxLockTupleMode

#define MaxLockTupleMode LockTupleExclusive

Definition at line 41 of file heapam.h.

Typedef Documentation

◆ BulkInsertState

typedef struct BulkInsertStateData* BulkInsertState

Definition at line 38 of file heapam.h.

◆ HeapScanDesc

typedef struct HeapScanDescData* HeapScanDesc

Definition at line 72 of file heapam.h.

◆ HeapScanDescData

typedef struct HeapScanDescData HeapScanDescData

◆ IndexFetchHeapData

typedef struct IndexFetchHeapData IndexFetchHeapData

Enumeration Type Documentation

◆ HTSV_Result

enum HTSV_Result

Enumerator
HEAPTUPLE_DEAD
HEAPTUPLE_LIVE
HEAPTUPLE_RECENTLY_DEAD
HEAPTUPLE_INSERT_IN_PROGRESS
HEAPTUPLE_DELETE_IN_PROGRESS

Definition at line 86 of file heapam.h.

 {
     HEAPTUPLE_DEAD,             /* tuple is dead and deletable */
     HEAPTUPLE_LIVE,             /* tuple is live (committed, no deleter) */
     HEAPTUPLE_RECENTLY_DEAD,    /* tuple is dead, but not deletable yet */
     HEAPTUPLE_INSERT_IN_PROGRESS,   /* inserting xact is still in progress */
     HEAPTUPLE_DELETE_IN_PROGRESS    /* deleting xact is still in progress */
 } HTSV_Result;

Function Documentation

◆ FreeBulkInsertState()

void FreeBulkInsertState ( BulkInsertState )

Definition at line 1829 of file heapam.c.

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

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

 {
     if (bistate->current_buf != InvalidBuffer)
         ReleaseBuffer(bistate->current_buf);
     FreeAccessStrategy(bistate->strategy);
     pfree(bistate);
 }

◆ GetBulkInsertState()

BulkInsertState GetBulkInsertState ( void )

Definition at line 1815 of file heapam.c.

References BAS_BULKWRITE, BulkInsertStateData::current_buf, GetAccessStrategy(), InvalidBuffer, palloc(), and BulkInsertStateData::strategy.

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

 {
     BulkInsertState bistate;
 
     bistate = (BulkInsertState) palloc(sizeof(BulkInsertStateData));
     bistate->strategy = GetAccessStrategy(BAS_BULKWRITE);
     bistate->current_buf = InvalidBuffer;
     return bistate;
 }

◆ heap_abort_speculative()

void heap_abort_speculative	(	Relation	relation,
		ItemPointer	tid
	)

Definition at line 5567 of file heapam.c.

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(), ReadBuffer(), RecentGlobalXmin, 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, 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().

 {
     TransactionId xid = GetCurrentTransactionId();
     ItemId      lp;
     HeapTupleData tp;
     Page        page;
     BlockNumber block;
     Buffer      buffer;
 
     Assert(ItemPointerIsValid(tid));
 
     block = ItemPointerGetBlockNumber(tid);
     buffer = ReadBuffer(relation, block);
     page = BufferGetPage(buffer);
 
     LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
     /*
      * Page can't be all visible, we just inserted into it, and are still
      * running.
      */
     Assert(!PageIsAllVisible(page));
 
     lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
     Assert(ItemIdIsNormal(lp));
 
     tp.t_tableOid = RelationGetRelid(relation);
     tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
     tp.t_len = ItemIdGetLength(lp);
     tp.t_self = *tid;
 
     /*
      * Sanity check that the tuple really is a speculatively inserted tuple,
      * inserted by us.
      */
     if (tp.t_data->t_choice.t_heap.t_xmin != xid)
         elog(ERROR, "attempted to kill a tuple inserted by another transaction");
     if (!(IsToastRelation(relation) || HeapTupleHeaderIsSpeculative(tp.t_data)))
         elog(ERROR, "attempted to kill a non-speculative tuple");
     Assert(!HeapTupleHeaderIsHeapOnly(tp.t_data));
 
     /*
      * No need to check for serializable conflicts here.  There is never a
      * need for a combocid, either.  No need to extract replica identity, or
      * do anything special with infomask bits.
      */
 
     START_CRIT_SECTION();
 
     /*
      * The tuple will become DEAD immediately.  Flag that this page
      * immediately is a candidate for pruning by setting xmin to
      * RecentGlobalXmin.  That's not pretty, but it doesn't seem worth
      * inventing a nicer API for this.
      */
     Assert(TransactionIdIsValid(RecentGlobalXmin));
     PageSetPrunable(page, RecentGlobalXmin);
 
     /* store transaction information of xact deleting the tuple */
     tp.t_data->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
     tp.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
 
     /*
      * Set the tuple header xmin to InvalidTransactionId.  This makes the
      * tuple immediately invisible everyone.  (In particular, to any
      * transactions waiting on the speculative token, woken up later.)
      */
     HeapTupleHeaderSetXmin(tp.t_data, InvalidTransactionId);
 
     /* Clear the speculative insertion token too */
     tp.t_data->t_ctid = tp.t_self;
 
     MarkBufferDirty(buffer);
 
     /*
      * XLOG stuff
      *
      * The WAL records generated here match heap_delete().  The same recovery
      * routines are used.
      */
     if (RelationNeedsWAL(relation))
     {
         xl_heap_delete xlrec;
         XLogRecPtr  recptr;
 
         xlrec.flags = XLH_DELETE_IS_SUPER;
         xlrec.infobits_set = compute_infobits(tp.t_data->t_infomask,
                                               tp.t_data->t_infomask2);
         xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
         xlrec.xmax = xid;
 
         XLogBeginInsert();
         XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
         XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
         /* No replica identity & replication origin logged */
 
         recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
     if (HeapTupleHasExternal(&tp))
     {
         Assert(!IsToastRelation(relation));
         heap_toast_delete(relation, &tp, true);
     }
 
     /*
      * Never need to mark tuple for invalidation, since catalogs don't support
      * speculative insertion
      */
 
     /* Now we can release the buffer */
     ReleaseBuffer(buffer);
 
     /* count deletion, as we counted the insertion too */
     pgstat_count_heap_delete(relation);
 }

◆ heap_beginscan()

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

Definition at line 1132 of file heapam.c.

References Assert, initscan(), IsMVCCSnapshot, palloc(), PredicateLockRelation(), RelationGetRelid, RelationIncrementReferenceCount(), HeapScanDescData::rs_base, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_parallel, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, SO_ALLOW_PAGEMODE, SO_TYPE_SAMPLESCAN, SO_TYPE_SEQSCAN, and HeapTupleData::t_tableOid.

Referenced by SampleHeapTupleVisible().

 {
     HeapScanDesc scan;
 
     /*
      * increment relation ref count while scanning relation
      *
      * This is just to make really sure the relcache entry won't go away while
      * the scan has a pointer to it.  Caller should be holding the rel open
      * anyway, so this is redundant in all normal scenarios...
      */
     RelationIncrementReferenceCount(relation);
 
     /*
      * allocate and initialize scan descriptor
      */
     scan = (HeapScanDesc) palloc(sizeof(HeapScanDescData));
 
     scan->rs_base.rs_rd = relation;
     scan->rs_base.rs_snapshot = snapshot;
     scan->rs_base.rs_nkeys = nkeys;
     scan->rs_base.rs_flags = flags;
     scan->rs_base.rs_parallel = parallel_scan;
     scan->rs_strategy = NULL;   /* set in initscan */
 
     /*
      * Disable page-at-a-time mode if it's not a MVCC-safe snapshot.
      */
     if (!(snapshot && IsMVCCSnapshot(snapshot)))
         scan->rs_base.rs_flags &= ~SO_ALLOW_PAGEMODE;
 
     /*
      * For seqscan and sample scans in a serializable transaction, acquire a
      * predicate lock on the entire relation. This is required not only to
      * lock all the matching tuples, but also to conflict with new insertions
      * into the table. In an indexscan, we take page locks on the index pages
      * covering the range specified in the scan qual, but in a heap scan there
      * is nothing more fine-grained to lock. A bitmap scan is a different
      * story, there we have already scanned the index and locked the index
      * pages covering the predicate. But in that case we still have to lock
      * any matching heap tuples. For sample scan we could optimize the locking
      * to be at least page-level granularity, but we'd need to add per-tuple
      * locking for that.
      */
     if (scan->rs_base.rs_flags & (SO_TYPE_SEQSCAN | SO_TYPE_SAMPLESCAN))
     {
         /*
          * Ensure a missing snapshot is noticed reliably, even if the
          * isolation mode means predicate locking isn't performed (and
          * therefore the snapshot isn't used here).
          */
         Assert(snapshot);
         PredicateLockRelation(relation, snapshot);
     }
 
     /* we only need to set this up once */
     scan->rs_ctup.t_tableOid = RelationGetRelid(relation);
 
     /*
      * we do this here instead of in initscan() because heap_rescan also calls
      * initscan() and we don't want to allocate memory again
      */
     if (nkeys > 0)
         scan->rs_base.rs_key = (ScanKey) palloc(sizeof(ScanKeyData) * nkeys);
     else
         scan->rs_base.rs_key = NULL;
 
     initscan(scan, key, false);
 
     return (TableScanDesc) scan;
 }

◆ heap_compute_xid_horizon_for_tuples()

TransactionId heap_compute_xid_horizon_for_tuples	(	Relation	rel,
		ItemPointerData *	items,
		int	nitems
	)

Definition at line 6986 of file heapam.c.

References Assert, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage, BufferIsValid, CHECK_FOR_INTERRUPTS, effective_io_concurrency, get_tablespace_io_concurrency(), HeapTupleHeaderAdvanceLatestRemovedXid(), i, InvalidBlockNumber, InvalidBuffer, InvalidTransactionId, IsCatalogRelation(), ItemIdGetRedirect, ItemIdHasStorage, ItemIdIsDead, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerCompare(), ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockBuffer(), MAX_IO_CONCURRENCY, Min, PageGetItem, PageGetItemId, qsort, RelationData::rd_rel, ReadBuffer(), and ReleaseBuffer().

Referenced by SampleHeapTupleVisible().

 {
     TransactionId latestRemovedXid = InvalidTransactionId;
     BlockNumber hblkno;
     Buffer      buf = InvalidBuffer;
     Page        hpage;
 #ifdef USE_PREFETCH
     XidHorizonPrefetchState prefetch_state;
     int         io_concurrency;
     int         prefetch_distance;
 #endif
 
     /*
      * Sort to avoid repeated lookups for the same page, and to make it more
      * likely to access items in an efficient order. In particular, this
      * ensures that if there are multiple pointers to the same page, they all
      * get processed looking up and locking the page just once.
      */
     qsort((void *) tids, nitems, sizeof(ItemPointerData),
           (int (*) (const void *, const void *)) ItemPointerCompare);
 
 #ifdef USE_PREFETCH
     /* Initialize prefetch state. */
     prefetch_state.cur_hblkno = InvalidBlockNumber;
     prefetch_state.next_item = 0;
     prefetch_state.nitems = nitems;
     prefetch_state.tids = tids;
 
     /*
      * Compute the prefetch distance that we will attempt to maintain.
      *
      * We don't use the regular formula to determine how much to prefetch
      * here, but instead just add a constant to effective_io_concurrency.
      * That's because it seems best to do some prefetching here even when
      * effective_io_concurrency is set to 0, but if the DBA thinks it's OK to
      * do more prefetching for other operations, then it's probably OK to do
      * more prefetching in this case, too. It may be that this formula is too
      * simplistic, but at the moment there is no evidence of that or any idea
      * about what would work better.
      *
      * Since the caller holds a buffer lock somewhere in rel, we'd better make
      * sure that isn't a catalog relation before we call code that does
      * syscache lookups, to avoid risk of deadlock.
      */
     if (IsCatalogRelation(rel))
         io_concurrency = effective_io_concurrency;
     else
         io_concurrency = get_tablespace_io_concurrency(rel->rd_rel->reltablespace);
     prefetch_distance = Min((io_concurrency) + 10, MAX_IO_CONCURRENCY);
 
     /* Start prefetching. */
     xid_horizon_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
 #endif
 
     /* Iterate over all tids, and check their horizon */
     hblkno = InvalidBlockNumber;
     hpage = NULL;
     for (int i = 0; i < nitems; i++)
     {
         ItemPointer htid = &tids[i];
         ItemId      hitemid;
         OffsetNumber hoffnum;
 
         /*
          * Read heap buffer, but avoid refetching if it's the same block as
          * required for the last tid.
          */
         if (hblkno == InvalidBlockNumber ||
             ItemPointerGetBlockNumber(htid) != hblkno)
         {
             /* release old buffer */
             if (BufferIsValid(buf))
             {
                 LockBuffer(buf, BUFFER_LOCK_UNLOCK);
                 ReleaseBuffer(buf);
             }
 
             hblkno = ItemPointerGetBlockNumber(htid);
 
             buf = ReadBuffer(rel, hblkno);
 
 #ifdef USE_PREFETCH
 
             /*
              * To maintain the prefetch distance, prefetch one more page for
              * each page we read.
              */
             xid_horizon_prefetch_buffer(rel, &prefetch_state, 1);
 #endif
 
             hpage = BufferGetPage(buf);
 
             LockBuffer(buf, BUFFER_LOCK_SHARE);
         }
 
         hoffnum = ItemPointerGetOffsetNumber(htid);
         hitemid = PageGetItemId(hpage, hoffnum);
 
         /*
          * Follow any redirections until we find something useful.
          */
         while (ItemIdIsRedirected(hitemid))
         {
             hoffnum = ItemIdGetRedirect(hitemid);
             hitemid = PageGetItemId(hpage, hoffnum);
             CHECK_FOR_INTERRUPTS();
         }
 
         /*
          * If the heap item has storage, then read the header and use that to
          * set latestRemovedXid.
          *
          * Some LP_DEAD items may not be accessible, so we ignore them.
          */
         if (ItemIdHasStorage(hitemid))
         {
             HeapTupleHeader htuphdr;
 
             htuphdr = (HeapTupleHeader) PageGetItem(hpage, hitemid);
 
             HeapTupleHeaderAdvanceLatestRemovedXid(htuphdr, &latestRemovedXid);
         }
         else if (ItemIdIsDead(hitemid))
         {
             /*
              * Conjecture: if hitemid is dead then it had xids before the xids
              * marked on LP_NORMAL items. So we just ignore this item and move
              * onto the next, for the purposes of calculating
              * latestRemovedXid.
              */
         }
         else
             Assert(!ItemIdIsUsed(hitemid));
 
     }
 
     if (BufferIsValid(buf))
     {
         LockBuffer(buf, BUFFER_LOCK_UNLOCK);
         ReleaseBuffer(buf);
     }
 
     /*
      * If all heap tuples were LP_DEAD then we will be returning
      * InvalidTransactionId here, which avoids conflicts. This matches
      * existing logic which assumes that LP_DEAD tuples must already be older
      * than the latestRemovedXid on the cleanup record that set them as
      * LP_DEAD, hence must already have generated a conflict.
      */
 
     return latestRemovedXid;
 }

◆ heap_delete()

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

Definition at line 2442 of file heapam.c.

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

 {
     TM_Result   result;
     TransactionId xid = GetCurrentTransactionId();
     ItemId      lp;
     HeapTupleData tp;
     Page        page;
     BlockNumber block;
     Buffer      buffer;
     Buffer      vmbuffer = InvalidBuffer;
     TransactionId new_xmax;
     uint16      new_infomask,
                 new_infomask2;
     bool        have_tuple_lock = false;
     bool        iscombo;
     bool        all_visible_cleared = false;
     HeapTuple   old_key_tuple = NULL;   /* replica identity of the tuple */
     bool        old_key_copied = false;
 
     Assert(ItemPointerIsValid(tid));
 
     /*
      * Forbid this during a parallel operation, lest it allocate a combocid.
      * Other workers might need that combocid for visibility checks, and we
      * have no provision for broadcasting it to them.
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot delete tuples during a parallel operation")));
 
     block = ItemPointerGetBlockNumber(tid);
     buffer = ReadBuffer(relation, block);
     page = BufferGetPage(buffer);
 
     /*
      * Before locking the buffer, pin the visibility map page if it appears to
      * be necessary.  Since we haven't got the lock yet, someone else might be
      * in the middle of changing this, so we'll need to recheck after we have
      * the lock.
      */
     if (PageIsAllVisible(page))
         visibilitymap_pin(relation, block, &vmbuffer);
 
     LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
     /*
      * If we didn't pin the visibility map page and the page has become all
      * visible while we were busy locking the buffer, we'll have to unlock and
      * re-lock, to avoid holding the buffer lock across an I/O.  That's a bit
      * unfortunate, but hopefully shouldn't happen often.
      */
     if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
     {
         LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
         visibilitymap_pin(relation, block, &vmbuffer);
         LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
     }
 
     lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
     Assert(ItemIdIsNormal(lp));
 
     tp.t_tableOid = RelationGetRelid(relation);
     tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
     tp.t_len = ItemIdGetLength(lp);
     tp.t_self = *tid;
 
 l1:
     result = HeapTupleSatisfiesUpdate(&tp, cid, buffer);
 
     if (result == TM_Invisible)
     {
         UnlockReleaseBuffer(buffer);
         ereport(ERROR,
                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                  errmsg("attempted to delete invisible tuple")));
     }
     else if (result == TM_BeingModified && wait)
     {
         TransactionId xwait;
         uint16      infomask;
 
         /* must copy state data before unlocking buffer */
         xwait = HeapTupleHeaderGetRawXmax(tp.t_data);
         infomask = tp.t_data->t_infomask;
 
         /*
          * Sleep until concurrent transaction ends -- except when there's a
          * single locker and it's our own transaction.  Note we don't care
          * which lock mode the locker has, because we need the strongest one.
          *
          * Before sleeping, we need to acquire tuple lock to establish our
          * priority for the tuple (see heap_lock_tuple).  LockTuple will
          * release us when we are next-in-line for the tuple.
          *
          * If we are forced to "start over" below, we keep the tuple lock;
          * this arranges that we stay at the head of the line while rechecking
          * tuple state.
          */
         if (infomask & HEAP_XMAX_IS_MULTI)
         {
             bool        current_is_member = false;
 
             if (DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
                                         LockTupleExclusive, &current_is_member))
             {
                 LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
                 /*
                  * Acquire the lock, if necessary (but skip it when we're
                  * requesting a lock and already have one; avoids deadlock).
                  */
                 if (!current_is_member)
                     heap_acquire_tuplock(relation, &(tp.t_self), LockTupleExclusive,
                                          LockWaitBlock, &have_tuple_lock);
 
                 /* wait for multixact */
                 MultiXactIdWait((MultiXactId) xwait, MultiXactStatusUpdate, infomask,
                                 relation, &(tp.t_self), XLTW_Delete,
                                 NULL);
                 LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
                 /*
                  * If xwait had just locked the tuple then some other xact
                  * could update this tuple before we get to this point.  Check
                  * for xmax change, and start over if so.
                  */
                 if (xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
                     !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
                                          xwait))
                     goto l1;
             }
 
             /*
              * You might think the multixact is necessarily done here, but not
              * so: it could have surviving members, namely our own xact or
              * other subxacts of this backend.  It is legal for us to delete
              * the tuple in either case, however (the latter case is
              * essentially a situation of upgrading our former shared lock to
              * exclusive).  We don't bother changing the on-disk hint bits
              * since we are about to overwrite the xmax altogether.
              */
         }
         else if (!TransactionIdIsCurrentTransactionId(xwait))
         {
             /*
              * Wait for regular transaction to end; but first, acquire tuple
              * lock.
              */
             LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
             heap_acquire_tuplock(relation, &(tp.t_self), LockTupleExclusive,
                                  LockWaitBlock, &have_tuple_lock);
             XactLockTableWait(xwait, relation, &(tp.t_self), XLTW_Delete);
             LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
             /*
              * xwait is done, but if xwait had just locked the tuple then some
              * other xact could update this tuple before we get to this point.
              * Check for xmax change, and start over if so.
              */
             if (xmax_infomask_changed(tp.t_data->t_infomask, infomask) ||
                 !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tp.t_data),
                                      xwait))
                 goto l1;
 
             /* Otherwise check if it committed or aborted */
             UpdateXmaxHintBits(tp.t_data, buffer, xwait);
         }
 
         /*
          * We may overwrite if previous xmax aborted, or if it committed but
          * only locked the tuple without updating it.
          */
         if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
             HEAP_XMAX_IS_LOCKED_ONLY(tp.t_data->t_infomask) ||
             HeapTupleHeaderIsOnlyLocked(tp.t_data))
             result = TM_Ok;
         else if (!ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid) ||
                  HeapTupleHeaderIndicatesMovedPartitions(tp.t_data))
             result = TM_Updated;
         else
             result = TM_Deleted;
     }
 
     if (crosscheck != InvalidSnapshot && result == TM_Ok)
     {
         /* Perform additional check for transaction-snapshot mode RI updates */
         if (!HeapTupleSatisfiesVisibility(&tp, crosscheck, buffer))
             result = TM_Updated;
     }
 
     if (result != TM_Ok)
     {
         Assert(result == TM_SelfModified ||
                result == TM_Updated ||
                result == TM_Deleted ||
                result == TM_BeingModified);
         Assert(!(tp.t_data->t_infomask & HEAP_XMAX_INVALID));
         Assert(result != TM_Updated ||
                !ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid));
         tmfd->ctid = tp.t_data->t_ctid;
         tmfd->xmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
         if (result == TM_SelfModified)
             tmfd->cmax = HeapTupleHeaderGetCmax(tp.t_data);
         else
             tmfd->cmax = InvalidCommandId;
         UnlockReleaseBuffer(buffer);
         if (have_tuple_lock)
             UnlockTupleTuplock(relation, &(tp.t_self), LockTupleExclusive);
         if (vmbuffer != InvalidBuffer)
             ReleaseBuffer(vmbuffer);
         return result;
     }
 
     /*
      * We're about to do the actual delete -- check for conflict first, to
      * avoid possibly having to roll back work we've just done.
      *
      * This is safe without a recheck as long as there is no possibility of
      * another process scanning the page between this check and the delete
      * being visible to the scan (i.e., an exclusive buffer content lock is
      * continuously held from this point until the tuple delete is visible).
      */
     CheckForSerializableConflictIn(relation, &tp, buffer);
 
     /* replace cid with a combo cid if necessary */
     HeapTupleHeaderAdjustCmax(tp.t_data, &cid, &iscombo);
 
     /*
      * Compute replica identity tuple before entering the critical section so
      * we don't PANIC upon a memory allocation failure.
      */
     old_key_tuple = ExtractReplicaIdentity(relation, &tp, true, &old_key_copied);
 
     /*
      * If this is the first possibly-multixact-able operation in the current
      * transaction, set my per-backend OldestMemberMXactId setting. We can be
      * certain that the transaction will never become a member of any older
      * MultiXactIds than that.  (We have to do this even if we end up just
      * using our own TransactionId below, since some other backend could
      * incorporate our XID into a MultiXact immediately afterwards.)
      */
     MultiXactIdSetOldestMember();
 
     compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(tp.t_data),
                               tp.t_data->t_infomask, tp.t_data->t_infomask2,
                               xid, LockTupleExclusive, true,
                               &new_xmax, &new_infomask, &new_infomask2);
 
     START_CRIT_SECTION();
 
     /*
      * If this transaction commits, the tuple will become DEAD sooner or
      * later.  Set flag that this page is a candidate for pruning once our xid
      * falls below the OldestXmin horizon.  If the transaction finally aborts,
      * the subsequent page pruning will be a no-op and the hint will be
      * cleared.
      */
     PageSetPrunable(page, xid);
 
     if (PageIsAllVisible(page))
     {
         all_visible_cleared = true;
         PageClearAllVisible(page);
         visibilitymap_clear(relation, BufferGetBlockNumber(buffer),
                             vmbuffer, VISIBILITYMAP_VALID_BITS);
     }
 
     /* store transaction information of xact deleting the tuple */
     tp.t_data->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
     tp.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
     tp.t_data->t_infomask |= new_infomask;
     tp.t_data->t_infomask2 |= new_infomask2;
     HeapTupleHeaderClearHotUpdated(tp.t_data);
     HeapTupleHeaderSetXmax(tp.t_data, new_xmax);
     HeapTupleHeaderSetCmax(tp.t_data, cid, iscombo);
     /* Make sure there is no forward chain link in t_ctid */
     tp.t_data->t_ctid = tp.t_self;
 
     /* Signal that this is actually a move into another partition */
     if (changingPart)
         HeapTupleHeaderSetMovedPartitions(tp.t_data);
 
     MarkBufferDirty(buffer);
 
     /*
      * XLOG stuff
      *
      * NB: heap_abort_speculative() uses the same xlog record and replay
      * routines.
      */
     if (RelationNeedsWAL(relation))
     {
         xl_heap_delete xlrec;
         xl_heap_header xlhdr;
         XLogRecPtr  recptr;
 
         /* For logical decode we need combocids to properly decode the catalog */
         if (RelationIsAccessibleInLogicalDecoding(relation))
             log_heap_new_cid(relation, &tp);
 
         xlrec.flags = 0;
         if (all_visible_cleared)
             xlrec.flags |= XLH_DELETE_ALL_VISIBLE_CLEARED;
         if (changingPart)
             xlrec.flags |= XLH_DELETE_IS_PARTITION_MOVE;
         xlrec.infobits_set = compute_infobits(tp.t_data->t_infomask,
                                               tp.t_data->t_infomask2);
         xlrec.offnum = ItemPointerGetOffsetNumber(&tp.t_self);
         xlrec.xmax = new_xmax;
 
         if (old_key_tuple != NULL)
         {
             if (relation->rd_rel->relreplident == REPLICA_IDENTITY_FULL)
                 xlrec.flags |= XLH_DELETE_CONTAINS_OLD_TUPLE;
             else
                 xlrec.flags |= XLH_DELETE_CONTAINS_OLD_KEY;
         }
 
         XLogBeginInsert();
         XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
 
         XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
         /*
          * Log replica identity of the deleted tuple if there is one
          */
         if (old_key_tuple != NULL)
         {
             xlhdr.t_infomask2 = old_key_tuple->t_data->t_infomask2;
             xlhdr.t_infomask = old_key_tuple->t_data->t_infomask;
             xlhdr.t_hoff = old_key_tuple->t_data->t_hoff;
 
             XLogRegisterData((char *) &xlhdr, SizeOfHeapHeader);
             XLogRegisterData((char *) old_key_tuple->t_data
                              + SizeofHeapTupleHeader,
                              old_key_tuple->t_len
                              - SizeofHeapTupleHeader);
         }
 
         /* filtering by origin on a row level is much more efficient */
         XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
         recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
     if (vmbuffer != InvalidBuffer)
         ReleaseBuffer(vmbuffer);
 
     /*
      * If the tuple has toasted out-of-line attributes, we need to delete
      * those items too.  We have to do this before releasing the buffer
      * because we need to look at the contents of the tuple, but it's OK to
      * release the content lock on the buffer first.
      */
     if (relation->rd_rel->relkind != RELKIND_RELATION &&
         relation->rd_rel->relkind != RELKIND_MATVIEW)
     {
         /* toast table entries should never be recursively toasted */
         Assert(!HeapTupleHasExternal(&tp));
     }
     else if (HeapTupleHasExternal(&tp))
         heap_toast_delete(relation, &tp, false);
 
     /*
      * Mark tuple for invalidation from system caches at next command
      * boundary. We have to do this before releasing the buffer because we
      * need to look at the contents of the tuple.
      */
     CacheInvalidateHeapTuple(relation, &tp, NULL);
 
     /* Now we can release the buffer */
     ReleaseBuffer(buffer);
 
     /*
      * Release the lmgr tuple lock, if we had it.
      */
     if (have_tuple_lock)
         UnlockTupleTuplock(relation, &(tp.t_self), LockTupleExclusive);
 
     pgstat_count_heap_delete(relation);
 
     if (old_key_tuple != NULL && old_key_copied)
         heap_freetuple(old_key_tuple);
 
     return TM_Ok;
 }

◆ heap_endscan()

void heap_endscan ( TableScanDesc scan )

Definition at line 1245 of file heapam.c.

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

Referenced by SampleHeapTupleVisible().

 {
     HeapScanDesc scan = (HeapScanDesc) sscan;
 
     /* Note: no locking manipulations needed */
 
     /*
      * unpin scan buffers
      */
     if (BufferIsValid(scan->rs_cbuf))
         ReleaseBuffer(scan->rs_cbuf);
 
     /*
      * decrement relation reference count and free scan descriptor storage
      */
     RelationDecrementReferenceCount(scan->rs_base.rs_rd);
 
     if (scan->rs_base.rs_key)
         pfree(scan->rs_base.rs_key);
 
     if (scan->rs_strategy != NULL)
         FreeAccessStrategy(scan->rs_strategy);
 
     if (scan->rs_base.rs_flags & SO_TEMP_SNAPSHOT)
         UnregisterSnapshot(scan->rs_base.rs_snapshot);
 
     pfree(scan);
 }

◆ heap_fetch()

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

Definition at line 1412 of file heapam.c.

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

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

 {
     ItemPointer tid = &(tuple->t_self);
     ItemId      lp;
     Buffer      buffer;
     Page        page;
     OffsetNumber offnum;
     bool        valid;
 
     /*
      * Fetch and pin the appropriate page of the relation.
      */
     buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
 
     /*
      * Need share lock on buffer to examine tuple commit status.
      */
     LockBuffer(buffer, BUFFER_LOCK_SHARE);
     page = BufferGetPage(buffer);
     TestForOldSnapshot(snapshot, relation, page);
 
     /*
      * We'd better check for out-of-range offnum in case of VACUUM since the
      * TID was obtained.
      */
     offnum = ItemPointerGetOffsetNumber(tid);
     if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
     {
         LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
         ReleaseBuffer(buffer);
         *userbuf = InvalidBuffer;
         tuple->t_data = NULL;
         return false;
     }
 
     /*
      * get the item line pointer corresponding to the requested tid
      */
     lp = PageGetItemId(page, offnum);
 
     /*
      * Must check for deleted tuple.
      */
     if (!ItemIdIsNormal(lp))
     {
         LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
         ReleaseBuffer(buffer);
         *userbuf = InvalidBuffer;
         tuple->t_data = NULL;
         return false;
     }
 
     /*
      * fill in *tuple fields
      */
     tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
     tuple->t_len = ItemIdGetLength(lp);
     tuple->t_tableOid = RelationGetRelid(relation);
 
     /*
      * check tuple visibility, then release lock
      */
     valid = HeapTupleSatisfiesVisibility(tuple, snapshot, buffer);
 
     if (valid)
         PredicateLockTuple(relation, tuple, snapshot);
 
     CheckForSerializableConflictOut(valid, relation, tuple, buffer, snapshot);
 
     LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
     if (valid)
     {
         /*
          * All checks passed, so return the tuple as valid. Caller is now
          * responsible for releasing the buffer.
          */
         *userbuf = buffer;
 
         return true;
     }
 
     /* Tuple failed time qual */
     ReleaseBuffer(buffer);
     *userbuf = InvalidBuffer;
 
     return false;
 }

◆ heap_finish_speculative()

void heap_finish_speculative	(	Relation	relation,
		ItemPointer	tid
	)

Definition at line 5476 of file heapam.c.

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

Referenced by heapam_tuple_complete_speculative().

 {
     Buffer      buffer;
     Page        page;
     OffsetNumber offnum;
     ItemId      lp = NULL;
     HeapTupleHeader htup;
 
     buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
     LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
     page = (Page) BufferGetPage(buffer);
 
     offnum = ItemPointerGetOffsetNumber(tid);
     if (PageGetMaxOffsetNumber(page) >= offnum)
         lp = PageGetItemId(page, offnum);
 
     if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
         elog(ERROR, "invalid lp");
 
     htup = (HeapTupleHeader) PageGetItem(page, lp);
 
     /* SpecTokenOffsetNumber should be distinguishable from any real offset */
     StaticAssertStmt(MaxOffsetNumber < SpecTokenOffsetNumber,
                      "invalid speculative token constant");
 
     /* NO EREPORT(ERROR) from here till changes are logged */
     START_CRIT_SECTION();
 
     Assert(HeapTupleHeaderIsSpeculative(htup));
 
     MarkBufferDirty(buffer);
 
     /*
      * Replace the speculative insertion token with a real t_ctid, pointing to
      * itself like it does on regular tuples.
      */
     htup->t_ctid = *tid;
 
     /* XLOG stuff */
     if (RelationNeedsWAL(relation))
     {
         xl_heap_confirm xlrec;
         XLogRecPtr  recptr;
 
         xlrec.offnum = ItemPointerGetOffsetNumber(tid);
 
         XLogBeginInsert();
 
         /* We want the same filtering on this as on a plain insert */
         XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
         XLogRegisterData((char *) &xlrec, SizeOfHeapConfirm);
         XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
         recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_CONFIRM);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     UnlockReleaseBuffer(buffer);
 }

◆ heap_freeze_tuple()

bool heap_freeze_tuple	(	HeapTupleHeader	tuple,
		TransactionId	relfrozenxid,
		TransactionId	relminmxid,
		TransactionId	cutoff_xid,
		TransactionId	cutoff_multi
	)

Definition at line 6368 of file heapam.c.

References heap_execute_freeze_tuple(), and heap_prepare_freeze_tuple().

Referenced by rewrite_heap_tuple().

 {
     xl_heap_freeze_tuple frz;
     bool        do_freeze;
     bool        tuple_totally_frozen;
 
     do_freeze = heap_prepare_freeze_tuple(tuple,
                                           relfrozenxid, relminmxid,
                                           cutoff_xid, cutoff_multi,
                                           &frz, &tuple_totally_frozen);
 
     /*
      * Note that because this is not a WAL-logged operation, we don't need to
      * fill in the offset in the freeze record.
      */
 
     if (do_freeze)
         heap_execute_freeze_tuple(tuple, &frz);
     return do_freeze;
 }

◆ heap_get_latest_tid()

void heap_get_latest_tid	(	TableScanDesc	scan,
		ItemPointer	tid
	)

Definition at line 1670 of file heapam.c.

References Assert, BUFFER_LOCK_SHARE, BufferGetPage, CheckForSerializableConflictOut(), HEAP_XMAX_INVALID, 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, TestForOldSnapshot(), TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().

Referenced by SampleHeapTupleVisible().

 {
     Relation    relation = sscan->rs_rd;
     Snapshot    snapshot = sscan->rs_snapshot;
     ItemPointerData ctid;
     TransactionId priorXmax;
 
     /*
      * table_get_latest_tid verified that the passed in tid is valid.  Assume
      * that t_ctid links are valid however - there shouldn't be invalid ones
      * in the table.
      */
     Assert(ItemPointerIsValid(tid));
 
     /*
      * Loop to chase down t_ctid links.  At top of loop, ctid is the tuple we
      * need to examine, and *tid is the TID we will return if ctid turns out
      * to be bogus.
      *
      * Note that we will loop until we reach the end of the t_ctid chain.
      * Depending on the snapshot passed, there might be at most one visible
      * version of the row, but we don't try to optimize for that.
      */
     ctid = *tid;
     priorXmax = InvalidTransactionId;   /* cannot check first XMIN */
     for (;;)
     {
         Buffer      buffer;
         Page        page;
         OffsetNumber offnum;
         ItemId      lp;
         HeapTupleData tp;
         bool        valid;
 
         /*
          * Read, pin, and lock the page.
          */
         buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&ctid));
         LockBuffer(buffer, BUFFER_LOCK_SHARE);
         page = BufferGetPage(buffer);
         TestForOldSnapshot(snapshot, relation, page);
 
         /*
          * Check for bogus item number.  This is not treated as an error
          * condition because it can happen while following a t_ctid link. We
          * just assume that the prior tid is OK and return it unchanged.
          */
         offnum = ItemPointerGetOffsetNumber(&ctid);
         if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
         {
             UnlockReleaseBuffer(buffer);
             break;
         }
         lp = PageGetItemId(page, offnum);
         if (!ItemIdIsNormal(lp))
         {
             UnlockReleaseBuffer(buffer);
             break;
         }
 
         /* OK to access the tuple */
         tp.t_self = ctid;
         tp.t_data = (HeapTupleHeader) PageGetItem(page, lp);
         tp.t_len = ItemIdGetLength(lp);
         tp.t_tableOid = RelationGetRelid(relation);
 
         /*
          * After following a t_ctid link, we might arrive at an unrelated
          * tuple.  Check for XMIN match.
          */
         if (TransactionIdIsValid(priorXmax) &&
             !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
         {
             UnlockReleaseBuffer(buffer);
             break;
         }
 
         /*
          * Check tuple visibility; if visible, set it as the new result
          * candidate.
          */
         valid = HeapTupleSatisfiesVisibility(&tp, snapshot, buffer);
         CheckForSerializableConflictOut(valid, relation, &tp, buffer, snapshot);
         if (valid)
             *tid = ctid;
 
         /*
          * If there's a valid t_ctid link, follow it, else we're done.
          */
         if ((tp.t_data->t_infomask & HEAP_XMAX_INVALID) ||
             HeapTupleHeaderIsOnlyLocked(tp.t_data) ||
             HeapTupleHeaderIndicatesMovedPartitions(tp.t_data) ||
             ItemPointerEquals(&tp.t_self, &tp.t_data->t_ctid))
         {
             UnlockReleaseBuffer(buffer);
             break;
         }
 
         ctid = tp.t_data->t_ctid;
         priorXmax = HeapTupleHeaderGetUpdateXid(tp.t_data);
         UnlockReleaseBuffer(buffer);
     }                           /* end of loop */
 }

◆ heap_get_root_tuples()

void heap_get_root_tuples	(	Page	page,
		OffsetNumber *	root_offsets
	)

Definition at line 745 of file pruneheap.c.

References Assert, FirstOffsetNumber, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleHeaderIndicatesMovedPartitions, HeapTupleHeaderIsHeapOnly, HeapTupleHeaderIsHotUpdated, InvalidTransactionId, ItemIdGetRedirect, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerGetOffsetNumber, MaxHeapTuplesPerPage, MemSet, OffsetNumberNext, PageGetItem, PageGetItemId, PageGetMaxOffsetNumber, HeapTupleHeaderData::t_ctid, TransactionIdEquals, and TransactionIdIsValid.

Referenced by heapam_index_build_range_scan(), and heapam_index_validate_scan().

 {
     OffsetNumber offnum,
                 maxoff;
 
     MemSet(root_offsets, 0, MaxHeapTuplesPerPage * sizeof(OffsetNumber));
 
     maxoff = PageGetMaxOffsetNumber(page);
     for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
     {
         ItemId      lp = PageGetItemId(page, offnum);
         HeapTupleHeader htup;
         OffsetNumber nextoffnum;
         TransactionId priorXmax;
 
         /* skip unused and dead items */
         if (!ItemIdIsUsed(lp) || ItemIdIsDead(lp))
             continue;
 
         if (ItemIdIsNormal(lp))
         {
             htup = (HeapTupleHeader) PageGetItem(page, lp);
 
             /*
              * Check if this tuple is part of a HOT-chain rooted at some other
              * tuple. If so, skip it for now; we'll process it when we find
              * its root.
              */
             if (HeapTupleHeaderIsHeapOnly(htup))
                 continue;
 
             /*
              * This is either a plain tuple or the root of a HOT-chain.
              * Remember it in the mapping.
              */
             root_offsets[offnum - 1] = offnum;
 
             /* If it's not the start of a HOT-chain, we're done with it */
             if (!HeapTupleHeaderIsHotUpdated(htup))
                 continue;
 
             /* Set up to scan the HOT-chain */
             nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
             priorXmax = HeapTupleHeaderGetUpdateXid(htup);
         }
         else
         {
             /* Must be a redirect item. We do not set its root_offsets entry */
             Assert(ItemIdIsRedirected(lp));
             /* Set up to scan the HOT-chain */
             nextoffnum = ItemIdGetRedirect(lp);
             priorXmax = InvalidTransactionId;
         }
 
         /*
          * Now follow the HOT-chain and collect other tuples in the chain.
          *
          * Note: Even though this is a nested loop, the complexity of the
          * function is O(N) because a tuple in the page should be visited not
          * more than twice, once in the outer loop and once in HOT-chain
          * chases.
          */
         for (;;)
         {
             lp = PageGetItemId(page, nextoffnum);
 
             /* Check for broken chains */
             if (!ItemIdIsNormal(lp))
                 break;
 
             htup = (HeapTupleHeader) PageGetItem(page, lp);
 
             if (TransactionIdIsValid(priorXmax) &&
                 !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(htup)))
                 break;
 
             /* Remember the root line pointer for this item */
             root_offsets[nextoffnum - 1] = offnum;
 
             /* Advance to next chain member, if any */
             if (!HeapTupleHeaderIsHotUpdated(htup))
                 break;
 
             /* HOT implies it can't have moved to different partition */
             Assert(!HeapTupleHeaderIndicatesMovedPartitions(htup));
 
             nextoffnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
             priorXmax = HeapTupleHeaderGetUpdateXid(htup);
         }
     }
 }

◆ heap_getnext()

HeapTuple heap_getnext	(	TableScanDesc	scan,
		ScanDirection	direction
	)

Definition at line 1290 of file heapam.c.

References ereport, errcode(), errmsg_internal(), ERROR, GetHeapamTableAmRoutine(), HEAPDEBUG_1, HEAPDEBUG_2, HEAPDEBUG_3, 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, and unlikely.

Referenced by AlterTableMoveAll(), AlterTableSpaceOptions(), boot_openrel(), check_db_file_conflict(), createdb(), 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(), gettype(), heapam_index_build_range_scan(), heapam_index_validate_scan(), index_update_stats(), objectsInSchemaToOids(), pgrowlocks(), pgstat_collect_oids(), pgstat_heap(), ReindexMultipleTables(), remove_dbtablespaces(), RemoveConversionById(), RemoveSubscriptionRel(), RenameTableSpace(), ThereIsAtLeastOneRole(), and vac_truncate_clog().

 {
     HeapScanDesc scan = (HeapScanDesc) sscan;
 
     /*
      * This is still widely used directly, without going through table AM, so
      * add a safety check.  It's possible we should, at a later point,
      * downgrade this to an assert. The reason for checking the AM routine,
      * rather than the AM oid, is that this allows to write regression tests
      * that create another AM reusing the heap handler.
      */
     if (unlikely(sscan->rs_rd->rd_tableam != GetHeapamTableAmRoutine()))
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg_internal("only heap AM is supported")));
 
     /* Note: no locking manipulations needed */
 
     HEAPDEBUG_1;                /* heap_getnext( info ) */
 
     if (scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)
         heapgettup_pagemode(scan, direction,
                             scan->rs_base.rs_nkeys, scan->rs_base.rs_key);
     else
         heapgettup(scan, direction,
                    scan->rs_base.rs_nkeys, scan->rs_base.rs_key);
 
     if (scan->rs_ctup.t_data == NULL)
     {
         HEAPDEBUG_2;            /* heap_getnext returning EOS */
         return NULL;
     }
 
     /*
      * if we get here it means we have a new current scan tuple, so point to
      * the proper return buffer and return the tuple.
      */
     HEAPDEBUG_3;                /* heap_getnext returning tuple */
 
     pgstat_count_heap_getnext(scan->rs_base.rs_rd);
 
     return &scan->rs_ctup;
 }

◆ heap_getnextslot()

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

Definition at line 1349 of file heapam.c.

References ExecClearTuple(), ExecStoreBufferHeapTuple(), HEAPAMSLOTDEBUG_1, HEAPAMSLOTDEBUG_2, HEAPAMSLOTDEBUG_3, 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.

Referenced by SampleHeapTupleVisible().

 {
     HeapScanDesc scan = (HeapScanDesc) sscan;
 
     /* Note: no locking manipulations needed */
 
     HEAPAMSLOTDEBUG_1;          /* heap_getnextslot( info ) */
 
     if (sscan->rs_flags & SO_ALLOW_PAGEMODE)
         heapgettup_pagemode(scan, direction, sscan->rs_nkeys, sscan->rs_key);
     else
         heapgettup(scan, direction, sscan->rs_nkeys, sscan->rs_key);
 
     if (scan->rs_ctup.t_data == NULL)
     {
         HEAPAMSLOTDEBUG_2;      /* heap_getnextslot returning EOS */
         ExecClearTuple(slot);
         return false;
     }
 
     /*
      * if we get here it means we have a new current scan tuple, so point to
      * the proper return buffer and return the tuple.
      */
     HEAPAMSLOTDEBUG_3;          /* heap_getnextslot returning tuple */
 
     pgstat_count_heap_getnext(scan->rs_base.rs_rd);
 
     ExecStoreBufferHeapTuple(&scan->rs_ctup, slot,
                              scan->rs_cbuf);
     return true;
 }

◆ 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 1526 of file heapam.c.

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

Referenced by heapam_index_fetch_tuple(), and heapam_scan_bitmap_next_block().

 {
     Page        dp = (Page) BufferGetPage(buffer);
     TransactionId prev_xmax = InvalidTransactionId;
     BlockNumber blkno;
     OffsetNumber offnum;
     bool        at_chain_start;
     bool        valid;
     bool        skip;
 
     /* If this is not the first call, previous call returned a (live!) tuple */
     if (all_dead)
         *all_dead = first_call;
 
     blkno = ItemPointerGetBlockNumber(tid);
     offnum = ItemPointerGetOffsetNumber(tid);
     at_chain_start = first_call;
     skip = !first_call;
 
     Assert(TransactionIdIsValid(RecentGlobalXmin));
     Assert(BufferGetBlockNumber(buffer) == blkno);
 
     /* Scan through possible multiple members of HOT-chain */
     for (;;)
     {
         ItemId      lp;
 
         /* check for bogus TID */
         if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(dp))
             break;
 
         lp = PageGetItemId(dp, offnum);
 
         /* check for unused, dead, or redirected items */
         if (!ItemIdIsNormal(lp))
         {
             /* We should only see a redirect at start of chain */
             if (ItemIdIsRedirected(lp) && at_chain_start)
             {
                 /* Follow the redirect */
                 offnum = ItemIdGetRedirect(lp);
                 at_chain_start = false;
                 continue;
             }
             /* else must be end of chain */
             break;
         }
 
         /*
          * Update heapTuple to point to the element of the HOT chain we're
          * currently investigating. Having t_self set correctly is important
          * because the SSI checks and the *Satisfies routine for historical
          * MVCC snapshots need the correct tid to decide about the visibility.
          */
         heapTuple->t_data = (HeapTupleHeader) PageGetItem(dp, lp);
         heapTuple->t_len = ItemIdGetLength(lp);
         heapTuple->t_tableOid = RelationGetRelid(relation);
         ItemPointerSet(&heapTuple->t_self, blkno, offnum);
 
         /*
          * Shouldn't see a HEAP_ONLY tuple at chain start.
          */
         if (at_chain_start && HeapTupleIsHeapOnly(heapTuple))
             break;
 
         /*
          * The xmin should match the previous xmax value, else chain is
          * broken.
          */
         if (TransactionIdIsValid(prev_xmax) &&
             !TransactionIdEquals(prev_xmax,
                                  HeapTupleHeaderGetXmin(heapTuple->t_data)))
             break;
 
         /*
          * When first_call is true (and thus, skip is initially false) we'll
          * return the first tuple we find.  But on later passes, heapTuple
          * will initially be pointing to the tuple we returned last time.
          * Returning it again would be incorrect (and would loop forever), so
          * we skip it and return the next match we find.
          */
         if (!skip)
         {
             /* If it's visible per the snapshot, we must return it */
             valid = HeapTupleSatisfiesVisibility(heapTuple, snapshot, buffer);
             CheckForSerializableConflictOut(valid, relation, heapTuple,
                                             buffer, snapshot);
 
             if (valid)
             {
                 ItemPointerSetOffsetNumber(tid, offnum);
                 PredicateLockTuple(relation, heapTuple, snapshot);
                 if (all_dead)
                     *all_dead = false;
                 return true;
             }
         }
         skip = false;
 
         /*
          * If we can't see it, maybe no one else can either.  At caller
          * request, check whether all chain members are dead to all
          * transactions.
          *
          * Note: if you change the criterion here for what is "dead", fix the
          * planner's get_actual_variable_range() function to match.
          */
         if (all_dead && *all_dead &&
             !HeapTupleIsSurelyDead(heapTuple, RecentGlobalXmin))
             *all_dead = false;
 
         /*
          * Check to see if HOT chain continues past this tuple; if so fetch
          * the next offnum and loop around.
          */
         if (HeapTupleIsHotUpdated(heapTuple))
         {
             Assert(ItemPointerGetBlockNumber(&heapTuple->t_data->t_ctid) ==
                    blkno);
             offnum = ItemPointerGetOffsetNumber(&heapTuple->t_data->t_ctid);
             at_chain_start = false;
             prev_xmax = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
         }
         else
             break;              /* end of chain */
     }
 
     return false;
 }

◆ heap_inplace_update()

void heap_inplace_update	(	Relation	relation,
		HeapTuple	tuple
	)

Definition at line 5707 of file heapam.c.

References BUFFER_LOCK_EXCLUSIVE, BufferGetPage, CacheInvalidateHeapTuple(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, 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(), index_set_state_flags(), index_update_stats(), vac_update_datfrozenxid(), and vac_update_relstats().

 {
     Buffer      buffer;
     Page        page;
     OffsetNumber offnum;
     ItemId      lp = NULL;
     HeapTupleHeader htup;
     uint32      oldlen;
     uint32      newlen;
 
     /*
      * For now, parallel operations are required to be strictly read-only.
      * Unlike a regular update, this should never create a combo CID, so it
      * might be possible to relax this restriction, but not without more
      * thought and testing.  It's not clear that it would be useful, anyway.
      */
     if (IsInParallelMode())
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                  errmsg("cannot update tuples during a parallel operation")));
 
     buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(&(tuple->t_self)));
     LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
     page = (Page) BufferGetPage(buffer);
 
     offnum = ItemPointerGetOffsetNumber(&(tuple->t_self));
     if (PageGetMaxOffsetNumber(page) >= offnum)
         lp = PageGetItemId(page, offnum);
 
     if (PageGetMaxOffsetNumber(page) < offnum || !ItemIdIsNormal(lp))
         elog(ERROR, "invalid lp");
 
     htup = (HeapTupleHeader) PageGetItem(page, lp);
 
     oldlen = ItemIdGetLength(lp) - htup->t_hoff;
     newlen = tuple->t_len - tuple->t_data->t_hoff;
     if (oldlen != newlen || htup->t_hoff != tuple->t_data->t_hoff)
         elog(ERROR, "wrong tuple length");
 
     /* NO EREPORT(ERROR) from here till changes are logged */
     START_CRIT_SECTION();
 
     memcpy((char *) htup + htup->t_hoff,
            (char *) tuple->t_data + tuple->t_data->t_hoff,
            newlen);
 
     MarkBufferDirty(buffer);
 
     /* XLOG stuff */
     if (RelationNeedsWAL(relation))
     {
         xl_heap_inplace xlrec;
         XLogRecPtr  recptr;
 
         xlrec.offnum = ItemPointerGetOffsetNumber(&tuple->t_self);
 
         XLogBeginInsert();
         XLogRegisterData((char *) &xlrec, SizeOfHeapInplace);
 
         XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
         XLogRegisterBufData(0, (char *) htup + htup->t_hoff, newlen);
 
         /* inplace updates aren't decoded atm, don't log the origin */
 
         recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_INPLACE);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     UnlockReleaseBuffer(buffer);
 
     /*
      * Send out shared cache inval if necessary.  Note that because we only
      * pass the new version of the tuple, this mustn't be used for any
      * operations that could change catcache lookup keys.  But we aren't
      * bothering with index updates either, so that's true a fortiori.
      */
     if (!IsBootstrapProcessingMode())
         CacheInvalidateHeapTuple(relation, tuple, NULL);
 }

◆ heap_insert()

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

Definition at line 1868 of file heapam.c.

References Assert, BufferGetBlockNumber(), BufferGetPage, CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), END_CRIT_SECTION, FirstOffsetNumber, xl_heap_insert::flags, GetCurrentTransactionId(), heap_freetuple(), HEAP_INSERT_NO_LOGICAL, HEAP_INSERT_SKIP_WAL, HEAP_INSERT_SPECULATIVE, heap_prepare_insert(), InvalidBuffer, 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(), 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, 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().

 {
     TransactionId xid = GetCurrentTransactionId();
     HeapTuple   heaptup;
     Buffer      buffer;
     Buffer      vmbuffer = InvalidBuffer;
     bool        all_visible_cleared = false;
 
     /*
      * Fill in tuple header fields and toast the tuple if necessary.
      *
      * Note: below this point, heaptup is the data we actually intend to store
      * into the relation; tup is the caller's original untoasted data.
      */
     heaptup = heap_prepare_insert(relation, tup, xid, cid, options);
 
     /*
      * Find buffer to insert this tuple into.  If the page is all visible,
      * this will also pin the requisite visibility map page.
      */
     buffer = RelationGetBufferForTuple(relation, heaptup->t_len,
                                        InvalidBuffer, options, bistate,
                                        &vmbuffer, NULL);
 
     /*
      * We're about to do the actual insert -- but check for conflict first, to
      * avoid possibly having to roll back work we've just done.
      *
      * This is safe without a recheck as long as there is no possibility of
      * another process scanning the page between this check and the insert
      * being visible to the scan (i.e., an exclusive buffer content lock is
      * continuously held from this point until the tuple insert is visible).
      *
      * For a heap insert, we only need to check for table-level SSI locks. Our
      * new tuple can't possibly conflict with existing tuple locks, and heap
      * page locks are only consolidated versions of tuple locks; they do not
      * lock "gaps" as index page locks do.  So we don't need to specify a
      * buffer when making the call, which makes for a faster check.
      */
     CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
 
     /* NO EREPORT(ERROR) from here till changes are logged */
     START_CRIT_SECTION();
 
     RelationPutHeapTuple(relation, buffer, heaptup,
                          (options & HEAP_INSERT_SPECULATIVE) != 0);
 
     if (PageIsAllVisible(BufferGetPage(buffer)))
     {
         all_visible_cleared = true;
         PageClearAllVisible(BufferGetPage(buffer));
         visibilitymap_clear(relation,
                             ItemPointerGetBlockNumber(&(heaptup->t_self)),
                             vmbuffer, VISIBILITYMAP_VALID_BITS);
     }
 
     /*
      * XXX Should we set PageSetPrunable on this page ?
      *
      * The inserting transaction may eventually abort thus making this tuple
      * DEAD and hence available for pruning. Though we don't want to optimize
      * for aborts, if no other tuple in this page is UPDATEd/DELETEd, the
      * aborted tuple will never be pruned until next vacuum is triggered.
      *
      * If you do add PageSetPrunable here, add it in heap_xlog_insert too.
      */
 
     MarkBufferDirty(buffer);
 
     /* XLOG stuff */
     if (!(options & HEAP_INSERT_SKIP_WAL) && RelationNeedsWAL(relation))
     {
         xl_heap_insert xlrec;
         xl_heap_header xlhdr;
         XLogRecPtr  recptr;
         Page        page = BufferGetPage(buffer);
         uint8       info = XLOG_HEAP_INSERT;
         int         bufflags = 0;
 
         /*
          * If this is a catalog, we need to transmit combocids to properly
          * decode, so log that as well.
          */
         if (RelationIsAccessibleInLogicalDecoding(relation))
             log_heap_new_cid(relation, heaptup);
 
         /*
          * If this is the single and first tuple on page, we can reinit the
          * page instead of restoring the whole thing.  Set flag, and hide
          * buffer references from XLogInsert.
          */
         if (ItemPointerGetOffsetNumber(&(heaptup->t_self)) == FirstOffsetNumber &&
             PageGetMaxOffsetNumber(page) == FirstOffsetNumber)
         {
             info |= XLOG_HEAP_INIT_PAGE;
             bufflags |= REGBUF_WILL_INIT;
         }
 
         xlrec.offnum = ItemPointerGetOffsetNumber(&heaptup->t_self);
         xlrec.flags = 0;
         if (all_visible_cleared)
             xlrec.flags |= XLH_INSERT_ALL_VISIBLE_CLEARED;
         if (options & HEAP_INSERT_SPECULATIVE)
             xlrec.flags |= XLH_INSERT_IS_SPECULATIVE;
         Assert(ItemPointerGetBlockNumber(&heaptup->t_self) == BufferGetBlockNumber(buffer));
 
         /*
          * For logical decoding, we need the tuple even if we're doing a full
          * page write, so make sure it's included even if we take a full-page
          * image. (XXX We could alternatively store a pointer into the FPW).
          */
         if (RelationIsLogicallyLogged(relation) &&
             !(options & HEAP_INSERT_NO_LOGICAL))
         {
             xlrec.flags |= XLH_INSERT_CONTAINS_NEW_TUPLE;
             bufflags |= REGBUF_KEEP_DATA;
         }
 
         XLogBeginInsert();
         XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
 
         xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
         xlhdr.t_infomask = heaptup->t_data->t_infomask;
         xlhdr.t_hoff = heaptup->t_data->t_hoff;
 
         /*
          * note we mark xlhdr as belonging to buffer; if XLogInsert decides to
          * write the whole page to the xlog, we don't need to store
          * xl_heap_header in the xlog.
          */
         XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
         XLogRegisterBufData(0, (char *) &xlhdr, SizeOfHeapHeader);
         /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
         XLogRegisterBufData(0,
                             (char *) heaptup->t_data + SizeofHeapTupleHeader,
                             heaptup->t_len - SizeofHeapTupleHeader);
 
         /* filtering by origin on a row level is much more efficient */
         XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
         recptr = XLogInsert(RM_HEAP_ID, info);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     UnlockReleaseBuffer(buffer);
     if (vmbuffer != InvalidBuffer)
         ReleaseBuffer(vmbuffer);
 
     /*
      * If tuple is cachable, mark it for invalidation from the caches in case
      * we abort.  Note it is OK to do this after releasing the buffer, because
      * the heaptup data structure is all in local memory, not in the shared
      * buffer.
      */
     CacheInvalidateHeapTuple(relation, heaptup, NULL);
 
     /* Note: speculative insertions are counted too, even if aborted later */
     pgstat_count_heap_insert(relation, 1);
 
     /*
      * If heaptup is a private copy, release it.  Don't forget to copy t_self
      * back to the caller's image, too.
      */
     if (heaptup != tup)
     {
         tup->t_self = heaptup->t_self;
         heap_freetuple(heaptup);
     }
 }

◆ heap_lock_tuple()

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

Definition at line 3973 of file heapam.c.

References Assert, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage, BufferIsValid, TM_FailureData::cmax, compute_infobits(), compute_new_xmax_infomask(), ConditionalMultiXactIdWait(), ConditionalXactLockTableWait(), TM_FailureData::ctid, DoesMultiXactIdConflict(), elog, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, xl_heap_lock::flags, get_mxact_status_for_lock(), GetCurrentTransactionId(), GetMultiXactIdMembers(), heap_acquire_tuplock(), HEAP_KEYS_UPDATED, heap_lock_updated_tuple(), HEAP_XMAX_BITS, 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, HeapTupleHeaderClearHotUpdated, HeapTupleHeaderGetCmax(), HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderIndicatesMovedPartitions, HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetXmax, HeapTupleSatisfiesUpdate(), i, xl_heap_lock::infobits_set, InvalidBuffer, InvalidCommandId, ItemIdGetLength, ItemIdIsNormal, ItemPointerCopy, ItemPointerEquals(), ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockBuffer(), xl_heap_lock::locking_xid, LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, LockWaitBlock, LockWaitError, LockWaitSkip, MarkBufferDirty(), MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, xl_heap_lock::offnum, PageGetItem, PageGetItemId, PageIsAllVisible, PageSetLSN, pfree(), ReadBuffer(), REGBUF_STANDARD, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapLock, START_CRIT_SECTION, status(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TM_WouldBlock, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TUPLOCK_from_mxstatus, UnlockTupleTuplock, UpdateXmaxHintBits(), VISIBILITYMAP_ALL_FROZEN, visibilitymap_clear(), visibilitymap_pin(), XactLockTableWait(), XLH_LOCK_ALL_FROZEN_CLEARED, XLOG_HEAP_LOCK, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLTW_Lock, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_lock().

 {
     TM_Result   result;
     ItemPointer tid = &(tuple->t_self);
     ItemId      lp;
     Page        page;
     Buffer      vmbuffer = InvalidBuffer;
     BlockNumber block;
     TransactionId xid,
                 xmax;
     uint16      old_infomask,
                 new_infomask,
                 new_infomask2;
     bool        first_time = true;
     bool        skip_tuple_lock = false;
     bool        have_tuple_lock = false;
     bool        cleared_all_frozen = false;
 
     *buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
     block = ItemPointerGetBlockNumber(tid);
 
     /*
      * Before locking the buffer, pin the visibility map page if it appears to
      * be necessary.  Since we haven't got the lock yet, someone else might be
      * in the middle of changing this, so we'll need to recheck after we have
      * the lock.
      */
     if (PageIsAllVisible(BufferGetPage(*buffer)))
         visibilitymap_pin(relation, block, &vmbuffer);
 
     LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
     page = BufferGetPage(*buffer);
     lp = PageGetItemId(page, ItemPointerGetOffsetNumber(tid));
     Assert(ItemIdIsNormal(lp));
 
     tuple->t_data = (HeapTupleHeader) PageGetItem(page, lp);
     tuple->t_len = ItemIdGetLength(lp);
     tuple->t_tableOid = RelationGetRelid(relation);
 
 l3:
     result = HeapTupleSatisfiesUpdate(tuple, cid, *buffer);
 
     if (result == TM_Invisible)
     {
         /*
          * This is possible, but only when locking a tuple for ON CONFLICT
          * UPDATE.  We return this value here rather than throwing an error in
          * order to give that case the opportunity to throw a more specific
          * error.
          */
         result = TM_Invisible;
         goto out_locked;
     }
     else if (result == TM_BeingModified ||
              result == TM_Updated ||
              result == TM_Deleted)
     {
         TransactionId xwait;
         uint16      infomask;
         uint16      infomask2;
         bool        require_sleep;
         ItemPointerData t_ctid;
 
         /* must copy state data before unlocking buffer */
         xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
         infomask = tuple->t_data->t_infomask;
         infomask2 = tuple->t_data->t_infomask2;
         ItemPointerCopy(&tuple->t_data->t_ctid, &t_ctid);
 
         LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
 
         /*
          * If any subtransaction of the current top transaction already holds
          * a lock as strong as or stronger than what we're requesting, we
          * effectively hold the desired lock already.  We *must* succeed
          * without trying to take the tuple lock, else we will deadlock
          * against anyone wanting to acquire a stronger lock.
          *
          * Note we only do this the first time we loop on the HTSU result;
          * there is no point in testing in subsequent passes, because
          * evidently our own transaction cannot have acquired a new lock after
          * the first time we checked.
          */
         if (first_time)
         {
             first_time = false;
 
             if (infomask & HEAP_XMAX_IS_MULTI)
             {
                 int         i;
                 int         nmembers;
                 MultiXactMember *members;
 
                 /*
                  * We don't need to allow old multixacts here; if that had
                  * been the case, HeapTupleSatisfiesUpdate would have returned
                  * MayBeUpdated and we wouldn't be here.
                  */
                 nmembers =
                     GetMultiXactIdMembers(xwait, &members, false,
                                           HEAP_XMAX_IS_LOCKED_ONLY(infomask));
 
                 for (i = 0; i < nmembers; i++)
                 {
                     /* only consider members of our own transaction */
                     if (!TransactionIdIsCurrentTransactionId(members[i].xid))
                         continue;
 
                     if (TUPLOCK_from_mxstatus(members[i].status) >= mode)
                     {
                         pfree(members);
                         result = TM_Ok;
                         goto out_unlocked;
                     }
                     else
                     {
                         /*
                          * Disable acquisition of the heavyweight tuple lock.
                          * Otherwise, when promoting a weaker lock, we might
                          * deadlock with another locker that has acquired the
                          * heavyweight tuple lock and is waiting for our
                          * transaction to finish.
                          *
                          * Note that in this case we still need to wait for
                          * the multixact if required, to avoid acquiring
                          * conflicting locks.
                          */
                         skip_tuple_lock = true;
                     }
                 }
 
                 if (members)
                     pfree(members);
             }
             else if (TransactionIdIsCurrentTransactionId(xwait))
             {
                 switch (mode)
                 {
                     case LockTupleKeyShare:
                         Assert(HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) ||
                                HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
                                HEAP_XMAX_IS_EXCL_LOCKED(infomask));
                         result = TM_Ok;
                         goto out_unlocked;
                     case LockTupleShare:
                         if (HEAP_XMAX_IS_SHR_LOCKED(infomask) ||
                             HEAP_XMAX_IS_EXCL_LOCKED(infomask))
                         {
                             result = TM_Ok;
                             goto out_unlocked;
                         }
                         break;
                     case LockTupleNoKeyExclusive:
                         if (HEAP_XMAX_IS_EXCL_LOCKED(infomask))
                         {
                             result = TM_Ok;
                             goto out_unlocked;
                         }
                         break;
                     case LockTupleExclusive:
                         if (HEAP_XMAX_IS_EXCL_LOCKED(infomask) &&
                             infomask2 & HEAP_KEYS_UPDATED)
                         {
                             result = TM_Ok;
                             goto out_unlocked;
                         }
                         break;
                 }
             }
         }
 
         /*
          * Initially assume that we will have to wait for the locking
          * transaction(s) to finish.  We check various cases below in which
          * this can be turned off.
          */
         require_sleep = true;
         if (mode == LockTupleKeyShare)
         {
             /*
              * If we're requesting KeyShare, and there's no update present, we
              * don't need to wait.  Even if there is an update, we can still
              * continue if the key hasn't been modified.
              *
              * However, if there are updates, we need to walk the update chain
              * to mark future versions of the row as locked, too.  That way,
              * if somebody deletes that future version, we're protected
              * against the key going away.  This locking of future versions
              * could block momentarily, if a concurrent transaction is
              * deleting a key; or it could return a value to the effect that
              * the transaction deleting the key has already committed.  So we
              * do this before re-locking the buffer; otherwise this would be
              * prone to deadlocks.
              *
              * Note that the TID we're locking was grabbed before we unlocked
              * the buffer.  For it to change while we're not looking, the
              * other properties we're testing for below after re-locking the
              * buffer would also change, in which case we would restart this
              * loop above.
              */
             if (!(infomask2 & HEAP_KEYS_UPDATED))
             {
                 bool        updated;
 
                 updated = !HEAP_XMAX_IS_LOCKED_ONLY(infomask);
 
                 /*
                  * If there are updates, follow the update chain; bail out if
                  * that cannot be done.
                  */
                 if (follow_updates && updated)
                 {
                     TM_Result   res;
 
                     res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
                                                   GetCurrentTransactionId(),
                                                   mode);
                     if (res != TM_Ok)
                     {
                         result = res;
                         /* recovery code expects to have buffer lock held */
                         LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                         goto failed;
                     }
                 }
 
                 LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
                 /*
                  * Make sure it's still an appropriate lock, else start over.
                  * Also, if it wasn't updated before we released the lock, but
                  * is updated now, we start over too; the reason is that we
                  * now need to follow the update chain to lock the new
                  * versions.
                  */
                 if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
                     ((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
                      !updated))
                     goto l3;
 
                 /* Things look okay, so we can skip sleeping */
                 require_sleep = false;
 
                 /*
                  * Note we allow Xmax to change here; other updaters/lockers
                  * could have modified it before we grabbed the buffer lock.
                  * However, this is not a problem, because with the recheck we
                  * just did we ensure that they still don't conflict with the
                  * lock we want.
                  */
             }
         }
         else if (mode == LockTupleShare)
         {
             /*
              * If we're requesting Share, we can similarly avoid sleeping if
              * there's no update and no exclusive lock present.
              */
             if (HEAP_XMAX_IS_LOCKED_ONLY(infomask) &&
                 !HEAP_XMAX_IS_EXCL_LOCKED(infomask))
             {
                 LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
                 /*
                  * Make sure it's still an appropriate lock, else start over.
                  * See above about allowing xmax to change.
                  */
                 if (!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
                     HEAP_XMAX_IS_EXCL_LOCKED(tuple->t_data->t_infomask))
                     goto l3;
                 require_sleep = false;
             }
         }
         else if (mode == LockTupleNoKeyExclusive)
         {
             /*
              * If we're requesting NoKeyExclusive, we might also be able to
              * avoid sleeping; just ensure that there no conflicting lock
              * already acquired.
              */
             if (infomask & HEAP_XMAX_IS_MULTI)
             {
                 if (!DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
                                              mode, NULL))
                 {
                     /*
                      * No conflict, but if the xmax changed under us in the
                      * meantime, start over.
                      */
                     LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                     if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
                         !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
                                              xwait))
                         goto l3;
 
                     /* otherwise, we're good */
                     require_sleep = false;
                 }
             }
             else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
             {
                 LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
                 /* if the xmax changed in the meantime, start over */
                 if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
                     !TransactionIdEquals(
                                          HeapTupleHeaderGetRawXmax(tuple->t_data),
                                          xwait))
                     goto l3;
                 /* otherwise, we're good */
                 require_sleep = false;
             }
         }
 
         /*
          * As a check independent from those above, we can also avoid sleeping
          * if the current transaction is the sole locker of the tuple.  Note
          * that the strength of the lock already held is irrelevant; this is
          * not about recording the lock in Xmax (which will be done regardless
          * of this optimization, below).  Also, note that the cases where we
          * hold a lock stronger than we are requesting are already handled
          * above by not doing anything.
          *
          * Note we only deal with the non-multixact case here; MultiXactIdWait
          * is well equipped to deal with this situation on its own.
          */
         if (require_sleep && !(infomask & HEAP_XMAX_IS_MULTI) &&
             TransactionIdIsCurrentTransactionId(xwait))
         {
             /* ... but if the xmax changed in the meantime, start over */
             LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
             if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
                 !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
                                      xwait))
                 goto l3;
             Assert(HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask));
             require_sleep = false;
         }
 
         /*
          * Time to sleep on the other transaction/multixact, if necessary.
          *
          * If the other transaction is an update/delete that's already
          * committed, then sleeping cannot possibly do any good: if we're
          * required to sleep, get out to raise an error instead.
          *
          * By here, we either have already acquired the buffer exclusive lock,
          * or we must wait for the locking transaction or multixact; so below
          * we ensure that we grab buffer lock after the sleep.
          */
         if (require_sleep && (result == TM_Updated || result == TM_Deleted))
         {
             LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
             goto failed;
         }
         else if (require_sleep)
         {
             /*
              * Acquire tuple lock to establish our priority for the tuple, or
              * die trying.  LockTuple will release us when we are next-in-line
              * for the tuple.  We must do this even if we are share-locking,
              * but not if we already have a weaker lock on the tuple.
              *
              * If we are forced to "start over" below, we keep the tuple lock;
              * this arranges that we stay at the head of the line while
              * rechecking tuple state.
              */
             if (!skip_tuple_lock &&
                 !heap_acquire_tuplock(relation, tid, mode, wait_policy,
                                       &have_tuple_lock))
             {
                 /*
                  * This can only happen if wait_policy is Skip and the lock
                  * couldn't be obtained.
                  */
                 result = TM_WouldBlock;
                 /* recovery code expects to have buffer lock held */
                 LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                 goto failed;
             }
 
             if (infomask & HEAP_XMAX_IS_MULTI)
             {
                 MultiXactStatus status = get_mxact_status_for_lock(mode, false);
 
                 /* We only ever lock tuples, never update them */
                 if (status >= MultiXactStatusNoKeyUpdate)
                     elog(ERROR, "invalid lock mode in heap_lock_tuple");
 
                 /* wait for multixact to end, or die trying  */
                 switch (wait_policy)
                 {
                     case LockWaitBlock:
                         MultiXactIdWait((MultiXactId) xwait, status, infomask,
                                         relation, &tuple->t_self, XLTW_Lock, NULL);
                         break;
                     case LockWaitSkip:
                         if (!ConditionalMultiXactIdWait((MultiXactId) xwait,
                                                         status, infomask, relation,
                                                         NULL))
                         {
                             result = TM_WouldBlock;
                             /* recovery code expects to have buffer lock held */
                             LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                             goto failed;
                         }
                         break;
                     case LockWaitError:
                         if (!ConditionalMultiXactIdWait((MultiXactId) xwait,
                                                         status, infomask, relation,
                                                         NULL))
                             ereport(ERROR,
                                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                                      errmsg("could not obtain lock on row in relation \"%s\"",
                                             RelationGetRelationName(relation))));
 
                         break;
                 }
 
                 /*
                  * Of course, the multixact might not be done here: if we're
                  * requesting a light lock mode, other transactions with light
                  * locks could still be alive, as well as locks owned by our
                  * own xact or other subxacts of this backend.  We need to
                  * preserve the surviving MultiXact members.  Note that it
                  * isn't absolutely necessary in the latter case, but doing so
                  * is simpler.
                  */
             }
             else
             {
                 /* wait for regular transaction to end, or die trying */
                 switch (wait_policy)
                 {
                     case LockWaitBlock:
                         XactLockTableWait(xwait, relation, &tuple->t_self,
                                           XLTW_Lock);
                         break;
                     case LockWaitSkip:
                         if (!ConditionalXactLockTableWait(xwait))
                         {
                             result = TM_WouldBlock;
                             /* recovery code expects to have buffer lock held */
                             LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                             goto failed;
                         }
                         break;
                     case LockWaitError:
                         if (!ConditionalXactLockTableWait(xwait))
                             ereport(ERROR,
                                     (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                                      errmsg("could not obtain lock on row in relation \"%s\"",
                                             RelationGetRelationName(relation))));
                         break;
                 }
             }
 
             /* if there are updates, follow the update chain */
             if (follow_updates && !HEAP_XMAX_IS_LOCKED_ONLY(infomask))
             {
                 TM_Result   res;
 
                 res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
                                               GetCurrentTransactionId(),
                                               mode);
                 if (res != TM_Ok)
                 {
                     result = res;
                     /* recovery code expects to have buffer lock held */
                     LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                     goto failed;
                 }
             }
 
             LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
 
             /*
              * xwait is done, but if xwait had just locked the tuple then some
              * other xact could update this tuple before we get to this point.
              * Check for xmax change, and start over if so.
              */
             if (xmax_infomask_changed(tuple->t_data->t_infomask, infomask) ||
                 !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
                                      xwait))
                 goto l3;
 
             if (!(infomask & HEAP_XMAX_IS_MULTI))
             {
                 /*
                  * Otherwise check if it committed or aborted.  Note we cannot
                  * be here if the tuple was only locked by somebody who didn't
                  * conflict with us; that would have been handled above.  So
                  * that transaction must necessarily be gone by now.  But
                  * don't check for this in the multixact case, because some
                  * locker transactions might still be running.
                  */
                 UpdateXmaxHintBits(tuple->t_data, *buffer, xwait);
             }
         }
 
         /* By here, we're certain that we hold buffer exclusive lock again */
 
         /*
          * We may lock if previous xmax aborted, or if it committed but only
          * locked the tuple without updating it; or if we didn't have to wait
          * at all for whatever reason.
          */
         if (!require_sleep ||
             (tuple->t_data->t_infomask & HEAP_XMAX_INVALID) ||
             HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_data->t_infomask) ||
             HeapTupleHeaderIsOnlyLocked(tuple->t_data))
             result = TM_Ok;
         else if (!ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid) ||
                  HeapTupleHeaderIndicatesMovedPartitions(tuple->t_data))
             result = TM_Updated;
         else
             result = TM_Deleted;
     }
 
 failed:
     if (result != TM_Ok)
     {
         Assert(result == TM_SelfModified || result == TM_Updated ||
                result == TM_Deleted || result == TM_WouldBlock);
         Assert(!(tuple->t_data->t_infomask & HEAP_XMAX_INVALID));
         Assert(result != TM_Updated ||
                !ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid));
         tmfd->ctid = tuple->t_data->t_ctid;
         tmfd->xmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
         if (result == TM_SelfModified)
             tmfd->cmax = HeapTupleHeaderGetCmax(tuple->t_data);
         else
             tmfd->cmax = InvalidCommandId;
         goto out_locked;
     }
 
     /*
      * If we didn't pin the visibility map page and the page has become all
      * visible while we were busy locking the buffer, or during some
      * subsequent window during which we had it unlocked, we'll have to unlock
      * and re-lock, to avoid holding the buffer lock across I/O.  That's a bit
      * unfortunate, especially since we'll now have to recheck whether the
      * tuple has been locked or updated under us, but hopefully it won't
      * happen very often.
      */
     if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
     {
         LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
         visibilitymap_pin(relation, block, &vmbuffer);
         LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
         goto l3;
     }
 
     xmax = HeapTupleHeaderGetRawXmax(tuple->t_data);
     old_infomask = tuple->t_data->t_infomask;
 
     /*
      * If this is the first possibly-multixact-able operation in the current
      * transaction, set my per-backend OldestMemberMXactId setting. We can be
      * certain that the transaction will never become a member of any older
      * MultiXactIds than that.  (We have to do this even if we end up just
      * using our own TransactionId below, since some other backend could
      * incorporate our XID into a MultiXact immediately afterwards.)
      */
     MultiXactIdSetOldestMember();
 
     /*
      * Compute the new xmax and infomask to store into the tuple.  Note we do
      * not modify the tuple just yet, because that would leave it in the wrong
      * state if multixact.c elogs.
      */
     compute_new_xmax_infomask(xmax, old_infomask, tuple->t_data->t_infomask2,
                               GetCurrentTransactionId(), mode, false,
                               &xid, &new_infomask, &new_infomask2);
 
     START_CRIT_SECTION();
 
     /*
      * Store transaction information of xact locking the tuple.
      *
      * Note: Cmax is meaningless in this context, so don't set it; this avoids
      * possibly generating a useless combo CID.  Moreover, if we're locking a
      * previously updated tuple, it's important to preserve the Cmax.
      *
      * Also reset the HOT UPDATE bit, but only if there's no update; otherwise
      * we would break the HOT chain.
      */
     tuple->t_data->t_infomask &= ~HEAP_XMAX_BITS;
     tuple->t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
     tuple->t_data->t_infomask |= new_infomask;
     tuple->t_data->t_infomask2 |= new_infomask2;
     if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
         HeapTupleHeaderClearHotUpdated(tuple->t_data);
     HeapTupleHeaderSetXmax(tuple->t_data, xid);
 
     /*
      * Make sure there is no forward chain link in t_ctid.  Note that in the
      * cases where the tuple has been updated, we must not overwrite t_ctid,
      * because it was set by the updater.  Moreover, if the tuple has been
      * updated, we need to follow the update chain to lock the new versions of
      * the tuple as well.
      */
     if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
         tuple->t_data->t_ctid = *tid;
 
     /* Clear only the all-frozen bit on visibility map if needed */
     if (PageIsAllVisible(page) &&
         visibilitymap_clear(relation, block, vmbuffer,
                             VISIBILITYMAP_ALL_FROZEN))
         cleared_all_frozen = true;
 
 
     MarkBufferDirty(*buffer);
 
     /*
      * XLOG stuff.  You might think that we don't need an XLOG record because
      * there is no state change worth restoring after a crash.  You would be
      * wrong however: we have just written either a TransactionId or a
      * MultiXactId that may never have been seen on disk before, and we need
      * to make sure that there are XLOG entries covering those ID numbers.
      * Else the same IDs might be re-used after a crash, which would be
      * disastrous if this page made it to disk before the crash.  Essentially
      * we have to enforce the WAL log-before-data rule even in this case.
      * (Also, in a PITR log-shipping or 2PC environment, we have to have XLOG
      * entries for everything anyway.)
      */
     if (RelationNeedsWAL(relation))
     {
         xl_heap_lock xlrec;
         XLogRecPtr  recptr;
 
         XLogBeginInsert();
         XLogRegisterBuffer(0, *buffer, REGBUF_STANDARD);
 
         xlrec.offnum = ItemPointerGetOffsetNumber(&tuple->t_self);
         xlrec.locking_xid = xid;
         xlrec.infobits_set = compute_infobits(new_infomask,
                                               tuple->t_data->t_infomask2);
         xlrec.flags = cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
         XLogRegisterData((char *) &xlrec, SizeOfHeapLock);
 
         /* we don't decode row locks atm, so no need to log the origin */
 
         recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_LOCK);
 
         PageSetLSN(page, recptr);
     }
 
     END_CRIT_SECTION();
 
     result = TM_Ok;
 
 out_locked:
     LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
 
 out_unlocked:
     if (BufferIsValid(vmbuffer))
         ReleaseBuffer(vmbuffer);
 
     /*
      * Don't update the visibility map here. Locking a tuple doesn't change
      * visibility info.
      */
 
     /*
      * Now that we have successfully marked the tuple as locked, we can
      * release the lmgr tuple lock, if we had it.
      */
     if (have_tuple_lock)
         UnlockTupleTuplock(relation, tid, mode);
 
     return result;
 }

◆ heap_multi_insert()

void heap_multi_insert	(	Relation	relation,
		struct TupleTableSlot **	slots,
		int	ntuples,
		CommandId	cid,
		int	options,
		BulkInsertState	bistate
	)

Definition at line 2105 of file heapam.c.

References Assert, AssertArg, BufferGetBlockNumber(), BufferGetPage, CacheInvalidateHeapTuple(), CHECK_FOR_INTERRUPTS, CheckForSerializableConflictIn(), PGAlignedBlock::data, xl_multi_insert_tuple::datalen, END_CRIT_SECTION, ExecFetchSlotHeapTuple(), FirstOffsetNumber, xl_heap_multi_insert::flags, GetCurrentTransactionId(), HEAP_DEFAULT_FILLFACTOR, HEAP_INSERT_NO_LOGICAL, HEAP_INSERT_SKIP_WAL, heap_prepare_insert(), i, init, InvalidBuffer, IsCatalogRelation(), ItemPointerGetOffsetNumber, log_heap_new_cid(), MarkBufferDirty(), MAXALIGN, xl_heap_multi_insert::ntuples, xl_heap_multi_insert::offsets, PageClearAllVisible, PageGetHeapFreeSpace(), PageGetMaxOffsetNumber, PageIsAllVisible, PageSetLSN, palloc(), pgstat_count_heap_insert(), REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetRelid, RelationGetTargetPageFreeSpace, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SHORTALIGN, SizeOfHeapMultiInsert, SizeofHeapTupleHeader, SizeOfMultiInsertTuple, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, xl_multi_insert_tuple::t_hoff, HeapTupleHeaderData::t_infomask, xl_multi_insert_tuple::t_infomask, HeapTupleHeaderData::t_infomask2, xl_multi_insert_tuple::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleTableSlot::tts_tableOid, UnlockReleaseBuffer(), visibilitymap_clear(), VISIBILITYMAP_VALID_BITS, XLH_INSERT_ALL_VISIBLE_CLEARED, XLH_INSERT_CONTAINS_NEW_TUPLE, XLH_INSERT_LAST_IN_MULTI, XLOG_HEAP2_MULTI_INSERT, XLOG_HEAP_INIT_PAGE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), XLogRegisterData(), and XLogSetRecordFlags().

Referenced by SampleHeapTupleVisible().

 {
     TransactionId xid = GetCurrentTransactionId();
     HeapTuple  *heaptuples;
     int         i;
     int         ndone;
     PGAlignedBlock scratch;
     Page        page;
     bool        needwal;
     Size        saveFreeSpace;
     bool        need_tuple_data = RelationIsLogicallyLogged(relation);
     bool        need_cids = RelationIsAccessibleInLogicalDecoding(relation);
 
     /* currently not needed (thus unsupported) for heap_multi_insert() */
     AssertArg(!(options & HEAP_INSERT_NO_LOGICAL));
 
     needwal = !(options & HEAP_INSERT_SKIP_WAL) && RelationNeedsWAL(relation);
     saveFreeSpace = RelationGetTargetPageFreeSpace(relation,
                                                    HEAP_DEFAULT_FILLFACTOR);
 
     /* Toast and set header data in all the slots */
     heaptuples = palloc(ntuples * sizeof(HeapTuple));
     for (i = 0; i < ntuples; i++)
     {
         HeapTuple   tuple;
 
         tuple = ExecFetchSlotHeapTuple(slots[i], true, NULL);
         slots[i]->tts_tableOid = RelationGetRelid(relation);
         tuple->t_tableOid = slots[i]->tts_tableOid;
         heaptuples[i] = heap_prepare_insert(relation, tuple, xid, cid,
                                             options);
     }
 
     /*
      * We're about to do the actual inserts -- but check for conflict first,
      * to minimize the possibility of having to roll back work we've just
      * done.
      *
      * A check here does not definitively prevent a serialization anomaly;
      * that check MUST be done at least past the point of acquiring an
      * exclusive buffer content lock on every buffer that will be affected,
      * and MAY be done after all inserts are reflected in the buffers and
      * those locks are released; otherwise there is a race condition.  Since
      * multiple buffers can be locked and unlocked in the loop below, and it
      * would not be feasible to identify and lock all of those buffers before
      * the loop, we must do a final check at the end.
      *
      * The check here could be omitted with no loss of correctness; it is
      * present strictly as an optimization.
      *
      * For heap inserts, we only need to check for table-level SSI locks. Our
      * new tuples can't possibly conflict with existing tuple locks, and heap
      * page locks are only consolidated versions of tuple locks; they do not
      * lock "gaps" as index page locks do.  So we don't need to specify a
      * buffer when making the call, which makes for a faster check.
      */
     CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
 
     ndone = 0;
     while (ndone < ntuples)
     {
         Buffer      buffer;
         Buffer      vmbuffer = InvalidBuffer;
         bool        all_visible_cleared = false;
         int         nthispage;
 
         CHECK_FOR_INTERRUPTS();
 
         /*
          * Find buffer where at least the next tuple will fit.  If the page is
          * all-visible, this will also pin the requisite visibility map page.
          */
         buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
                                            InvalidBuffer, options, bistate,
                                            &vmbuffer, NULL);
         page = BufferGetPage(buffer);
 
         /* NO EREPORT(ERROR) from here till changes are logged */
         START_CRIT_SECTION();
 
         /*
          * RelationGetBufferForTuple has ensured that the first tuple fits.
          * Put that on the page, and then as many other tuples as fit.
          */
         RelationPutHeapTuple(relation, buffer, heaptuples[ndone], false);
         for (nthispage = 1; ndone + nthispage < ntuples; nthispage++)
         {
             HeapTuple   heaptup = heaptuples[ndone + nthispage];
 
             if (PageGetHeapFreeSpace(page) < MAXALIGN(heaptup->t_len) + saveFreeSpace)
                 break;
 
             RelationPutHeapTuple(relation, buffer, heaptup, false);
 
             /*
              * We don't use heap_multi_insert for catalog tuples yet, but
              * better be prepared...
              */
             if (needwal && need_cids)
                 log_heap_new_cid(relation, heaptup);
         }
 
         if (PageIsAllVisible(page))
         {
             all_visible_cleared = true;
             PageClearAllVisible(page);
             visibilitymap_clear(relation,
                                 BufferGetBlockNumber(buffer),
                                 vmbuffer, VISIBILITYMAP_VALID_BITS);
         }
 
         /*
          * XXX Should we set PageSetPrunable on this page ? See heap_insert()
          */
 
         MarkBufferDirty(buffer);
 
         /* XLOG stuff */
         if (needwal)
         {
             XLogRecPtr  recptr;
             xl_heap_multi_insert *xlrec;
             uint8       info = XLOG_HEAP2_MULTI_INSERT;
             char       *tupledata;
             int         totaldatalen;
             char       *scratchptr = scratch.data;
             bool        init;
             int         bufflags = 0;
 
             /*
              * If the page was previously empty, we can reinit the page
              * instead of restoring the whole thing.
              */
             init = (ItemPointerGetOffsetNumber(&(heaptuples[ndone]->t_self)) == FirstOffsetNumber &&
                     PageGetMaxOffsetNumber(page) == FirstOffsetNumber + nthispage - 1);
 
             /* allocate xl_heap_multi_insert struct from the scratch area */
             xlrec = (xl_heap_multi_insert *) scratchptr;
             scratchptr += SizeOfHeapMultiInsert;
 
             /*
              * Allocate offsets array. Unless we're reinitializing the page,
              * in that case the tuples are stored in order starting at
              * FirstOffsetNumber and we don't need to store the offsets
              * explicitly.
              */
             if (!init)
                 scratchptr += nthispage * sizeof(OffsetNumber);
 
             /* the rest of the scratch space is used for tuple data */
             tupledata = scratchptr;
 
             xlrec->flags = all_visible_cleared ? XLH_INSERT_ALL_VISIBLE_CLEARED : 0;
             xlrec->ntuples = nthispage;
 
             /*
              * Write out an xl_multi_insert_tuple and the tuple data itself
              * for each tuple.
              */
             for (i = 0; i < nthispage; i++)
             {
                 HeapTuple   heaptup = heaptuples[ndone + i];
                 xl_multi_insert_tuple *tuphdr;
                 int         datalen;
 
                 if (!init)
                     xlrec->offsets[i] = ItemPointerGetOffsetNumber(&heaptup->t_self);
                 /* xl_multi_insert_tuple needs two-byte alignment. */
                 tuphdr = (xl_multi_insert_tuple *) SHORTALIGN(scratchptr);
                 scratchptr = ((char *) tuphdr) + SizeOfMultiInsertTuple;
 
                 tuphdr->t_infomask2 = heaptup->t_data->t_infomask2;
                 tuphdr->t_infomask = heaptup->t_data->t_infomask;
                 tuphdr->t_hoff = heaptup->t_data->t_hoff;
 
                 /* write bitmap [+ padding] [+ oid] + data */
                 datalen = heaptup->t_len - SizeofHeapTupleHeader;
                 memcpy(scratchptr,
                        (char *) heaptup->t_data + SizeofHeapTupleHeader,
                        datalen);
                 tuphdr->datalen = datalen;
                 scratchptr += datalen;
             }
             totaldatalen = scratchptr - tupledata;
             Assert((scratchptr - scratch.data) < BLCKSZ);
 
             if (need_tuple_data)
                 xlrec->flags |= XLH_INSERT_CONTAINS_NEW_TUPLE;
 
             /*
              * Signal that this is the last xl_heap_multi_insert record
              * emitted by this call to heap_multi_insert(). Needed for logical
              * decoding so it knows when to cleanup temporary data.
              */
             if (ndone + nthispage == ntuples)
                 xlrec->flags |= XLH_INSERT_LAST_IN_MULTI;
 
             if (init)
             {
                 info |= XLOG_HEAP_INIT_PAGE;
                 bufflags |= REGBUF_WILL_INIT;
             }
 
             /*
              * If we're doing logical decoding, include the new tuple data
              * even if we take a full-page image of the page.
              */
             if (need_tuple_data)
                 bufflags |= REGBUF_KEEP_DATA;
 
             XLogBeginInsert();
             XLogRegisterData((char *) xlrec, tupledata - scratch.data);
             XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
 
             XLogRegisterBufData(0, tupledata, totaldatalen);
 
             /* filtering by origin on a row level is much more efficient */
             XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
             recptr = XLogInsert(RM_HEAP2_ID, info);
 
             PageSetLSN(page, recptr);
         }
 
         END_CRIT_SECTION();
 
         UnlockReleaseBuffer(buffer);
         if (vmbuffer != InvalidBuffer)
             ReleaseBuffer(vmbuffer);
 
         ndone += nthispage;
     }
 
     /*
      * We're done with the actual inserts.  Check for conflicts again, to
      * ensure that all rw-conflicts in to these inserts are detected.  Without
      * this final check, a sequential scan of the heap may have locked the
      * table after the "before" check, missing one opportunity to detect the
      * conflict, and then scanned the table before the new tuples were there,
      * missing the other chance to detect the conflict.
      *
      * For heap inserts, we only need to check for table-level SSI locks. Our
      * new tuples can't possibly conflict with existing tuple locks, and heap
      * page locks are only consolidated versions of tuple locks; they do not
      * lock "gaps" as index page locks do.  So we don't need to specify a
      * buffer when making the call.
      */
     CheckForSerializableConflictIn(relation, NULL, InvalidBuffer);
 
     /*
      * If tuples are cachable, mark them for invalidation from the caches in
      * case we abort.  Note it is OK to do this after releasing the buffer,
      * because the heaptuples data structure is all in local memory, not in
      * the shared buffer.
      */
     if (IsCatalogRelation(relation))
     {
         for (i = 0; i < ntuples; i++)
             CacheInvalidateHeapTuple(relation, heaptuples[i], NULL);
     }
 
     /* copy t_self fields back to the caller's slots */
     for (i = 0; i < ntuples; i++)
         slots[i]->tts_tid = heaptuples[i]->t_self;
 
     pgstat_count_heap_insert(relation, ntuples);
 }

◆ heap_page_prune()

int heap_page_prune	(	Relation	relation,
		Buffer	buffer,
		TransactionId	OldestXmin,
		bool	report_stats,
		TransactionId *	latestRemovedXid
	)

Definition at line 180 of file pruneheap.c.

References BufferGetPage, END_CRIT_SECTION, FirstOffsetNumber, heap_page_prune_execute(), heap_prune_chain(), InvalidTransactionId, ItemIdIsDead, ItemIdIsUsed, PruneState::latestRemovedXid, log_heap_clean(), MarkBufferDirty(), MarkBufferDirtyHint(), PruneState::marked, PruneState::ndead, PruneState::new_prune_xid, PruneState::nowdead, PruneState::nowunused, PruneState::nredirected, PruneState::nunused, OffsetNumberNext, PageClearFull, PageGetItemId, PageGetMaxOffsetNumber, PageIsFull, PageSetLSN, pgstat_update_heap_dead_tuples(), PruneState::redirected, RelationNeedsWAL, and START_CRIT_SECTION.

Referenced by heap_page_prune_opt(), and lazy_scan_heap().

 {
     int         ndeleted = 0;
     Page        page = BufferGetPage(buffer);
     OffsetNumber offnum,
                 maxoff;
     PruneState  prstate;
 
     /*
      * Our strategy is to scan the page and make lists of items to change,
      * then apply the changes within a critical section.  This keeps as much
      * logic as possible out of the critical section, and also ensures that
      * WAL replay will work the same as the normal case.
      *
      * First, initialize the new pd_prune_xid value to zero (indicating no
      * prunable tuples).  If we find any tuples which may soon become
      * prunable, we will save the lowest relevant XID in new_prune_xid. Also
      * initialize the rest of our working state.
      */
     prstate.new_prune_xid = InvalidTransactionId;
     prstate.latestRemovedXid = *latestRemovedXid;
     prstate.nredirected = prstate.ndead = prstate.nunused = 0;
     memset(prstate.marked, 0, sizeof(prstate.marked));
 
     /* Scan the page */
     maxoff = PageGetMaxOffsetNumber(page);
     for (offnum = FirstOffsetNumber;
          offnum <= maxoff;
          offnum = OffsetNumberNext(offnum))
     {
         ItemId      itemid;
 
         /* Ignore items already processed as part of an earlier chain */
         if (prstate.marked[offnum])
             continue;
 
         /* Nothing to do if slot is empty or already dead */
         itemid = PageGetItemId(page, offnum);
         if (!ItemIdIsUsed(itemid) || ItemIdIsDead(itemid))
             continue;
 
         /* Process this item or chain of items */
         ndeleted += heap_prune_chain(relation, buffer, offnum,
                                      OldestXmin,
                                      &prstate);
     }
 
     /* Any error while applying the changes is critical */
     START_CRIT_SECTION();
 
     /* Have we found any prunable items? */
     if (prstate.nredirected > 0 || prstate.ndead > 0 || prstate.nunused > 0)
     {
         /*
          * Apply the planned item changes, then repair page fragmentation, and
          * update the page's hint bit about whether it has free line pointers.
          */
         heap_page_prune_execute(buffer,
                                 prstate.redirected, prstate.nredirected,
                                 prstate.nowdead, prstate.ndead,
                                 prstate.nowunused, prstate.nunused);
 
         /*
          * Update the page's pd_prune_xid field to either zero, or the lowest
          * XID of any soon-prunable tuple.
          */
         ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
 
         /*
          * Also clear the "page is full" flag, since there's no point in
          * repeating the prune/defrag process until something else happens to
          * the page.
          */
         PageClearFull(page);
 
         MarkBufferDirty(buffer);
 
         /*
          * Emit a WAL XLOG_HEAP2_CLEAN record showing what we did
          */
         if (RelationNeedsWAL(relation))
         {
             XLogRecPtr  recptr;
 
             recptr = log_heap_clean(relation, buffer,
                                     prstate.redirected, prstate.nredirected,
                                     prstate.nowdead, prstate.ndead,
                                     prstate.nowunused, prstate.nunused,
                                     prstate.latestRemovedXid);
 
             PageSetLSN(BufferGetPage(buffer), recptr);
         }
     }
     else
     {
         /*
          * If we didn't prune anything, but have found a new value for the
          * pd_prune_xid field, update it and mark the buffer dirty. This is
          * treated as a non-WAL-logged hint.
          *
          * Also clear the "page is full" flag if it is set, since there's no
          * point in repeating the prune/defrag process until something else
          * happens to the page.
          */
         if (((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
             PageIsFull(page))
         {
             ((PageHeader) page)->pd_prune_xid = prstate.new_prune_xid;
             PageClearFull(page);
             MarkBufferDirtyHint(buffer, true);
         }
     }
 
     END_CRIT_SECTION();
 
     /*
      * If requested, report the number of tuples reclaimed to pgstats. This is
      * ndeleted minus ndead, because we don't want to count a now-DEAD root
      * item as a deletion for this purpose.
      */
     if (report_stats && ndeleted > prstate.ndead)
         pgstat_update_heap_dead_tuples(relation, ndeleted - prstate.ndead);
 
     *latestRemovedXid = prstate.latestRemovedXid;
 
     /*
      * XXX Should we update the FSM information of this page ?
      *
      * There are two schools of thought here. We may not want to update FSM
      * information so that the page is not used for unrelated UPDATEs/INSERTs
      * and any free space in this page will remain available for further
      * UPDATEs in *this* page, thus improving chances for doing HOT updates.
      *
      * But for a large table and where a page does not receive further UPDATEs
      * for a long time, we might waste this space by not updating the FSM
      * information. The relation may get extended and fragmented further.
      *
      * One possibility is to leave "fillfactor" worth of space in this page
      * and update FSM with the remaining space.
      */
 
     return ndeleted;
 }

◆ heap_page_prune_execute()

void heap_page_prune_execute	(	Buffer	buffer,
		OffsetNumber *	redirected,
		int	nredirected,
		OffsetNumber *	nowdead,
		int	ndead,
		OffsetNumber *	nowunused,
		int	nunused
	)

Definition at line 681 of file pruneheap.c.

References BufferGetPage, i, ItemIdSetDead, ItemIdSetRedirect, ItemIdSetUnused, PageGetItemId, and PageRepairFragmentation().

Referenced by heap_page_prune(), and heap_xlog_clean().

 {
     Page        page = (Page) BufferGetPage(buffer);
     OffsetNumber *offnum;
     int         i;
 
     /* Update all redirected line pointers */
     offnum = redirected;
     for (i = 0; i < nredirected; i++)
     {
         OffsetNumber fromoff = *offnum++;
         OffsetNumber tooff = *offnum++;
         ItemId      fromlp = PageGetItemId(page, fromoff);
 
         ItemIdSetRedirect(fromlp, tooff);
     }
 
     /* Update all now-dead line pointers */
     offnum = nowdead;
     for (i = 0; i < ndead; i++)
     {
         OffsetNumber off = *offnum++;
         ItemId      lp = PageGetItemId(page, off);
 
         ItemIdSetDead(lp);
     }
 
     /* Update all now-unused line pointers */
     offnum = nowunused;
     for (i = 0; i < nunused; i++)
     {
         OffsetNumber off = *offnum++;
         ItemId      lp = PageGetItemId(page, off);
 
         ItemIdSetUnused(lp);
     }
 
     /*
      * Finally, repair any fragmentation, and update the page's hint bit about
      * whether it has free pointers.
      */
     PageRepairFragmentation(page);
 }

◆ heap_page_prune_opt()

void heap_page_prune_opt	(	Relation	relation,
		Buffer	buffer
	)

Definition at line 73 of file pruneheap.c.

References Assert, BUFFER_LOCK_UNLOCK, BufferGetPage, ConditionalLockBufferForCleanup(), HEAP_DEFAULT_FILLFACTOR, heap_page_prune(), InvalidTransactionId, IsCatalogRelation(), LockBuffer(), Max, OldestXmin, PageGetHeapFreeSpace(), PageIsFull, PageIsPrunable, RecentGlobalDataXmin, RecentGlobalXmin, RecoveryInProgress(), RelationGetTargetPageFreeSpace, RelationIsAccessibleInLogicalDecoding, TransactionIdIsValid, and TransactionIdLimitedForOldSnapshots().

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

 {
     Page        page = BufferGetPage(buffer);
     Size        minfree;
     TransactionId OldestXmin;
 
     /*
      * We can't write WAL in recovery mode, so there's no point trying to
      * clean the page. The master will likely issue a cleaning WAL record soon
      * anyway, so this is no particular loss.
      */
     if (RecoveryInProgress())
         return;
 
     /*
      * Use the appropriate xmin horizon for this relation. If it's a proper
      * catalog relation or a user defined, additional, catalog relation, we
      * need to use the horizon that includes slots, otherwise the data-only
      * horizon can be used. Note that the toast relation of user defined
      * relations are *not* considered catalog relations.
      *
      * It is OK to apply the old snapshot limit before acquiring the cleanup
      * lock because the worst that can happen is that we are not quite as
      * aggressive about the cleanup (by however many transaction IDs are
      * consumed between this point and acquiring the lock).  This allows us to
      * save significant overhead in the case where the page is found not to be
      * prunable.
      */
     if (IsCatalogRelation(relation) ||
         RelationIsAccessibleInLogicalDecoding(relation))
         OldestXmin = RecentGlobalXmin;
     else
         OldestXmin =
             TransactionIdLimitedForOldSnapshots(RecentGlobalDataXmin,
                                                 relation);
 
     Assert(TransactionIdIsValid(OldestXmin));
 
     /*
      * Let's see if we really need pruning.
      *
      * Forget it if page is not hinted to contain something prunable that's
      * older than OldestXmin.
      */
     if (!PageIsPrunable(page, OldestXmin))
         return;
 
     /*
      * We prune when a previous UPDATE failed to find enough space on the page
      * for a new tuple version, or when free space falls below the relation's
      * fill-factor target (but not less than 10%).
      *
      * Checking free space here is questionable since we aren't holding any
      * lock on the buffer; in the worst case we could get a bogus answer. It's
      * unlikely to be *seriously* wrong, though, since reading either pd_lower
      * or pd_upper is probably atomic.  Avoiding taking a lock seems more
      * important than sometimes getting a wrong answer in what is after all
      * just a heuristic estimate.
      */
     minfree = RelationGetTargetPageFreeSpace(relation,
                                              HEAP_DEFAULT_FILLFACTOR);
     minfree = Max(minfree, BLCKSZ / 10);
 
     if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
     {
         /* OK, try to get exclusive buffer lock */
         if (!ConditionalLockBufferForCleanup(buffer))
             return;
 
         /*
          * Now that we have buffer lock, get accurate information about the
          * page's free space, and recheck the heuristic about whether to
          * prune. (We needn't recheck PageIsPrunable, since no one else could
          * have pruned while we hold pin.)
          */
         if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
         {
             TransactionId ignore = InvalidTransactionId;    /* return value not
                                                              * needed */
 
             /* OK to prune */
             (void) heap_page_prune(relation, buffer, OldestXmin, true, &ignore);
         }
 
         /* And release buffer lock */
         LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
     }
 }

◆ heap_rescan()

void heap_rescan	(	TableScanDesc	scan,
		ScanKey	key,
		bool	set_params,
		bool	allow_strat,
		bool	allow_sync,
		bool	allow_pagemode
	)

Definition at line 1208 of file heapam.c.

References BufferIsValid, initscan(), IsMVCCSnapshot, ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, and SO_ALLOW_SYNC.

Referenced by SampleHeapTupleVisible().

 {
     HeapScanDesc scan = (HeapScanDesc) sscan;
 
     if (set_params)
     {
         if (allow_strat)
             scan->rs_base.rs_flags |= SO_ALLOW_STRAT;
         else
             scan->rs_base.rs_flags &= ~SO_ALLOW_STRAT;
 
         if (allow_sync)
             scan->rs_base.rs_flags |= SO_ALLOW_SYNC;
         else
             scan->rs_base.rs_flags &= ~SO_ALLOW_SYNC;
 
         if (allow_pagemode && scan->rs_base.rs_snapshot &&
             IsMVCCSnapshot(scan->rs_base.rs_snapshot))
             scan->rs_base.rs_flags |= SO_ALLOW_PAGEMODE;
         else
             scan->rs_base.rs_flags &= ~SO_ALLOW_PAGEMODE;
     }
 
     /*
      * unpin scan buffers
      */
     if (BufferIsValid(scan->rs_cbuf))
         ReleaseBuffer(scan->rs_cbuf);
 
     /*
      * reinitialize scan descriptor
      */
     initscan(scan, key, true);
 }

◆ heap_setscanlimits()

void heap_setscanlimits	(	TableScanDesc	scan,
		BlockNumber	startBlk,
		BlockNumber	numBlks
	)

Definition at line 329 of file heapam.c.

References Assert, HeapScanDescData::rs_base, TableScanDescData::rs_flags, HeapScanDescData::rs_inited, HeapScanDescData::rs_numblocks, HeapScanDescData::rs_startblock, and SO_ALLOW_SYNC.

Referenced by heapam_index_build_range_scan().

 {
     HeapScanDesc scan = (HeapScanDesc) sscan;
 
     Assert(!scan->rs_inited);   /* else too late to change */
     /* else rs_startblock is significant */
     Assert(!(scan->rs_base.rs_flags & SO_ALLOW_SYNC));
 
     /* Check startBlk is valid (but allow case of zero blocks...) */
     Assert(startBlk == 0 || startBlk < scan->rs_nblocks);
 
     scan->rs_startblock = startBlk;
     scan->rs_numblocks = numBlks;
 }

◆ heap_sync()

void heap_sync ( Relation relation )

Definition at line 8938 of file heapam.c.

References AccessShareLock, FlushRelationBuffers(), MAIN_FORKNUM, OidIsValid, RelationData::rd_rel, RelationData::rd_smgr, RelationNeedsWAL, smgrimmedsync(), table_close(), and table_open().

Referenced by end_heap_rewrite(), and heapam_finish_bulk_insert().

 {
     /* non-WAL-logged tables never need fsync */
     if (!RelationNeedsWAL(rel))
         return;
 
     /* main heap */
     FlushRelationBuffers(rel);
     /* FlushRelationBuffers will have opened rd_smgr */
     smgrimmedsync(rel->rd_smgr, MAIN_FORKNUM);
 
     /* FSM is not critical, don't bother syncing it */
 
     /* toast heap, if any */
     if (OidIsValid(rel->rd_rel->reltoastrelid))
     {
         Relation    toastrel;
 
         toastrel = table_open(rel->rd_rel->reltoastrelid, AccessShareLock);
         FlushRelationBuffers(toastrel);
         smgrimmedsync(toastrel->rd_smgr, MAIN_FORKNUM);
         table_close(toastrel, AccessShareLock);
     }
 }

◆ heap_tuple_needs_eventual_freeze()

bool heap_tuple_needs_eventual_freeze ( HeapTupleHeader tuple )

Definition at line 6763 of file heapam.c.

References HEAP_MOVED, HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetXmin, HeapTupleHeaderGetXvac, MultiXactIdIsValid, HeapTupleHeaderData::t_infomask, and TransactionIdIsNormal.

Referenced by collect_corrupt_items(), and heap_page_is_all_visible().

 {
     TransactionId xid;
 
     /*
      * If xmin is a normal transaction ID, this tuple is definitely not
      * frozen.
      */
     xid = HeapTupleHeaderGetXmin(tuple);
     if (TransactionIdIsNormal(xid))
         return true;
 
     /*
      * If xmax is a valid xact or multixact, this tuple is also not frozen.
      */
     if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
     {
         MultiXactId multi;
 
         multi = HeapTupleHeaderGetRawXmax(tuple);
         if (MultiXactIdIsValid(multi))
             return true;
     }
     else
     {
         xid = HeapTupleHeaderGetRawXmax(tuple);
         if (TransactionIdIsNormal(xid))
             return true;
     }
 
     if (tuple->t_infomask & HEAP_MOVED)
     {
         xid = HeapTupleHeaderGetXvac(tuple);
         if (TransactionIdIsNormal(xid))
             return true;
     }
 
     return false;
 }

◆ heap_tuple_needs_freeze()

bool heap_tuple_needs_freeze	(	HeapTupleHeader	tuple,
		TransactionId	cutoff_xid,
		MultiXactId	cutoff_multi,
		Buffer	buf
	)

Definition at line 6816 of file heapam.c.

References GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED, HEAP_MOVED, HEAP_XMAX_IS_LOCKED_ONLY, HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax, HeapTupleHeaderGetXmin, HeapTupleHeaderGetXvac, i, MultiXactIdIsValid, MultiXactIdPrecedes(), pfree(), HeapTupleHeaderData::t_infomask, TransactionIdIsNormal, and TransactionIdPrecedes().

Referenced by lazy_check_needs_freeze().

 {
     TransactionId xid;
 
     xid = HeapTupleHeaderGetXmin(tuple);
     if (TransactionIdIsNormal(xid) &&
         TransactionIdPrecedes(xid, cutoff_xid))


Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ HEAP_INSERT_FROZEN

◆ HEAP_INSERT_NO_LOGICAL

◆ HEAP_INSERT_SKIP_FSM

◆ HEAP_INSERT_SKIP_WAL

◆ HEAP_INSERT_SPECULATIVE

◆ HeapScanIsValid

◆ MaxLockTupleMode

Typedef Documentation

◆ BulkInsertState

◆ HeapScanDesc

◆ HeapScanDescData

◆ IndexFetchHeapData

Enumeration Type Documentation

◆ HTSV_Result

Function Documentation

◆ FreeBulkInsertState()

◆ GetBulkInsertState()

◆ heap_abort_speculative()

◆ heap_beginscan()

◆ heap_compute_xid_horizon_for_tuples()

◆ heap_delete()

◆ heap_endscan()

◆ heap_fetch()

◆ heap_finish_speculative()

◆ heap_freeze_tuple()

◆ heap_get_latest_tid()

◆ heap_get_root_tuples()

◆ heap_getnext()

◆ heap_getnextslot()

◆ heap_hot_search_buffer()

◆ heap_inplace_update()

◆ heap_insert()

◆ heap_lock_tuple()

◆ heap_multi_insert()

◆ heap_page_prune()

◆ heap_page_prune_execute()

◆ heap_page_prune_opt()

◆ heap_rescan()

◆ heap_setscanlimits()

◆ heap_sync()

◆ heap_tuple_needs_eventual_freeze()

◆ heap_tuple_needs_freeze()