heapam.h File Reference

#include "access/heapam_xlog.h"
#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/dsm.h"
#include "storage/lockdefs.h"
#include "storage/read_stream.h"
#include "storage/shm_toc.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	BitmapHeapScanDescData
struct	IndexFetchHeapData
struct	HeapTupleFreeze
struct	HeapPageFreeze
struct	PruneFreezeResult

Macros
#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	HEAP_PAGE_PRUNE_MARK_UNUSED_NOW   (1 << 0)
#define	HEAP_PAGE_PRUNE_FREEZE   (1 << 1)
#define	MaxLockTupleMode   LockTupleExclusive
#define	HEAP_FREEZE_CHECK_XMIN_COMMITTED   0x01
#define	HEAP_FREEZE_CHECK_XMAX_ABORTED   0x02
#define	HeapScanIsValid(scan)   PointerIsValid(scan)

Typedefs
typedef struct BulkInsertStateData *	BulkInsertState
typedef struct HeapScanDescData	HeapScanDescData
typedef struct HeapScanDescData *	HeapScanDesc
typedef struct BitmapHeapScanDescData	BitmapHeapScanDescData
typedef struct BitmapHeapScanDescData *	BitmapHeapScanDesc
typedef struct IndexFetchHeapData	IndexFetchHeapData
typedef struct HeapTupleFreeze	HeapTupleFreeze
typedef struct HeapPageFreeze	HeapPageFreeze
typedef struct PruneFreezeResult	PruneFreezeResult

Enumerations
enum	HTSV_Result {   HEAPTUPLE_DEAD , HEAPTUPLE_LIVE , HEAPTUPLE_RECENTLY_DEAD , HEAPTUPLE_INSERT_IN_PROGRESS ,   HEAPTUPLE_DELETE_IN_PROGRESS }
enum	PruneReason { PRUNE_ON_ACCESS , PRUNE_VACUUM_SCAN , PRUNE_VACUUM_CLEANUP }

Functions
TableScanDesc	heap_beginscan (Relation relation, Snapshot snapshot, int nkeys, ScanKey key, ParallelTableScanDesc parallel_scan, uint32 flags)
void	heap_setscanlimits (TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
void	heap_prepare_pagescan (TableScanDesc sscan)
void	heap_rescan (TableScanDesc sscan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
void	heap_endscan (TableScanDesc sscan)
HeapTuple	heap_getnext (TableScanDesc sscan, ScanDirection direction)
bool	heap_getnextslot (TableScanDesc sscan, ScanDirection direction, struct TupleTableSlot *slot)
void	heap_set_tidrange (TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
bool	heap_getnextslot_tidrange (TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
bool	heap_fetch (Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
bool	heap_hot_search_buffer (ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
void	heap_get_latest_tid (TableScanDesc sscan, ItemPointer tid)
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, TU_UpdateIndexes *update_indexes)
TM_Result	heap_lock_tuple (Relation relation, HeapTuple tuple, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, bool follow_updates, Buffer *buffer, struct TM_FailureData *tmfd)
bool	heap_inplace_lock (Relation relation, HeapTuple oldtup_ptr, Buffer buffer, void(*release_callback)(void *), void *arg)
void	heap_inplace_update_and_unlock (Relation relation, HeapTuple oldtup, HeapTuple tuple, Buffer buffer)
void	heap_inplace_unlock (Relation relation, HeapTuple oldtup, Buffer buffer)
bool	heap_prepare_freeze_tuple (HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
void	heap_pre_freeze_checks (Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
void	heap_freeze_prepared_tuples (Buffer buffer, HeapTupleFreeze *tuples, int ntuples)
bool	heap_freeze_tuple (HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId FreezeLimit, TransactionId MultiXactCutoff)
bool	heap_tuple_should_freeze (HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
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, TU_UpdateIndexes *update_indexes)
TransactionId	heap_index_delete_tuples (Relation rel, TM_IndexDeleteOp *delstate)
void	heap_page_prune_opt (Relation relation, Buffer buffer)
void	heap_page_prune_and_freeze (Relation relation, Buffer buffer, struct GlobalVisState *vistest, int options, struct VacuumCutoffs *cutoffs, PruneFreezeResult *presult, PruneReason reason, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid)
void	heap_page_prune_execute (Buffer buffer, bool lp_truncate_only, OffsetNumber *redirected, int nredirected, OffsetNumber *nowdead, int ndead, OffsetNumber *nowunused, int nunused)
void	heap_get_root_tuples (Page page, OffsetNumber *root_offsets)
void	log_heap_prune_and_freeze (Relation relation, Buffer buffer, TransactionId conflict_xid, bool cleanup_lock, PruneReason reason, HeapTupleFreeze *frozen, int nfrozen, OffsetNumber *redirected, int nredirected, OffsetNumber *dead, int ndead, OffsetNumber *unused, int nunused)
void	heap_vacuum_rel (Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy)
bool	HeapTupleSatisfiesVisibility (HeapTuple htup, Snapshot snapshot, Buffer buffer)
TM_Result	HeapTupleSatisfiesUpdate (HeapTuple htup, CommandId curcid, Buffer buffer)
HTSV_Result	HeapTupleSatisfiesVacuum (HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
HTSV_Result	HeapTupleSatisfiesVacuumHorizon (HeapTuple htup, Buffer buffer, TransactionId *dead_after)
void	HeapTupleSetHintBits (HeapTupleHeader tuple, Buffer buffer, uint16 infomask, TransactionId xid)
bool	HeapTupleHeaderIsOnlyLocked (HeapTupleHeader tuple)
bool	HeapTupleIsSurelyDead (HeapTuple htup, struct GlobalVisState *vistest)
bool	ResolveCminCmaxDuringDecoding (struct HTAB *tuplecid_data, Snapshot snapshot, HeapTuple htup, Buffer buffer, CommandId *cmin, CommandId *cmax)
void	HeapCheckForSerializableConflictOut (bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
static void	heap_execute_freeze_tuple (HeapTupleHeader tuple, HeapTupleFreeze *frz)

Macro Definition Documentation

HEAP_FREEZE_CHECK_XMAX_ABORTED

#define HEAP_FREEZE_CHECK_XMAX_ABORTED   0x02

Definition at line 136 of file heapam.h.

HEAP_FREEZE_CHECK_XMIN_COMMITTED

#define HEAP_FREEZE_CHECK_XMIN_COMMITTED   0x01

Definition at line 135 of file heapam.h.

HEAP_INSERT_FROZEN

#define HEAP_INSERT_FROZEN   TABLE_INSERT_FROZEN

Definition at line 37 of file heapam.h.

HEAP_INSERT_NO_LOGICAL

#define HEAP_INSERT_NO_LOGICAL   TABLE_INSERT_NO_LOGICAL

Definition at line 38 of file heapam.h.

HEAP_INSERT_SKIP_FSM

#define HEAP_INSERT_SKIP_FSM   TABLE_INSERT_SKIP_FSM

Definition at line 36 of file heapam.h.

HEAP_INSERT_SPECULATIVE

#define HEAP_INSERT_SPECULATIVE   0x0010

Definition at line 39 of file heapam.h.

HEAP_PAGE_PRUNE_FREEZE

#define HEAP_PAGE_PRUNE_FREEZE   (1 << 1)

Definition at line 43 of file heapam.h.

HEAP_PAGE_PRUNE_MARK_UNUSED_NOW

#define HEAP_PAGE_PRUNE_MARK_UNUSED_NOW   (1 << 0)

Definition at line 42 of file heapam.h.

HeapScanIsValid

#define HeapScanIsValid

(

scan

)

PointerIsValid(scan)

Definition at line 286 of file heapam.h.

MaxLockTupleMode

#define MaxLockTupleMode   LockTupleExclusive

Definition at line 49 of file heapam.h.

Typedef Documentation

BitmapHeapScanDesc

typedef struct BitmapHeapScanDescData* BitmapHeapScanDesc

Definition at line 108 of file heapam.h.

BitmapHeapScanDescData

typedef struct BitmapHeapScanDescData BitmapHeapScanDescData

BulkInsertState

typedef struct BulkInsertStateData* BulkInsertState

Definition at line 45 of file heapam.h.

HeapPageFreeze

typedef struct HeapPageFreeze HeapPageFreeze

HeapScanDesc

typedef struct HeapScanDescData* HeapScanDesc

Definition at line 100 of file heapam.h.

HeapScanDescData

typedef struct HeapScanDescData HeapScanDescData

HeapTupleFreeze

typedef struct HeapTupleFreeze HeapTupleFreeze

IndexFetchHeapData

typedef struct IndexFetchHeapData IndexFetchHeapData

PruneFreezeResult

typedef struct PruneFreezeResult PruneFreezeResult

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 122 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;

PruneReason

enum PruneReason

Enumerator
PRUNE_ON_ACCESS
PRUNE_VACUUM_SCAN
PRUNE_VACUUM_CLEANUP

Definition at line 266 of file heapam.h.

{
    PRUNE_ON_ACCESS,            /* on-access pruning */
    PRUNE_VACUUM_SCAN,          /* VACUUM 1st heap pass */
    PRUNE_VACUUM_CLEANUP,       /* VACUUM 2nd heap pass */
} PruneReason;

Function Documentation

FreeBulkInsertState()

void FreeBulkInsertState

(

BulkInsertState

bistate

)

Definition at line 2006 of file heapam.c.

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

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

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

GetBulkInsertState()

BulkInsertState GetBulkInsertState

(

void

)

Definition at line 1989 of file heapam.c.

{
    BulkInsertState bistate;
 
    bistate = (BulkInsertState) palloc(sizeof(BulkInsertStateData));
    bistate->strategy = GetAccessStrategy(BAS_BULKWRITE);
    bistate->current_buf = InvalidBuffer;
    bistate->next_free = InvalidBlockNumber;
    bistate->last_free = InvalidBlockNumber;
    bistate->already_extended_by = 0;
    return bistate;
}

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

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

heap_abort_speculative()

void heap_abort_speculative	(	Relation	relation,
		ItemPointer	tid
	)

Definition at line 6139 of file heapam.c.

{
    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 combo CID, 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 is a
     * candidate for pruning by setting xmin to TransactionXmin. While not
     * immediately prunable, it is the oldest xid we can cheaply determine
     * that's safe against wraparound / being older than the table's
     * relfrozenxid.  To defend against the unlikely case of a new relation
     * having a newer relfrozenxid than our TransactionXmin, use relfrozenxid
     * if so (vacuum can't subsequently move relfrozenxid to beyond
     * TransactionXmin, so there's no race here).
     */
    Assert(TransactionIdIsValid(TransactionXmin));
    {
        TransactionId relfrozenxid = relation->rd_rel->relfrozenxid;
        TransactionId prune_xid;
 
        if (TransactionIdPrecedes(TransactionXmin, relfrozenxid))
            prune_xid = relfrozenxid;
        else
            prune_xid = TransactionXmin;
        PageSetPrunable(page, prune_xid);
    }
 
    /* 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(&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);
}

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

Referenced by heapam_tuple_complete_speculative(), and toast_delete_datum().

heap_beginscan()

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

Definition at line 1079 of file heapam.c.

{
    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
     */
    if (flags & SO_TYPE_BITMAPSCAN)
    {
        BitmapHeapScanDesc bscan = palloc(sizeof(BitmapHeapScanDescData));
 
        /*
         * Bitmap Heap scans do not have any fields that a normal Heap Scan
         * does not have, so no special initializations required here.
         */
        scan = (HeapScanDesc) bscan;
    }
    else
        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 */
    scan->rs_cbuf = InvalidBuffer;
 
    /*
     * 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);
 
    /*
     * Allocate memory to keep track of page allocation for parallel workers
     * when doing a parallel scan.
     */
    if (parallel_scan != NULL)
        scan->rs_parallelworkerdata = palloc(sizeof(ParallelBlockTableScanWorkerData));
    else
        scan->rs_parallelworkerdata = NULL;
 
    /*
     * 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);
 
    scan->rs_read_stream = NULL;
 
    /*
     * Set up a read stream for sequential scans and TID range scans. This
     * should be done after initscan() because initscan() allocates the
     * BufferAccessStrategy object passed to the read stream API.
     */
    if (scan->rs_base.rs_flags & SO_TYPE_SEQSCAN ||
        scan->rs_base.rs_flags & SO_TYPE_TIDRANGESCAN)
    {
        ReadStreamBlockNumberCB cb;
 
        if (scan->rs_base.rs_parallel)
            cb = heap_scan_stream_read_next_parallel;
        else
            cb = heap_scan_stream_read_next_serial;
 
        /* ---
         * It is safe to use batchmode as the only locks taken by `cb`
         * are never taken while waiting for IO:
         * - SyncScanLock is used in the non-parallel case
         * - in the parallel case, only spinlocks and atomics are used
         * ---
         */
        scan->rs_read_stream = read_stream_begin_relation(READ_STREAM_SEQUENTIAL |
                                                          READ_STREAM_USE_BATCHING,
                                                          scan->rs_strategy,
                                                          scan->rs_base.rs_rd,
                                                          MAIN_FORKNUM,
                                                          cb,
                                                          scan,
                                                          0);
    }
    else if (scan->rs_base.rs_flags & SO_TYPE_BITMAPSCAN)
    {
        scan->rs_read_stream = read_stream_begin_relation(READ_STREAM_DEFAULT |
                                                          READ_STREAM_USE_BATCHING,
                                                          scan->rs_strategy,
                                                          scan->rs_base.rs_rd,
                                                          MAIN_FORKNUM,
                                                          bitmapheap_stream_read_next,
                                                          scan,
                                                          sizeof(TBMIterateResult));
    }
 
 
    return (TableScanDesc) scan;
}

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

heap_delete()

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

Definition at line 2745 of file heapam.c.

{
    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 combo CID.
     * Other workers might need that combo CID 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);
 
    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:
 
    /*
     * 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);
    }
 
    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.
                 *
                 * We also must start over if we didn't pin the VM page, and
                 * the page has become all visible.
                 */
                if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
                    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.
             *
             * We also must start over if we didn't pin the VM page, and the
             * page has become all visible.
             */
            if ((vmbuffer == InvalidBuffer && PageIsAllVisible(page)) ||
                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))
            result = TM_Updated;
        else
            result = TM_Deleted;
    }
 
    /* sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
    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));
    }
 
    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)
    {
        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, tid, BufferGetBlockNumber(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 combo CIDs 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(&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(&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;
}

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_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHasExternal(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderClearHotUpdated(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetCmax(), HeapTupleHeaderSetMovedPartitions(), HeapTupleHeaderSetXmax(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVisibility(), xl_heap_delete::infobits_set, InvalidBuffer, InvalidCommandId, InvalidSnapshot, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockWaitBlock, log_heap_new_cid(), MarkBufferDirty(), MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusUpdate, xl_heap_delete::offnum, PageClearAllVisible(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapDelete, SizeOfHeapHeader, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, xl_heap_header::t_hoff, HeapTupleHeaderData::t_hoff, xl_heap_header::t_infomask, HeapTupleHeaderData::t_infomask, xl_heap_header::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), UnlockReleaseBuffer(), UnlockTupleTuplock, UpdateXmaxHintBits(), visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XactLockTableWait(), XLH_DELETE_ALL_VISIBLE_CLEARED, XLH_DELETE_CONTAINS_OLD_KEY, XLH_DELETE_CONTAINS_OLD_TUPLE, XLH_DELETE_IS_PARTITION_MOVE, XLOG_HEAP_DELETE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLogSetRecordFlags(), XLTW_Delete, xl_heap_delete::xmax, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_delete(), and simple_heap_delete().

heap_endscan()

void heap_endscan

(

TableScanDesc

sscan

)

Definition at line 1275 of file heapam.c.

{
    HeapScanDesc scan = (HeapScanDesc) sscan;
 
    /* Note: no locking manipulations needed */
 
    /*
     * unpin scan buffers
     */
    if (BufferIsValid(scan->rs_cbuf))
        ReleaseBuffer(scan->rs_cbuf);
 
    /*
     * Must free the read stream before freeing the BufferAccessStrategy.
     */
    if (scan->rs_read_stream)
        read_stream_end(scan->rs_read_stream);
 
    /*
     * 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_parallelworkerdata != NULL)
        pfree(scan->rs_parallelworkerdata);
 
    if (scan->rs_base.rs_flags & SO_TEMP_SNAPSHOT)
        UnregisterSnapshot(scan->rs_base.rs_snapshot);
 
    pfree(scan);
}

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

heap_execute_freeze_tuple()

static void heap_execute_freeze_tuple ( HeapTupleHeader  tuple, HeapTupleFreeze *  frz  )

inlinestatic

Definition at line 441 of file heapam.h.

{
    HeapTupleHeaderSetXmax(tuple, frz->xmax);
 
    if (frz->frzflags & XLH_FREEZE_XVAC)
        HeapTupleHeaderSetXvac(tuple, FrozenTransactionId);
 
    if (frz->frzflags & XLH_INVALID_XVAC)
        HeapTupleHeaderSetXvac(tuple, InvalidTransactionId);
 
    tuple->t_infomask = frz->t_infomask;
    tuple->t_infomask2 = frz->t_infomask2;
}

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

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

heap_fetch()

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

Definition at line 1573 of file heapam.c.

{
    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);
 
    /*
     * 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)
        PredicateLockTID(relation, &(tuple->t_self), snapshot,
                         HeapTupleHeaderGetXmin(tuple->t_data));
 
    HeapCheckForSerializableConflictOut(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, but maybe caller wants to see it anyway. */
    if (keep_buf)
        *userbuf = buffer;
    else
    {
        ReleaseBuffer(buffer);
        *userbuf = InvalidBuffer;
        tuple->t_data = NULL;
    }
 
    return false;
}

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

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

heap_finish_speculative()

void heap_finish_speculative	(	Relation	relation,
		ItemPointer	tid
	)

Definition at line 6052 of file heapam.c.

{
    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);
 
    /* 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(&xlrec, SizeOfHeapConfirm);
        XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
        recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_CONFIRM);
 
        PageSetLSN(page, recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(buffer);
}

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

Referenced by heapam_tuple_complete_speculative().

heap_freeze_prepared_tuples()

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

Definition at line 7344 of file heapam.c.

{
    Page        page = BufferGetPage(buffer);
 
    for (int i = 0; i < ntuples; i++)
    {
        HeapTupleFreeze *frz = tuples + i;
        ItemId      itemid = PageGetItemId(page, frz->offset);
        HeapTupleHeader htup;
 
        htup = (HeapTupleHeader) PageGetItem(page, itemid);
        heap_execute_freeze_tuple(htup, frz);
    }
}

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

Referenced by heap_page_prune_and_freeze().

heap_freeze_tuple()

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

Definition at line 7366 of file heapam.c.

{
    HeapTupleFreeze frz;
    bool        do_freeze;
    bool        totally_frozen;
    struct VacuumCutoffs cutoffs;
    HeapPageFreeze pagefrz;
 
    cutoffs.relfrozenxid = relfrozenxid;
    cutoffs.relminmxid = relminmxid;
    cutoffs.OldestXmin = FreezeLimit;
    cutoffs.OldestMxact = MultiXactCutoff;
    cutoffs.FreezeLimit = FreezeLimit;
    cutoffs.MultiXactCutoff = MultiXactCutoff;
 
    pagefrz.freeze_required = true;
    pagefrz.FreezePageRelfrozenXid = FreezeLimit;
    pagefrz.FreezePageRelminMxid = MultiXactCutoff;
    pagefrz.NoFreezePageRelfrozenXid = FreezeLimit;
    pagefrz.NoFreezePageRelminMxid = MultiXactCutoff;
 
    do_freeze = heap_prepare_freeze_tuple(tuple, &cutoffs,
                                          &pagefrz, &frz, &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;
}

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

Referenced by rewrite_heap_tuple().

heap_get_latest_tid()

void heap_get_latest_tid	(	TableScanDesc	sscan,
		ItemPointer	tid
	)

Definition at line 1845 of file heapam.c.

{
    Relation    relation = sscan->rs_rd;
    Snapshot    snapshot = sscan->rs_snapshot;
    ItemPointerData ctid;
    TransactionId priorXmax;
 
    /*
     * table_tuple_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);
 
        /*
         * 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);
        HeapCheckForSerializableConflictOut(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 */
}

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

heap_get_root_tuples()

void heap_get_root_tuples	(	Page	page,
		OffsetNumber *	root_offsets
	)

Definition at line 1785 of file pruneheap.c.

{
    OffsetNumber offnum,
                maxoff;
 
    MemSet(root_offsets, InvalidOffsetNumber,
           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 (;;)
        {
            /* Sanity check (pure paranoia) */
            if (offnum < FirstOffsetNumber)
                break;
 
            /*
             * An offset past the end of page's line pointer array is possible
             * when the array was truncated
             */
            if (offnum > maxoff)
                break;
 
            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);
        }
    }
}

References Assert(), FirstOffsetNumber, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsHotUpdated(), InvalidOffsetNumber, 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().

heap_getnext()

HeapTuple heap_getnext	(	TableScanDesc	sscan,
		ScanDirection	direction
	)

Definition at line 1314 of file heapam.c.

{
    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")));
 
    /*
     * We don't expect direct calls to heap_getnext with valid CheckXidAlive
     * for catalog or regular tables.  See detailed comments in xact.c where
     * these variables are declared.  Normally we have such a check at tableam
     * level API but this is called from many places so we need to ensure it
     * here.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected heap_getnext call during logical decoding");
 
    /* Note: no locking manipulations needed */
 
    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)
        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.
     */
 
    pgstat_count_heap_getnext(scan->rs_base.rs_rd);
 
    return &scan->rs_ctup;
}

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

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

heap_getnextslot()

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

Definition at line 1363 of file heapam.c.

{
    HeapScanDesc scan = (HeapScanDesc) sscan;
 
    /* Note: no locking manipulations needed */
 
    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)
    {
        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.
     */
 
    pgstat_count_heap_getnext(scan->rs_base.rs_rd);
 
    ExecStoreBufferHeapTuple(&scan->rs_ctup, slot,
                             scan->rs_cbuf);
    return true;
}

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

heap_getnextslot_tidrange()

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

Definition at line 1466 of file heapam.c.

{
    HeapScanDesc scan = (HeapScanDesc) sscan;
    ItemPointer mintid = &sscan->st.tidrange.rs_mintid;
    ItemPointer maxtid = &sscan->st.tidrange.rs_maxtid;
 
    /* Note: no locking manipulations needed */
    for (;;)
    {
        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)
        {
            ExecClearTuple(slot);
            return false;
        }
 
        /*
         * heap_set_tidrange will have used heap_setscanlimits to limit the
         * range of pages we scan to only ones that can contain the TID range
         * we're scanning for.  Here we must filter out any tuples from these
         * pages that are outside of that range.
         */
        if (ItemPointerCompare(&scan->rs_ctup.t_self, mintid) < 0)
        {
            ExecClearTuple(slot);
 
            /*
             * When scanning backwards, the TIDs will be in descending order.
             * Future tuples in this direction will be lower still, so we can
             * just return false to indicate there will be no more tuples.
             */
            if (ScanDirectionIsBackward(direction))
                return false;
 
            continue;
        }
 
        /*
         * Likewise for the final page, we must filter out TIDs greater than
         * maxtid.
         */
        if (ItemPointerCompare(&scan->rs_ctup.t_self, maxtid) > 0)
        {
            ExecClearTuple(slot);
 
            /*
             * When scanning forward, the TIDs will be in ascending order.
             * Future tuples in this direction will be higher still, so we can
             * just return false to indicate there will be no more tuples.
             */
            if (ScanDirectionIsForward(direction))
                return false;
            continue;
        }
 
        break;
    }
 
    /*
     * if we get here it means we have a new current scan tuple, so point to
     * the proper return buffer and return the tuple.
     */
    pgstat_count_heap_getnext(scan->rs_base.rs_rd);
 
    ExecStoreBufferHeapTuple(&scan->rs_ctup, slot, scan->rs_cbuf);
    return true;
}

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

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

{
    Page        page = BufferGetPage(buffer);
    TransactionId prev_xmax = InvalidTransactionId;
    BlockNumber blkno;
    OffsetNumber offnum;
    bool        at_chain_start;
    bool        valid;
    bool        skip;
    GlobalVisState *vistest = NULL;
 
    /* 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;
 
    /* XXX: we should assert that a snapshot is pushed or registered */
    Assert(TransactionIdIsValid(RecentXmin));
    Assert(BufferGetBlockNumber(buffer) == blkno);
 
    /* Scan through possible multiple members of HOT-chain */
    for (;;)
    {
        ItemId      lp;
 
        /* check for bogus TID */
        if (offnum < FirstOffsetNumber || offnum > PageGetMaxOffsetNumber(page))
            break;
 
        lp = PageGetItemId(page, 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(page, 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);
            HeapCheckForSerializableConflictOut(valid, relation, heapTuple,
                                                buffer, snapshot);
 
            if (valid)
            {
                ItemPointerSetOffsetNumber(tid, offnum);
                PredicateLockTID(relation, &heapTuple->t_self, snapshot,
                                 HeapTupleHeaderGetXmin(heapTuple->t_data));
                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)
        {
            if (!vistest)
                vistest = GlobalVisTestFor(relation);
 
            if (!HeapTupleIsSurelyDead(heapTuple, vistest))
                *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;
}

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

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

heap_index_delete_tuples()

TransactionId heap_index_delete_tuples	(	Relation	rel,
		TM_IndexDeleteOp *	delstate
	)

Definition at line 8082 of file heapam.c.

{
    /* Initial assumption is that earlier pruning took care of conflict */
    TransactionId snapshotConflictHorizon = InvalidTransactionId;
    BlockNumber blkno = InvalidBlockNumber;
    Buffer      buf = InvalidBuffer;
    Page        page = NULL;
    OffsetNumber maxoff = InvalidOffsetNumber;
    TransactionId priorXmax;
#ifdef USE_PREFETCH
    IndexDeletePrefetchState prefetch_state;
    int         prefetch_distance;
#endif
    SnapshotData SnapshotNonVacuumable;
    int         finalndeltids = 0,
                nblocksaccessed = 0;
 
    /* State that's only used in bottom-up index deletion case */
    int         nblocksfavorable = 0;
    int         curtargetfreespace = delstate->bottomupfreespace,
                lastfreespace = 0,
                actualfreespace = 0;
    bool        bottomup_final_block = false;
 
    InitNonVacuumableSnapshot(SnapshotNonVacuumable, GlobalVisTestFor(rel));
 
    /* Sort caller's deltids array by TID for further processing */
    index_delete_sort(delstate);
 
    /*
     * Bottom-up case: resort deltids array in an order attuned to where the
     * greatest number of promising TIDs are to be found, and determine how
     * many blocks from the start of sorted array should be considered
     * favorable.  This will also shrink the deltids array in order to
     * eliminate completely unfavorable blocks up front.
     */
    if (delstate->bottomup)
        nblocksfavorable = bottomup_sort_and_shrink(delstate);
 
#ifdef USE_PREFETCH
    /* Initialize prefetch state. */
    prefetch_state.cur_hblkno = InvalidBlockNumber;
    prefetch_state.next_item = 0;
    prefetch_state.ndeltids = delstate->ndeltids;
    prefetch_state.deltids = delstate->deltids;
 
    /*
     * Determine the prefetch distance that we will attempt to maintain.
     *
     * 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))
        prefetch_distance = maintenance_io_concurrency;
    else
        prefetch_distance =
            get_tablespace_maintenance_io_concurrency(rel->rd_rel->reltablespace);
 
    /* Cap initial prefetch distance for bottom-up deletion caller */
    if (delstate->bottomup)
    {
        Assert(nblocksfavorable >= 1);
        Assert(nblocksfavorable <= BOTTOMUP_MAX_NBLOCKS);
        prefetch_distance = Min(prefetch_distance, nblocksfavorable);
    }
 
    /* Start prefetching. */
    index_delete_prefetch_buffer(rel, &prefetch_state, prefetch_distance);
#endif
 
    /* Iterate over deltids, determine which to delete, check their horizon */
    Assert(delstate->ndeltids > 0);
    for (int i = 0; i < delstate->ndeltids; i++)
    {
        TM_IndexDelete *ideltid = &delstate->deltids[i];
        TM_IndexStatus *istatus = delstate->status + ideltid->id;
        ItemPointer htid = &ideltid->tid;
        OffsetNumber offnum;
 
        /*
         * Read buffer, and perform required extra steps each time a new block
         * is encountered.  Avoid refetching if it's the same block as the one
         * from the last htid.
         */
        if (blkno == InvalidBlockNumber ||
            ItemPointerGetBlockNumber(htid) != blkno)
        {
            /*
             * Consider giving up early for bottom-up index deletion caller
             * first. (Only prefetch next-next block afterwards, when it
             * becomes clear that we're at least going to access the next
             * block in line.)
             *
             * Sometimes the first block frees so much space for bottom-up
             * caller that the deletion process can end without accessing any
             * more blocks.  It is usually necessary to access 2 or 3 blocks
             * per bottom-up deletion operation, though.
             */
            if (delstate->bottomup)
            {
                /*
                 * We often allow caller to delete a few additional items
                 * whose entries we reached after the point that space target
                 * from caller was satisfied.  The cost of accessing the page
                 * was already paid at that point, so it made sense to finish
                 * it off.  When that happened, we finalize everything here
                 * (by finishing off the whole bottom-up deletion operation
                 * without needlessly paying the cost of accessing any more
                 * blocks).
                 */
                if (bottomup_final_block)
                    break;
 
                /*
                 * Give up when we didn't enable our caller to free any
                 * additional space as a result of processing the page that we
                 * just finished up with.  This rule is the main way in which
                 * we keep the cost of bottom-up deletion under control.
                 */
                if (nblocksaccessed >= 1 && actualfreespace == lastfreespace)
                    break;
                lastfreespace = actualfreespace;    /* for next time */
 
                /*
                 * Deletion operation (which is bottom-up) will definitely
                 * access the next block in line.  Prepare for that now.
                 *
                 * Decay target free space so that we don't hang on for too
                 * long with a marginal case. (Space target is only truly
                 * helpful when it allows us to recognize that we don't need
                 * to access more than 1 or 2 blocks to satisfy caller due to
                 * agreeable workload characteristics.)
                 *
                 * We are a bit more patient when we encounter contiguous
                 * blocks, though: these are treated as favorable blocks.  The
                 * decay process is only applied when the next block in line
                 * is not a favorable/contiguous block.  This is not an
                 * exception to the general rule; we still insist on finding
                 * at least one deletable item per block accessed.  See
                 * bottomup_nblocksfavorable() for full details of the theory
                 * behind favorable blocks and heap block locality in general.
                 *
                 * Note: The first block in line is always treated as a
                 * favorable block, so the earliest possible point that the
                 * decay can be applied is just before we access the second
                 * block in line.  The Assert() verifies this for us.
                 */
                Assert(nblocksaccessed > 0 || nblocksfavorable > 0);
                if (nblocksfavorable > 0)
                    nblocksfavorable--;
                else
                    curtargetfreespace /= 2;
            }
 
            /* release old buffer */
            if (BufferIsValid(buf))
                UnlockReleaseBuffer(buf);
 
            blkno = ItemPointerGetBlockNumber(htid);
            buf = ReadBuffer(rel, blkno);
            nblocksaccessed++;
            Assert(!delstate->bottomup ||
                   nblocksaccessed <= BOTTOMUP_MAX_NBLOCKS);
 
#ifdef USE_PREFETCH
 
            /*
             * To maintain the prefetch distance, prefetch one more page for
             * each page we read.
             */
            index_delete_prefetch_buffer(rel, &prefetch_state, 1);
#endif
 
            LockBuffer(buf, BUFFER_LOCK_SHARE);
 
            page = BufferGetPage(buf);
            maxoff = PageGetMaxOffsetNumber(page);
        }
 
        /*
         * In passing, detect index corruption involving an index page with a
         * TID that points to a location in the heap that couldn't possibly be
         * correct.  We only do this with actual TIDs from caller's index page
         * (not items reached by traversing through a HOT chain).
         */
        index_delete_check_htid(delstate, page, maxoff, htid, istatus);
 
        if (istatus->knowndeletable)
            Assert(!delstate->bottomup && !istatus->promising);
        else
        {
            ItemPointerData tmp = *htid;
            HeapTupleData heapTuple;
 
            /* Are any tuples from this HOT chain non-vacuumable? */
            if (heap_hot_search_buffer(&tmp, rel, buf, &SnapshotNonVacuumable,
                                       &heapTuple, NULL, true))
                continue;       /* can't delete entry */
 
            /* Caller will delete, since whole HOT chain is vacuumable */
            istatus->knowndeletable = true;
 
            /* Maintain index free space info for bottom-up deletion case */
            if (delstate->bottomup)
            {
                Assert(istatus->freespace > 0);
                actualfreespace += istatus->freespace;
                if (actualfreespace >= curtargetfreespace)
                    bottomup_final_block = true;
            }
        }
 
        /*
         * Maintain snapshotConflictHorizon value for deletion operation as a
         * whole by advancing current value using heap tuple headers.  This is
         * loosely based on the logic for pruning a HOT chain.
         */
        offnum = ItemPointerGetOffsetNumber(htid);
        priorXmax = InvalidTransactionId;   /* cannot check first XMIN */
        for (;;)
        {
            ItemId      lp;
            HeapTupleHeader htup;
 
            /* Sanity check (pure paranoia) */
            if (offnum < FirstOffsetNumber)
                break;
 
            /*
             * An offset past the end of page's line pointer array is possible
             * when the array was truncated
             */
            if (offnum > maxoff)
                break;
 
            lp = PageGetItemId(page, offnum);
            if (ItemIdIsRedirected(lp))
            {
                offnum = ItemIdGetRedirect(lp);
                continue;
            }
 
            /*
             * We'll often encounter LP_DEAD line pointers (especially with an
             * entry marked knowndeletable by our caller up front).  No heap
             * tuple headers get examined for an htid that leads us to an
             * LP_DEAD item.  This is okay because the earlier pruning
             * operation that made the line pointer LP_DEAD in the first place
             * must have considered the original tuple header as part of
             * generating its own snapshotConflictHorizon value.
             *
             * Relying on XLOG_HEAP2_PRUNE_VACUUM_SCAN records like this is
             * the same strategy that index vacuuming uses in all cases. Index
             * VACUUM WAL records don't even have a snapshotConflictHorizon
             * field of their own for this reason.
             */
            if (!ItemIdIsNormal(lp))
                break;
 
            htup = (HeapTupleHeader) PageGetItem(page, lp);
 
            /*
             * Check the tuple XMIN against prior XMAX, if any
             */
            if (TransactionIdIsValid(priorXmax) &&
                !TransactionIdEquals(HeapTupleHeaderGetXmin(htup), priorXmax))
                break;
 
            HeapTupleHeaderAdvanceConflictHorizon(htup,
                                                  &snapshotConflictHorizon);
 
            /*
             * If the tuple is not HOT-updated, then we are at the end of this
             * HOT-chain.  No need to visit later tuples from the same update
             * chain (they get their own index entries) -- just move on to
             * next htid from index AM caller.
             */
            if (!HeapTupleHeaderIsHotUpdated(htup))
                break;
 
            /* Advance to next HOT chain member */
            Assert(ItemPointerGetBlockNumber(&htup->t_ctid) == blkno);
            offnum = ItemPointerGetOffsetNumber(&htup->t_ctid);
            priorXmax = HeapTupleHeaderGetUpdateXid(htup);
        }
 
        /* Enable further/final shrinking of deltids for caller */
        finalndeltids = i + 1;
    }
 
    UnlockReleaseBuffer(buf);
 
    /*
     * Shrink deltids array to exclude non-deletable entries at the end.  This
     * is not just a minor optimization.  Final deltids array size might be
     * zero for a bottom-up caller.  Index AM is explicitly allowed to rely on
     * ndeltids being zero in all cases with zero total deletable entries.
     */
    Assert(finalndeltids > 0 || delstate->bottomup);
    delstate->ndeltids = finalndeltids;
 
    return snapshotConflictHorizon;
}

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

heap_inplace_lock()

bool heap_inplace_lock	(	Relation	relation,
		HeapTuple	oldtup_ptr,
		Buffer	buffer,
		void(*)(void *)	release_callback,
		void *	arg
	)

Definition at line 6318 of file heapam.c.

{
    HeapTupleData oldtup = *oldtup_ptr; /* minimize diff vs. heap_update() */
    TM_Result   result;
    bool        ret;
 
#ifdef USE_ASSERT_CHECKING
    if (RelationGetRelid(relation) == RelationRelationId)
        check_inplace_rel_lock(oldtup_ptr);
#endif
 
    Assert(BufferIsValid(buffer));
 
    /*
     * Construct shared cache inval if necessary.  Because we pass a tuple
     * version without our own inplace changes or inplace changes other
     * sessions complete while we wait for locks, inplace update mustn't
     * change catcache lookup keys.  But we aren't bothering with index
     * updates either, so that's true a fortiori.  After LockBuffer(), it
     * would be too late, because this might reach a
     * CatalogCacheInitializeCache() that locks "buffer".
     */
    CacheInvalidateHeapTupleInplace(relation, oldtup_ptr, NULL);
 
    LockTuple(relation, &oldtup.t_self, InplaceUpdateTupleLock);
    LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
    /*----------
     * Interpret HeapTupleSatisfiesUpdate() like heap_update() does, except:
     *
     * - wait unconditionally
     * - already locked tuple above, since inplace needs that unconditionally
     * - don't recheck header after wait: simpler to defer to next iteration
     * - don't try to continue even if the updater aborts: likewise
     * - no crosscheck
     */
    result = HeapTupleSatisfiesUpdate(&oldtup, GetCurrentCommandId(false),
                                      buffer);
 
    if (result == TM_Invisible)
    {
        /* no known way this can happen */
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg_internal("attempted to overwrite invisible tuple")));
    }
    else if (result == TM_SelfModified)
    {
        /*
         * CREATE INDEX might reach this if an expression is silly enough to
         * call e.g. SELECT ... FROM pg_class FOR SHARE.  C code of other SQL
         * statements might get here after a heap_update() of the same row, in
         * the absence of an intervening CommandCounterIncrement().
         */
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("tuple to be updated was already modified by an operation triggered by the current command")));
    }
    else if (result == TM_BeingModified)
    {
        TransactionId xwait;
        uint16      infomask;
 
        xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
        infomask = oldtup.t_data->t_infomask;
 
        if (infomask & HEAP_XMAX_IS_MULTI)
        {
            LockTupleMode lockmode = LockTupleNoKeyExclusive;
            MultiXactStatus mxact_status = MultiXactStatusNoKeyUpdate;
            int         remain;
 
            if (DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
                                        lockmode, NULL))
            {
                LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
                release_callback(arg);
                ret = false;
                MultiXactIdWait((MultiXactId) xwait, mxact_status, infomask,
                                relation, &oldtup.t_self, XLTW_Update,
                                &remain);
            }
            else
                ret = true;
        }
        else if (TransactionIdIsCurrentTransactionId(xwait))
            ret = true;
        else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask))
            ret = true;
        else
        {
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            release_callback(arg);
            ret = false;
            XactLockTableWait(xwait, relation, &oldtup.t_self,
                              XLTW_Update);
        }
    }
    else
    {
        ret = (result == TM_Ok);
        if (!ret)
        {
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            release_callback(arg);
        }
    }
 
    /*
     * GetCatalogSnapshot() relies on invalidation messages to know when to
     * take a new snapshot.  COMMIT of xwait is responsible for sending the
     * invalidation.  We're not acquiring heavyweight locks sufficient to
     * block if not yet sent, so we must take a new snapshot to ensure a later
     * attempt has a fair chance.  While we don't need this if xwait aborted,
     * don't bother optimizing that.
     */
    if (!ret)
    {
        UnlockTuple(relation, &oldtup.t_self, InplaceUpdateTupleLock);
        ForgetInplace_Inval();
        InvalidateCatalogSnapshot();
    }
    return ret;
}

References arg, Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferIsValid(), CacheInvalidateHeapTupleInplace(), DoesMultiXactIdConflict(), ereport, errcode(), errmsg(), errmsg_internal(), ERROR, ForgetInplace_Inval(), GetCurrentCommandId(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleSatisfiesUpdate(), InplaceUpdateTupleLock, InvalidateCatalogSnapshot(), LockBuffer(), LockTuple(), LockTupleNoKeyExclusive, MultiXactIdWait(), MultiXactStatusNoKeyUpdate, RelationGetRelid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, TM_BeingModified, TM_Invisible, TM_Ok, TM_SelfModified, TransactionIdIsCurrentTransactionId(), UnlockTuple(), XactLockTableWait(), and XLTW_Update.

Referenced by systable_inplace_update_begin().

heap_inplace_unlock()

void heap_inplace_unlock	(	Relation	relation,
		HeapTuple	oldtup,
		Buffer	buffer
	)

Definition at line 6607 of file heapam.c.

{
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
    UnlockTuple(relation, &oldtup->t_self, InplaceUpdateTupleLock);
    ForgetInplace_Inval();
}

References BUFFER_LOCK_UNLOCK, ForgetInplace_Inval(), InplaceUpdateTupleLock, LockBuffer(), HeapTupleData::t_self, and UnlockTuple().

Referenced by systable_inplace_update_cancel().

heap_inplace_update_and_unlock()

void heap_inplace_update_and_unlock	(	Relation	relation,
		HeapTuple	oldtup,
		HeapTuple	tuple,
		Buffer	buffer
	)

Definition at line 6454 of file heapam.c.

{
    HeapTupleHeader htup = oldtup->t_data;
    uint32      oldlen;
    uint32      newlen;
    char       *dst;
    char       *src;
    int         nmsgs = 0;
    SharedInvalidationMessage *invalMessages = NULL;
    bool        RelcacheInitFileInval = false;
 
    Assert(ItemPointerEquals(&oldtup->t_self, &tuple->t_self));
    oldlen = oldtup->t_len - 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");
 
    dst = (char *) htup + htup->t_hoff;
    src = (char *) tuple->t_data + tuple->t_data->t_hoff;
 
    /* Like RecordTransactionCommit(), log only if needed */
    if (XLogStandbyInfoActive())
        nmsgs = inplaceGetInvalidationMessages(&invalMessages,
                                               &RelcacheInitFileInval);
 
    /*
     * Unlink relcache init files as needed.  If unlinking, acquire
     * RelCacheInitLock until after associated invalidations.  By doing this
     * in advance, if we checkpoint and then crash between inplace
     * XLogInsert() and inval, we don't rely on StartupXLOG() ->
     * RelationCacheInitFileRemove().  That uses elevel==LOG, so replay would
     * neglect to PANIC on EIO.
     */
    PreInplace_Inval();
 
    /*----------
     * NO EREPORT(ERROR) from here till changes are complete
     *
     * Our buffer lock won't stop a reader having already pinned and checked
     * visibility for this tuple.  Hence, we write WAL first, then mutate the
     * buffer.  Like in MarkBufferDirtyHint() or RecordTransactionCommit(),
     * checkpoint delay makes that acceptable.  With the usual order of
     * changes, a crash after memcpy() and before XLogInsert() could allow
     * datfrozenxid to overtake relfrozenxid:
     *
     * ["D" is a VACUUM (ONLY_DATABASE_STATS)]
     * ["R" is a VACUUM tbl]
     * D: vac_update_datfrozenxid() -> systable_beginscan(pg_class)
     * D: systable_getnext() returns pg_class tuple of tbl
     * R: memcpy() into pg_class tuple of tbl
     * D: raise pg_database.datfrozenxid, XLogInsert(), finish
     * [crash]
     * [recovery restores datfrozenxid w/o relfrozenxid]
     *
     * Mimic MarkBufferDirtyHint() subroutine XLogSaveBufferForHint().
     * Specifically, use DELAY_CHKPT_START, and copy the buffer to the stack.
     * The stack copy facilitates a FPI of the post-mutation block before we
     * accept other sessions seeing it.  DELAY_CHKPT_START allows us to
     * XLogInsert() before MarkBufferDirty().  Since XLogSaveBufferForHint()
     * can operate under BUFFER_LOCK_SHARED, it can't avoid DELAY_CHKPT_START.
     * This function, however, likely could avoid it with the following order
     * of operations: MarkBufferDirty(), XLogInsert(), memcpy().  Opt to use
     * DELAY_CHKPT_START here, too, as a way to have fewer distinct code
     * patterns to analyze.  Inplace update isn't so frequent that it should
     * pursue the small optimization of skipping DELAY_CHKPT_START.
     */
    Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);
    START_CRIT_SECTION();
    MyProc->delayChkptFlags |= DELAY_CHKPT_START;
 
    /* XLOG stuff */
    if (RelationNeedsWAL(relation))
    {
        xl_heap_inplace xlrec;
        PGAlignedBlock copied_buffer;
        char       *origdata = (char *) BufferGetBlock(buffer);
        Page        page = BufferGetPage(buffer);
        uint16      lower = ((PageHeader) page)->pd_lower;
        uint16      upper = ((PageHeader) page)->pd_upper;
        uintptr_t   dst_offset_in_block;
        RelFileLocator rlocator;
        ForkNumber  forkno;
        BlockNumber blkno;
        XLogRecPtr  recptr;
 
        xlrec.offnum = ItemPointerGetOffsetNumber(&tuple->t_self);
        xlrec.dbId = MyDatabaseId;
        xlrec.tsId = MyDatabaseTableSpace;
        xlrec.relcacheInitFileInval = RelcacheInitFileInval;
        xlrec.nmsgs = nmsgs;
 
        XLogBeginInsert();
        XLogRegisterData(&xlrec, MinSizeOfHeapInplace);
        if (nmsgs != 0)
            XLogRegisterData(invalMessages,
                             nmsgs * sizeof(SharedInvalidationMessage));
 
        /* register block matching what buffer will look like after changes */
        memcpy(copied_buffer.data, origdata, lower);
        memcpy(copied_buffer.data + upper, origdata + upper, BLCKSZ - upper);
        dst_offset_in_block = dst - origdata;
        memcpy(copied_buffer.data + dst_offset_in_block, src, newlen);
        BufferGetTag(buffer, &rlocator, &forkno, &blkno);
        Assert(forkno == MAIN_FORKNUM);
        XLogRegisterBlock(0, &rlocator, forkno, blkno, copied_buffer.data,
                          REGBUF_STANDARD);
        XLogRegisterBufData(0, src, newlen);
 
        /* inplace updates aren't decoded atm, don't log the origin */
 
        recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_INPLACE);
 
        PageSetLSN(page, recptr);
    }
 
    memcpy(dst, src, newlen);
 
    MarkBufferDirty(buffer);
 
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
    /*
     * Send invalidations to shared queue.  SearchSysCacheLocked1() assumes we
     * do this before UnlockTuple().
     *
     * If we're mutating a tuple visible only to this transaction, there's an
     * equivalent transactional inval from the action that created the tuple,
     * and this inval is superfluous.
     */
    AtInplace_Inval();
 
    MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
    END_CRIT_SECTION();
    UnlockTuple(relation, &tuple->t_self, InplaceUpdateTupleLock);
 
    AcceptInvalidationMessages();   /* local processing of just-sent inval */
 
    /*
     * Queue a transactional inval.  The immediate invalidation we just sent
     * is the only one known to be necessary.  To reduce risk from the
     * transition to immediate invalidation, continue sending a transactional
     * invalidation like we've long done.  Third-party code might rely on it.
     */
    if (!IsBootstrapProcessingMode())
        CacheInvalidateHeapTuple(relation, tuple, NULL);
}

References AcceptInvalidationMessages(), Assert(), AtInplace_Inval(), BUFFER_LOCK_UNLOCK, BufferGetBlock(), BufferGetPage(), BufferGetTag(), CacheInvalidateHeapTuple(), PGAlignedBlock::data, xl_heap_inplace::dbId, DELAY_CHKPT_START, PGPROC::delayChkptFlags, elog, END_CRIT_SECTION, ERROR, inplaceGetInvalidationMessages(), InplaceUpdateTupleLock, IsBootstrapProcessingMode, ItemPointerEquals(), ItemPointerGetOffsetNumber(), LockBuffer(), lower(), MAIN_FORKNUM, MarkBufferDirty(), MinSizeOfHeapInplace, MyDatabaseId, MyDatabaseTableSpace, MyProc, xl_heap_inplace::nmsgs, xl_heap_inplace::offnum, PageSetLSN(), PreInplace_Inval(), REGBUF_STANDARD, RelationNeedsWAL, xl_heap_inplace::relcacheInitFileInval, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, HeapTupleData::t_len, HeapTupleData::t_self, xl_heap_inplace::tsId, UnlockTuple(), upper(), XLOG_HEAP_INPLACE, XLogBeginInsert(), XLogInsert(), XLogRegisterBlock(), XLogRegisterBufData(), XLogRegisterData(), and XLogStandbyInfoActive.

Referenced by systable_inplace_update_finish().

heap_insert()

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

Definition at line 2056 of file heapam.c.

{
    TransactionId xid = GetCurrentTransactionId();
    HeapTuple   heaptup;
    Buffer      buffer;
    Buffer      vmbuffer = InvalidBuffer;
    bool        all_visible_cleared = false;
 
    /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
    Assert(HeapTupleHeaderGetNatts(tup->t_data) <=
           RelationGetNumberOfAttributes(relation));
 
    /*
     * 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,
                                       0);
 
    /*
     * 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, InvalidBlockNumber);
 
    /* 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 (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 combo CIDs 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;
 
            if (IsToastRelation(relation))
                xlrec.flags |= XLH_INSERT_ON_TOAST_RELATION;
        }
 
        XLogBeginInsert();
        XLogRegisterData(&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, &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);
    }
}

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

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

heap_lock_tuple()

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

Definition at line 4543 of file heapam.c.

{
    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, false))
                        {
                            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, log_lock_failure))
                            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, false))
                        {
                            result = TM_WouldBlock;
                            /* recovery code expects to have buffer lock held */
                            LockBuffer(*buffer, BUFFER_LOCK_EXCLUSIVE);
                            goto failed;
                        }
                        break;
                    case LockWaitError:
                        if (!ConditionalXactLockTableWait(xwait, log_lock_failure))
                            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))
            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);
 
        /*
         * When locking a tuple under LockWaitSkip semantics and we fail with
         * TM_WouldBlock above, it's possible for concurrent transactions to
         * release the lock and set HEAP_XMAX_INVALID in the meantime.  So
         * this assert is slightly different from the equivalent one in
         * heap_delete and heap_update.
         */
        Assert((result == TM_WouldBlock) ||
               !(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.xmax = 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(&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;
}

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_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(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderSetXmax(), HeapTupleSatisfiesUpdate(), i, xl_heap_lock::infobits_set, InvalidBuffer, InvalidCommandId, ItemIdGetLength, ItemIdIsNormal, ItemPointerCopy(), ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, LockWaitBlock, LockWaitError, LockWaitSkip, log_lock_failure, MarkBufferDirty(), mode, MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, xl_heap_lock::offnum, PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), pfree(), ReadBuffer(), REGBUF_STANDARD, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), SizeOfHeapLock, START_CRIT_SECTION, 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, xl_heap_lock::xmax, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_lock().

heap_multi_insert()

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

Definition at line 2325 of file heapam.c.

{
    TransactionId xid = GetCurrentTransactionId();
    HeapTuple  *heaptuples;
    int         i;
    int         ndone;
    PGAlignedBlock scratch;
    Page        page;
    Buffer      vmbuffer = InvalidBuffer;
    bool        needwal;
    Size        saveFreeSpace;
    bool        need_tuple_data = RelationIsLogicallyLogged(relation);
    bool        need_cids = RelationIsAccessibleInLogicalDecoding(relation);
    bool        starting_with_empty_page = false;
    int         npages = 0;
    int         npages_used = 0;
 
    /* currently not needed (thus unsupported) for heap_multi_insert() */
    Assert(!(options & HEAP_INSERT_NO_LOGICAL));
 
    needwal = 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, InvalidBlockNumber);
 
    ndone = 0;
    while (ndone < ntuples)
    {
        Buffer      buffer;
        bool        all_visible_cleared = false;
        bool        all_frozen_set = false;
        int         nthispage;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * Compute number of pages needed to fit the to-be-inserted tuples in
         * the worst case.  This will be used to determine how much to extend
         * the relation by in RelationGetBufferForTuple(), if needed.  If we
         * filled a prior page from scratch, we can just update our last
         * computation, but if we started with a partially filled page,
         * recompute from scratch, the number of potentially required pages
         * can vary due to tuples needing to fit onto the page, page headers
         * etc.
         */
        if (ndone == 0 || !starting_with_empty_page)
        {
            npages = heap_multi_insert_pages(heaptuples, ndone, ntuples,
                                             saveFreeSpace);
            npages_used = 0;
        }
        else
            npages_used++;
 
        /*
         * 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.
         *
         * Also pin visibility map page if COPY FREEZE inserts tuples into an
         * empty page. See all_frozen_set below.
         */
        buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
                                           InvalidBuffer, options, bistate,
                                           &vmbuffer, NULL,
                                           npages - npages_used);
        page = BufferGetPage(buffer);
 
        starting_with_empty_page = PageGetMaxOffsetNumber(page) == 0;
 
        if (starting_with_empty_page && (options & HEAP_INSERT_FROZEN))
            all_frozen_set = true;
 
        /* 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 logical decoding we need combo CIDs to properly decode the
         * catalog.
         */
        if (needwal && need_cids)
            log_heap_new_cid(relation, heaptuples[ndone]);
 
        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);
 
            /*
             * For logical decoding we need combo CIDs to properly decode the
             * catalog.
             */
            if (needwal && need_cids)
                log_heap_new_cid(relation, heaptup);
        }
 
        /*
         * If the page is all visible, need to clear that, unless we're only
         * going to add further frozen rows to it.
         *
         * If we're only adding already frozen rows to a previously empty
         * page, mark it as all-visible.
         */
        if (PageIsAllVisible(page) && !(options & HEAP_INSERT_FROZEN))
        {
            all_visible_cleared = true;
            PageClearAllVisible(page);
            visibilitymap_clear(relation,
                                BufferGetBlockNumber(buffer),
                                vmbuffer, VISIBILITYMAP_VALID_BITS);
        }
        else if (all_frozen_set)
            PageSetAllVisible(page);
 
        /*
         * 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 = starting_with_empty_page;
 
            /* 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;
 
            /* check that the mutually exclusive flags are not both set */
            Assert(!(all_visible_cleared && all_frozen_set));
 
            xlrec->flags = 0;
            if (all_visible_cleared)
                xlrec->flags = XLH_INSERT_ALL_VISIBLE_CLEARED;
            if (all_frozen_set)
                xlrec->flags = XLH_INSERT_ALL_FROZEN_SET;
 
            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(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();
 
        /*
         * If we've frozen everything on the page, update the visibilitymap.
         * We're already holding pin on the vmbuffer.
         */
        if (all_frozen_set)
        {
            Assert(PageIsAllVisible(page));
            Assert(visibilitymap_pin_ok(BufferGetBlockNumber(buffer), vmbuffer));
 
            /*
             * It's fine to use InvalidTransactionId here - this is only used
             * when HEAP_INSERT_FROZEN is specified, which intentionally
             * violates visibility rules.
             */
            visibilitymap_set(relation, BufferGetBlockNumber(buffer), buffer,
                              InvalidXLogRecPtr, vmbuffer,
                              InvalidTransactionId,
                              VISIBILITYMAP_ALL_VISIBLE | VISIBILITYMAP_ALL_FROZEN);
        }
 
        UnlockReleaseBuffer(buffer);
        ndone += nthispage;
 
        /*
         * NB: Only release vmbuffer after inserting all tuples - it's fairly
         * likely that we'll insert into subsequent heap pages that are likely
         * to use the same vm page.
         */
    }
 
    /* We're done with inserting all tuples, so release the last vmbuffer. */
    if (vmbuffer != InvalidBuffer)
        ReleaseBuffer(vmbuffer);
 
    /*
     * 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, InvalidBlockNumber);
 
    /*
     * 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);
}

References Assert(), BufferGetBlockNumber(), BufferGetPage(), CacheInvalidateHeapTuple(), CHECK_FOR_INTERRUPTS, CheckForSerializableConflictIn(), PGAlignedBlock::data, xl_multi_insert_tuple::datalen, END_CRIT_SECTION, ExecFetchSlotHeapTuple(), xl_heap_multi_insert::flags, GetCurrentTransactionId(), HEAP_DEFAULT_FILLFACTOR, HEAP_INSERT_FROZEN, HEAP_INSERT_NO_LOGICAL, heap_multi_insert_pages(), heap_prepare_insert(), i, init, InvalidBlockNumber, InvalidBuffer, InvalidTransactionId, InvalidXLogRecPtr, IsCatalogRelation(), ItemPointerGetOffsetNumber(), log_heap_new_cid(), MarkBufferDirty(), MAXALIGN, xl_heap_multi_insert::ntuples, xl_heap_multi_insert::offsets, PageClearAllVisible(), PageGetHeapFreeSpace(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetAllVisible(), 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, xl_multi_insert_tuple::t_hoff, HeapTupleHeaderData::t_hoff, xl_multi_insert_tuple::t_infomask, HeapTupleHeaderData::t_infomask, xl_multi_insert_tuple::t_infomask2, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleTableSlot::tts_tableOid, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_clear(), visibilitymap_pin_ok(), visibilitymap_set(), VISIBILITYMAP_VALID_BITS, XLH_INSERT_ALL_FROZEN_SET, 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 CatalogTuplesMultiInsertWithInfo().

heap_page_prune_and_freeze()

void heap_page_prune_and_freeze	(	Relation	relation,
		Buffer	buffer,
		struct GlobalVisState *	vistest,
		int	options,
		struct VacuumCutoffs *	cutoffs,
		PruneFreezeResult *	presult,
		PruneReason	reason,
		OffsetNumber *	off_loc,
		TransactionId *	new_relfrozen_xid,
		MultiXactId *	new_relmin_mxid
	)

Definition at line 350 of file pruneheap.c.

{
    Page        page = BufferGetPage(buffer);
    BlockNumber blockno = BufferGetBlockNumber(buffer);
    OffsetNumber offnum,
                maxoff;
    PruneState  prstate;
    HeapTupleData tup;
    bool        do_freeze;
    bool        do_prune;
    bool        do_hint;
    bool        hint_bit_fpi;
    int64       fpi_before = pgWalUsage.wal_fpi;
 
    /* Copy parameters to prstate */
    prstate.vistest = vistest;
    prstate.mark_unused_now = (options & HEAP_PAGE_PRUNE_MARK_UNUSED_NOW) != 0;
    prstate.freeze = (options & HEAP_PAGE_PRUNE_FREEZE) != 0;
    prstate.cutoffs = cutoffs;
 
    /*
     * 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.latest_xid_removed = InvalidTransactionId;
    prstate.nredirected = prstate.ndead = prstate.nunused = prstate.nfrozen = 0;
    prstate.nroot_items = 0;
    prstate.nheaponly_items = 0;
 
    /* initialize page freezing working state */
    prstate.pagefrz.freeze_required = false;
    if (prstate.freeze)
    {
        Assert(new_relfrozen_xid && new_relmin_mxid);
        prstate.pagefrz.FreezePageRelfrozenXid = *new_relfrozen_xid;
        prstate.pagefrz.NoFreezePageRelfrozenXid = *new_relfrozen_xid;
        prstate.pagefrz.FreezePageRelminMxid = *new_relmin_mxid;
        prstate.pagefrz.NoFreezePageRelminMxid = *new_relmin_mxid;
    }
    else
    {
        Assert(new_relfrozen_xid == NULL && new_relmin_mxid == NULL);
        prstate.pagefrz.FreezePageRelminMxid = InvalidMultiXactId;
        prstate.pagefrz.NoFreezePageRelminMxid = InvalidMultiXactId;
        prstate.pagefrz.FreezePageRelfrozenXid = InvalidTransactionId;
        prstate.pagefrz.NoFreezePageRelfrozenXid = InvalidTransactionId;
    }
 
    prstate.ndeleted = 0;
    prstate.live_tuples = 0;
    prstate.recently_dead_tuples = 0;
    prstate.hastup = false;
    prstate.lpdead_items = 0;
    prstate.deadoffsets = presult->deadoffsets;
 
    /*
     * Caller may update the VM after we're done.  We can keep track of
     * whether the page will be all-visible and all-frozen after pruning and
     * freezing to help the caller to do that.
     *
     * Currently, only VACUUM sets the VM bits.  To save the effort, only do
     * the bookkeeping if the caller needs it.  Currently, that's tied to
     * HEAP_PAGE_PRUNE_FREEZE, but it could be a separate flag if you wanted
     * to update the VM bits without also freezing or freeze without also
     * setting the VM bits.
     *
     * In addition to telling the caller whether it can set the VM bit, we
     * also use 'all_visible' and 'all_frozen' for our own decision-making. If
     * the whole page would become frozen, we consider opportunistically
     * freezing tuples.  We will not be able to freeze the whole page if there
     * are tuples present that are not visible to everyone or if there are
     * dead tuples which are not yet removable.  However, dead tuples which
     * will be removed by the end of vacuuming should not preclude us from
     * opportunistically freezing.  Because of that, we do not clear
     * all_visible when we see LP_DEAD items.  We fix that at the end of the
     * function, when we return the value to the caller, so that the caller
     * doesn't set the VM bit incorrectly.
     */
    if (prstate.freeze)
    {
        prstate.all_visible = true;
        prstate.all_frozen = true;
    }
    else
    {
        /*
         * Initializing to false allows skipping the work to update them in
         * heap_prune_record_unchanged_lp_normal().
         */
        prstate.all_visible = false;
        prstate.all_frozen = false;
    }
 
    /*
     * The visibility cutoff xid is the newest xmin of live tuples on the
     * page.  In the common case, this will be set as the conflict horizon the
     * caller can use for updating the VM.  If, at the end of freezing and
     * pruning, the page is all-frozen, there is no possibility that any
     * running transaction on the standby does not see tuples on the page as
     * all-visible, so the conflict horizon remains InvalidTransactionId.
     */
    prstate.visibility_cutoff_xid = InvalidTransactionId;
 
    maxoff = PageGetMaxOffsetNumber(page);
    tup.t_tableOid = RelationGetRelid(relation);
 
    /*
     * Determine HTSV for all tuples, and queue them up for processing as HOT
     * chain roots or as heap-only items.
     *
     * Determining HTSV only once for each tuple is required for correctness,
     * to deal with cases where running HTSV twice could result in different
     * results.  For example, RECENTLY_DEAD can turn to DEAD if another
     * checked item causes GlobalVisTestIsRemovableFullXid() to update the
     * horizon, or INSERT_IN_PROGRESS can change to DEAD if the inserting
     * transaction aborts.
     *
     * It's also good for performance. Most commonly tuples within a page are
     * stored at decreasing offsets (while the items are stored at increasing
     * offsets). When processing all tuples on a page this leads to reading
     * memory at decreasing offsets within a page, with a variable stride.
     * That's hard for CPU prefetchers to deal with. Processing the items in
     * reverse order (and thus the tuples in increasing order) increases
     * prefetching efficiency significantly / decreases the number of cache
     * misses.
     */
    for (offnum = maxoff;
         offnum >= FirstOffsetNumber;
         offnum = OffsetNumberPrev(offnum))
    {
        ItemId      itemid = PageGetItemId(page, offnum);
        HeapTupleHeader htup;
 
        /*
         * Set the offset number so that we can display it along with any
         * error that occurred while processing this tuple.
         */
        *off_loc = offnum;
 
        prstate.processed[offnum] = false;
        prstate.htsv[offnum] = -1;
 
        /* Nothing to do if slot doesn't contain a tuple */
        if (!ItemIdIsUsed(itemid))
        {
            heap_prune_record_unchanged_lp_unused(page, &prstate, offnum);
            continue;
        }
 
        if (ItemIdIsDead(itemid))
        {
            /*
             * If the caller set mark_unused_now true, we can set dead line
             * pointers LP_UNUSED now.
             */
            if (unlikely(prstate.mark_unused_now))
                heap_prune_record_unused(&prstate, offnum, false);
            else
                heap_prune_record_unchanged_lp_dead(page, &prstate, offnum);
            continue;
        }
 
        if (ItemIdIsRedirected(itemid))
        {
            /* This is the start of a HOT chain */
            prstate.root_items[prstate.nroot_items++] = offnum;
            continue;
        }
 
        Assert(ItemIdIsNormal(itemid));
 
        /*
         * Get the tuple's visibility status and queue it up for processing.
         */
        htup = (HeapTupleHeader) PageGetItem(page, itemid);
        tup.t_data = htup;
        tup.t_len = ItemIdGetLength(itemid);
        ItemPointerSet(&tup.t_self, blockno, offnum);
 
        prstate.htsv[offnum] = heap_prune_satisfies_vacuum(&prstate, &tup,
                                                           buffer);
 
        if (!HeapTupleHeaderIsHeapOnly(htup))
            prstate.root_items[prstate.nroot_items++] = offnum;
        else
            prstate.heaponly_items[prstate.nheaponly_items++] = offnum;
    }
 
    /*
     * If checksums are enabled, heap_prune_satisfies_vacuum() may have caused
     * an FPI to be emitted.
     */
    hint_bit_fpi = fpi_before != pgWalUsage.wal_fpi;
 
    /*
     * Process HOT chains.
     *
     * We added the items to the array starting from 'maxoff', so by
     * processing the array in reverse order, we process the items in
     * ascending offset number order.  The order doesn't matter for
     * correctness, but some quick micro-benchmarking suggests that this is
     * faster.  (Earlier PostgreSQL versions, which scanned all the items on
     * the page instead of using the root_items array, also did it in
     * ascending offset number order.)
     */
    for (int i = prstate.nroot_items - 1; i >= 0; i--)
    {
        offnum = prstate.root_items[i];
 
        /* Ignore items already processed as part of an earlier chain */
        if (prstate.processed[offnum])
            continue;
 
        /* see preceding loop */
        *off_loc = offnum;
 
        /* Process this item or chain of items */
        heap_prune_chain(page, blockno, maxoff, offnum, &prstate);
    }
 
    /*
     * Process any heap-only tuples that were not already processed as part of
     * a HOT chain.
     */
    for (int i = prstate.nheaponly_items - 1; i >= 0; i--)
    {
        offnum = prstate.heaponly_items[i];
 
        if (prstate.processed[offnum])
            continue;
 
        /* see preceding loop */
        *off_loc = offnum;
 
        /*
         * If the tuple is DEAD and doesn't chain to anything else, mark it
         * unused.  (If it does chain, we can only remove it as part of
         * pruning its chain.)
         *
         * We need this primarily to handle aborted HOT updates, that is,
         * XMIN_INVALID heap-only tuples.  Those might not be linked to by any
         * chain, since the parent tuple might be re-updated before any
         * pruning occurs.  So we have to be able to reap them separately from
         * chain-pruning.  (Note that HeapTupleHeaderIsHotUpdated will never
         * return true for an XMIN_INVALID tuple, so this code will work even
         * when there were sequential updates within the aborted transaction.)
         */
        if (prstate.htsv[offnum] == HEAPTUPLE_DEAD)
        {
            ItemId      itemid = PageGetItemId(page, offnum);
            HeapTupleHeader htup = (HeapTupleHeader) PageGetItem(page, itemid);
 
            if (likely(!HeapTupleHeaderIsHotUpdated(htup)))
            {
                HeapTupleHeaderAdvanceConflictHorizon(htup,
                                                      &prstate.latest_xid_removed);
                heap_prune_record_unused(&prstate, offnum, true);
            }
            else
            {
                /*
                 * This tuple should've been processed and removed as part of
                 * a HOT chain, so something's wrong.  To preserve evidence,
                 * we don't dare to remove it.  We cannot leave behind a DEAD
                 * tuple either, because that will cause VACUUM to error out.
                 * Throwing an error with a distinct error message seems like
                 * the least bad option.
                 */
                elog(ERROR, "dead heap-only tuple (%u, %d) is not linked to from any HOT chain",
                     blockno, offnum);
            }
        }
        else
            heap_prune_record_unchanged_lp_normal(page, &prstate, offnum);
    }
 
    /* We should now have processed every tuple exactly once  */
#ifdef USE_ASSERT_CHECKING
    for (offnum = FirstOffsetNumber;
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        *off_loc = offnum;
 
        Assert(prstate.processed[offnum]);
    }
#endif
 
    /* Clear the offset information once we have processed the given page. */
    *off_loc = InvalidOffsetNumber;
 
    do_prune = prstate.nredirected > 0 ||
        prstate.ndead > 0 ||
        prstate.nunused > 0;
 
    /*
     * Even if we don't prune anything, if we found a new value for the
     * pd_prune_xid field or the page was marked full, we will update the hint
     * bit.
     */
    do_hint = ((PageHeader) page)->pd_prune_xid != prstate.new_prune_xid ||
        PageIsFull(page);
 
    /*
     * Decide if we want to go ahead with freezing according to the freeze
     * plans we prepared, or not.
     */
    do_freeze = false;
    if (prstate.freeze)
    {
        if (prstate.pagefrz.freeze_required)
        {
            /*
             * heap_prepare_freeze_tuple indicated that at least one XID/MXID
             * from before FreezeLimit/MultiXactCutoff is present.  Must
             * freeze to advance relfrozenxid/relminmxid.
             */
            do_freeze = true;
        }
        else
        {
            /*
             * Opportunistically freeze the page if we are generating an FPI
             * anyway and if doing so means that we can set the page
             * all-frozen afterwards (might not happen until VACUUM's final
             * heap pass).
             *
             * XXX: Previously, we knew if pruning emitted an FPI by checking
             * pgWalUsage.wal_fpi before and after pruning.  Once the freeze
             * and prune records were combined, this heuristic couldn't be
             * used anymore.  The opportunistic freeze heuristic must be
             * improved; however, for now, try to approximate the old logic.
             */
            if (prstate.all_visible && prstate.all_frozen && prstate.nfrozen > 0)
            {
                /*
                 * Freezing would make the page all-frozen.  Have already
                 * emitted an FPI or will do so anyway?
                 */
                if (RelationNeedsWAL(relation))
                {
                    if (hint_bit_fpi)
                        do_freeze = true;
                    else if (do_prune)
                    {
                        if (XLogCheckBufferNeedsBackup(buffer))
                            do_freeze = true;
                    }
                    else if (do_hint)
                    {
                        if (XLogHintBitIsNeeded() && XLogCheckBufferNeedsBackup(buffer))
                            do_freeze = true;
                    }
                }
            }
        }
    }
 
    if (do_freeze)
    {
        /*
         * Validate the tuples we will be freezing before entering the
         * critical section.
         */
        heap_pre_freeze_checks(buffer, prstate.frozen, prstate.nfrozen);
    }
    else if (prstate.nfrozen > 0)
    {
        /*
         * The page contained some tuples that were not already frozen, and we
         * chose not to freeze them now.  The page won't be all-frozen then.
         */
        Assert(!prstate.pagefrz.freeze_required);
 
        prstate.all_frozen = false;
        prstate.nfrozen = 0;    /* avoid miscounts in instrumentation */
    }
    else
    {
        /*
         * We have no freeze plans to execute.  The page might already be
         * all-frozen (perhaps only following pruning), though.  Such pages
         * can be marked all-frozen in the VM by our caller, even though none
         * of its tuples were newly frozen here.
         */
    }
 
    /* Any error while applying the changes is critical */
    START_CRIT_SECTION();
 
    if (do_hint)
    {
        /*
         * 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);
 
        /*
         * If that's all we had to do to the page, this is a non-WAL-logged
         * hint.  If we are going to freeze or prune the page, we will mark
         * the buffer dirty below.
         */
        if (!do_freeze && !do_prune)
            MarkBufferDirtyHint(buffer, true);
    }
 
    if (do_prune || do_freeze)
    {
        /* Apply the planned item changes and repair page fragmentation. */
        if (do_prune)
        {
            heap_page_prune_execute(buffer, false,
                                    prstate.redirected, prstate.nredirected,
                                    prstate.nowdead, prstate.ndead,
                                    prstate.nowunused, prstate.nunused);
        }
 
        if (do_freeze)
            heap_freeze_prepared_tuples(buffer, prstate.frozen, prstate.nfrozen);
 
        MarkBufferDirty(buffer);
 
        /*
         * Emit a WAL XLOG_HEAP2_PRUNE_FREEZE record showing what we did
         */
        if (RelationNeedsWAL(relation))
        {
            /*
             * The snapshotConflictHorizon for the whole record should be the
             * most conservative of all the horizons calculated for any of the
             * possible modifications.  If this record will prune tuples, any
             * transactions on the standby older than the youngest xmax of the
             * most recently removed tuple this record will prune will
             * conflict.  If this record will freeze tuples, any transactions
             * on the standby with xids older than the youngest tuple this
             * record will freeze will conflict.
             */
            TransactionId frz_conflict_horizon = InvalidTransactionId;
            TransactionId conflict_xid;
 
            /*
             * We can use the visibility_cutoff_xid as our cutoff for
             * conflicts when the whole page is eligible to become all-frozen
             * in the VM once we're done with it.  Otherwise we generate a
             * conservative cutoff by stepping back from OldestXmin.
             */
            if (do_freeze)
            {
                if (prstate.all_visible && prstate.all_frozen)
                    frz_conflict_horizon = prstate.visibility_cutoff_xid;
                else
                {
                    /* Avoids false conflicts when hot_standby_feedback in use */
                    frz_conflict_horizon = prstate.cutoffs->OldestXmin;
                    TransactionIdRetreat(frz_conflict_horizon);
                }
            }
 
            if (TransactionIdFollows(frz_conflict_horizon, prstate.latest_xid_removed))
                conflict_xid = frz_conflict_horizon;
            else
                conflict_xid = prstate.latest_xid_removed;
 
            log_heap_prune_and_freeze(relation, buffer,
                                      conflict_xid,
                                      true, reason,
                                      prstate.frozen, prstate.nfrozen,
                                      prstate.redirected, prstate.nredirected,
                                      prstate.nowdead, prstate.ndead,
                                      prstate.nowunused, prstate.nunused);
        }
    }
 
    END_CRIT_SECTION();
 
    /* Copy information back for caller */
    presult->ndeleted = prstate.ndeleted;
    presult->nnewlpdead = prstate.ndead;
    presult->nfrozen = prstate.nfrozen;
    presult->live_tuples = prstate.live_tuples;
    presult->recently_dead_tuples = prstate.recently_dead_tuples;
 
    /*
     * It was convenient to ignore LP_DEAD items in all_visible earlier on to
     * make the choice of whether or not to freeze the page unaffected by the
     * short-term presence of LP_DEAD items.  These LP_DEAD items were
     * effectively assumed to be LP_UNUSED items in the making.  It doesn't
     * matter which vacuum heap pass (initial pass or final pass) ends up
     * setting the page all-frozen, as long as the ongoing VACUUM does it.
     *
     * Now that freezing has been finalized, unset all_visible if there are
     * any LP_DEAD items on the page.  It needs to reflect the present state
     * of the page, as expected by our caller.
     */
    if (prstate.all_visible && prstate.lpdead_items == 0)
    {
        presult->all_visible = prstate.all_visible;
        presult->all_frozen = prstate.all_frozen;
    }
    else
    {
        presult->all_visible = false;
        presult->all_frozen = false;
    }
 
    presult->hastup = prstate.hastup;
 
    /*
     * For callers planning to update the visibility map, the conflict horizon
     * for that record must be the newest xmin on the page.  However, if the
     * page is completely frozen, there can be no conflict and the
     * vm_conflict_horizon should remain InvalidTransactionId.  This includes
     * the case that we just froze all the tuples; the prune-freeze record
     * included the conflict XID already so the caller doesn't need it.
     */
    if (presult->all_frozen)
        presult->vm_conflict_horizon = InvalidTransactionId;
    else
        presult->vm_conflict_horizon = prstate.visibility_cutoff_xid;
 
    presult->lpdead_items = prstate.lpdead_items;
    /* the presult->deadoffsets array was already filled in */
 
    if (prstate.freeze)
    {
        if (presult->nfrozen > 0)
        {
            *new_relfrozen_xid = prstate.pagefrz.FreezePageRelfrozenXid;
            *new_relmin_mxid = prstate.pagefrz.FreezePageRelminMxid;
        }
        else
        {
            *new_relfrozen_xid = prstate.pagefrz.NoFreezePageRelfrozenXid;
            *new_relmin_mxid = prstate.pagefrz.NoFreezePageRelminMxid;
        }
    }
}

References PruneState::all_frozen, PruneFreezeResult::all_frozen, PruneState::all_visible, PruneFreezeResult::all_visible, Assert(), BufferGetBlockNumber(), BufferGetPage(), PruneState::cutoffs, PruneState::deadoffsets, PruneFreezeResult::deadoffsets, elog, END_CRIT_SECTION, ERROR, FirstOffsetNumber, PruneState::freeze, HeapPageFreeze::freeze_required, HeapPageFreeze::FreezePageRelfrozenXid, HeapPageFreeze::FreezePageRelminMxid, PruneState::frozen, PruneState::hastup, PruneFreezeResult::hastup, heap_freeze_prepared_tuples(), heap_page_prune_execute(), HEAP_PAGE_PRUNE_FREEZE, HEAP_PAGE_PRUNE_MARK_UNUSED_NOW, heap_pre_freeze_checks(), heap_prune_chain(), heap_prune_record_unchanged_lp_dead(), heap_prune_record_unchanged_lp_normal(), heap_prune_record_unchanged_lp_unused(), heap_prune_record_unused(), heap_prune_satisfies_vacuum(), PruneState::heaponly_items, HEAPTUPLE_DEAD, HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsHotUpdated(), PruneState::htsv, i, InvalidMultiXactId, InvalidOffsetNumber, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), PruneState::latest_xid_removed, likely, PruneState::live_tuples, PruneFreezeResult::live_tuples, log_heap_prune_and_freeze(), PruneState::lpdead_items, PruneFreezeResult::lpdead_items, PruneState::mark_unused_now, MarkBufferDirty(), MarkBufferDirtyHint(), PruneState::ndead, PruneState::ndeleted, PruneFreezeResult::ndeleted, PruneState::new_prune_xid, PruneState::nfrozen, PruneFreezeResult::nfrozen, PruneState::nheaponly_items, PruneFreezeResult::nnewlpdead, HeapPageFreeze::NoFreezePageRelfrozenXid, HeapPageFreeze::NoFreezePageRelminMxid, PruneState::nowdead, PruneState::nowunused, PruneState::nredirected, PruneState::nroot_items, PruneState::nunused, OffsetNumberNext, OffsetNumberPrev, VacuumCutoffs::OldestXmin, PageClearFull(), PruneState::pagefrz, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIsFull(), pgWalUsage, PruneState::processed, PruneState::recently_dead_tuples, PruneFreezeResult::recently_dead_tuples, PruneState::redirected, RelationGetRelid, RelationNeedsWAL, PruneState::root_items, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), TransactionIdRetreat, unlikely, PruneState::visibility_cutoff_xid, PruneState::vistest, PruneFreezeResult::vm_conflict_horizon, WalUsage::wal_fpi, XLogCheckBufferNeedsBackup(), and XLogHintBitIsNeeded.

Referenced by heap_page_prune_opt(), and lazy_scan_prune().

heap_page_prune_execute()

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

Definition at line 1561 of file pruneheap.c.

{
    Page        page = (Page) BufferGetPage(buffer);
    OffsetNumber *offnum;
    HeapTupleHeader htup PG_USED_FOR_ASSERTS_ONLY;
 
    /* Shouldn't be called unless there's something to do */
    Assert(nredirected > 0 || ndead > 0 || nunused > 0);
 
    /* If 'lp_truncate_only', we can only remove already-dead line pointers */
    Assert(!lp_truncate_only || (nredirected == 0 && ndead == 0));
 
    /* Update all redirected line pointers */
    offnum = redirected;
    for (int i = 0; i < nredirected; i++)
    {
        OffsetNumber fromoff = *offnum++;
        OffsetNumber tooff = *offnum++;
        ItemId      fromlp = PageGetItemId(page, fromoff);
        ItemId      tolp PG_USED_FOR_ASSERTS_ONLY;
 
#ifdef USE_ASSERT_CHECKING
 
        /*
         * Any existing item that we set as an LP_REDIRECT (any 'from' item)
         * must be the first item from a HOT chain.  If the item has tuple
         * storage then it can't be a heap-only tuple.  Otherwise we are just
         * maintaining an existing LP_REDIRECT from an existing HOT chain that
         * has been pruned at least once before now.
         */
        if (!ItemIdIsRedirected(fromlp))
        {
            Assert(ItemIdHasStorage(fromlp) && ItemIdIsNormal(fromlp));
 
            htup = (HeapTupleHeader) PageGetItem(page, fromlp);
            Assert(!HeapTupleHeaderIsHeapOnly(htup));
        }
        else
        {
            /* We shouldn't need to redundantly set the redirect */
            Assert(ItemIdGetRedirect(fromlp) != tooff);
        }
 
        /*
         * The item that we're about to set as an LP_REDIRECT (the 'from'
         * item) will point to an existing item (the 'to' item) that is
         * already a heap-only tuple.  There can be at most one LP_REDIRECT
         * item per HOT chain.
         *
         * We need to keep around an LP_REDIRECT item (after original
         * non-heap-only root tuple gets pruned away) so that it's always
         * possible for VACUUM to easily figure out what TID to delete from
         * indexes when an entire HOT chain becomes dead.  A heap-only tuple
         * can never become LP_DEAD; an LP_REDIRECT item or a regular heap
         * tuple can.
         *
         * This check may miss problems, e.g. the target of a redirect could
         * be marked as unused subsequently. The page_verify_redirects() check
         * below will catch such problems.
         */
        tolp = PageGetItemId(page, tooff);
        Assert(ItemIdHasStorage(tolp) && ItemIdIsNormal(tolp));
        htup = (HeapTupleHeader) PageGetItem(page, tolp);
        Assert(HeapTupleHeaderIsHeapOnly(htup));
#endif
 
        ItemIdSetRedirect(fromlp, tooff);
    }
 
    /* Update all now-dead line pointers */
    offnum = nowdead;
    for (int i = 0; i < ndead; i++)
    {
        OffsetNumber off = *offnum++;
        ItemId      lp = PageGetItemId(page, off);
 
#ifdef USE_ASSERT_CHECKING
 
        /*
         * An LP_DEAD line pointer must be left behind when the original item
         * (which is dead to everybody) could still be referenced by a TID in
         * an index.  This should never be necessary with any individual
         * heap-only tuple item, though. (It's not clear how much of a problem
         * that would be, but there is no reason to allow it.)
         */
        if (ItemIdHasStorage(lp))
        {
            Assert(ItemIdIsNormal(lp));
            htup = (HeapTupleHeader) PageGetItem(page, lp);
            Assert(!HeapTupleHeaderIsHeapOnly(htup));
        }
        else
        {
            /* Whole HOT chain becomes dead */
            Assert(ItemIdIsRedirected(lp));
        }
#endif
 
        ItemIdSetDead(lp);
    }
 
    /* Update all now-unused line pointers */
    offnum = nowunused;
    for (int i = 0; i < nunused; i++)
    {
        OffsetNumber off = *offnum++;
        ItemId      lp = PageGetItemId(page, off);
 
#ifdef USE_ASSERT_CHECKING
 
        if (lp_truncate_only)
        {
            /* Setting LP_DEAD to LP_UNUSED in vacuum's second pass */
            Assert(ItemIdIsDead(lp) && !ItemIdHasStorage(lp));
        }
        else
        {
            /*
             * When heap_page_prune_and_freeze() was called, mark_unused_now
             * may have been passed as true, which allows would-be LP_DEAD
             * items to be made LP_UNUSED instead.  This is only possible if
             * the relation has no indexes.  If there are any dead items, then
             * mark_unused_now was not true and every item being marked
             * LP_UNUSED must refer to a heap-only tuple.
             */
            if (ndead > 0)
            {
                Assert(ItemIdHasStorage(lp) && ItemIdIsNormal(lp));
                htup = (HeapTupleHeader) PageGetItem(page, lp);
                Assert(HeapTupleHeaderIsHeapOnly(htup));
            }
            else
                Assert(ItemIdIsUsed(lp));
        }
 
#endif
 
        ItemIdSetUnused(lp);
    }
 
    if (lp_truncate_only)
        PageTruncateLinePointerArray(page);
    else
    {
        /*
         * Finally, repair any fragmentation, and update the page's hint bit
         * about whether it has free pointers.
         */
        PageRepairFragmentation(page);
 
        /*
         * Now that the page has been modified, assert that redirect items
         * still point to valid targets.
         */
        page_verify_redirects(page);
    }
}

References Assert(), BufferGetPage(), HeapTupleHeaderIsHeapOnly(), i, ItemIdGetRedirect, ItemIdHasStorage, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemIdSetDead, ItemIdSetRedirect, ItemIdSetUnused, page_verify_redirects(), PageGetItem(), PageGetItemId(), PageRepairFragmentation(), PageTruncateLinePointerArray(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by heap_page_prune_and_freeze(), and heap_xlog_prune_freeze().

heap_page_prune_opt()

void heap_page_prune_opt	(	Relation	relation,
		Buffer	buffer
	)

Definition at line 193 of file pruneheap.c.

{
    Page        page = BufferGetPage(buffer);
    TransactionId prune_xid;
    GlobalVisState *vistest;
    Size        minfree;
 
    /*
     * We can't write WAL in recovery mode, so there's no point trying to
     * clean the page. The primary will likely issue a cleaning WAL record
     * soon anyway, so this is no particular loss.
     */
    if (RecoveryInProgress())
        return;
 
    /*
     * First check whether there's any chance there's something to prune,
     * determining the appropriate horizon is a waste if there's no prune_xid
     * (i.e. no updates/deletes left potentially dead tuples around).
     */
    prune_xid = ((PageHeader) page)->pd_prune_xid;
    if (!TransactionIdIsValid(prune_xid))
        return;
 
    /*
     * Check whether prune_xid indicates that there may be dead rows that can
     * be cleaned up.
     */
    vistest = GlobalVisTestFor(relation);
 
    if (!GlobalVisTestIsRemovableXid(vistest, prune_xid))
        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.
         */
        if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
        {
            OffsetNumber dummy_off_loc;
            PruneFreezeResult presult;
 
            /*
             * For now, pass mark_unused_now as false regardless of whether or
             * not the relation has indexes, since we cannot safely determine
             * that during on-access pruning with the current implementation.
             */
            heap_page_prune_and_freeze(relation, buffer, vistest, 0,
                                       NULL, &presult, PRUNE_ON_ACCESS, &dummy_off_loc, NULL, NULL);
 
            /*
             * Report the number of tuples reclaimed to pgstats.  This is
             * presult.ndeleted minus the number of newly-LP_DEAD-set items.
             *
             * We derive the number of dead tuples like this to avoid totally
             * forgetting about items that were set to LP_DEAD, since they
             * still need to be cleaned up by VACUUM.  We only want to count
             * heap-only tuples that just became LP_UNUSED in our report,
             * which don't.
             *
             * VACUUM doesn't have to compensate in the same way when it
             * tracks ndeleted, since it will set the same LP_DEAD items to
             * LP_UNUSED separately.
             */
            if (presult.ndeleted > presult.nnewlpdead)
                pgstat_update_heap_dead_tuples(relation,
                                               presult.ndeleted - presult.nnewlpdead);
        }
 
        /* And release buffer lock */
        LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
        /*
         * We avoid reuse of any free space created on the page by unrelated
         * UPDATEs/INSERTs by opting to not update the FSM at this point.  The
         * free space should be reused by UPDATEs to *this* page.
         */
    }
}

References BUFFER_LOCK_UNLOCK, BufferGetPage(), ConditionalLockBufferForCleanup(), GlobalVisTestFor(), GlobalVisTestIsRemovableXid(), HEAP_DEFAULT_FILLFACTOR, heap_page_prune_and_freeze(), LockBuffer(), Max, PruneFreezeResult::ndeleted, PruneFreezeResult::nnewlpdead, PageGetHeapFreeSpace(), PageIsFull(), pgstat_update_heap_dead_tuples(), PRUNE_ON_ACCESS, RecoveryInProgress(), RelationGetTargetPageFreeSpace, and TransactionIdIsValid.

Referenced by BitmapHeapScanNextBlock(), heap_prepare_pagescan(), and heapam_index_fetch_tuple().

heap_pre_freeze_checks()

void heap_pre_freeze_checks	(	Buffer	buffer,
		HeapTupleFreeze *	tuples,
		int	ntuples
	)

Definition at line 7291 of file heapam.c.

{
    Page        page = BufferGetPage(buffer);
 
    for (int i = 0; i < ntuples; i++)
    {
        HeapTupleFreeze *frz = tuples + i;
        ItemId      itemid = PageGetItemId(page, frz->offset);
        HeapTupleHeader htup;
 
        htup = (HeapTupleHeader) PageGetItem(page, itemid);
 
        /* Deliberately avoid relying on tuple hint bits here */
        if (frz->checkflags & HEAP_FREEZE_CHECK_XMIN_COMMITTED)
        {
            TransactionId xmin = HeapTupleHeaderGetRawXmin(htup);
 
            Assert(!HeapTupleHeaderXminFrozen(htup));
            if (unlikely(!TransactionIdDidCommit(xmin)))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("uncommitted xmin %u needs to be frozen",
                                         xmin)));
        }
 
        /*
         * TransactionIdDidAbort won't work reliably in the presence of XIDs
         * left behind by transactions that were in progress during a crash,
         * so we can only check that xmax didn't commit
         */
        if (frz->checkflags & HEAP_FREEZE_CHECK_XMAX_ABORTED)
        {
            TransactionId xmax = HeapTupleHeaderGetRawXmax(htup);
 
            Assert(TransactionIdIsNormal(xmax));
            if (unlikely(TransactionIdDidCommit(xmax)))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("cannot freeze committed xmax %u",
                                         xmax)));
        }
    }
}

References Assert(), BufferGetPage(), HeapTupleFreeze::checkflags, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, HEAP_FREEZE_CHECK_XMAX_ABORTED, HEAP_FREEZE_CHECK_XMIN_COMMITTED, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderXminFrozen(), i, HeapTupleFreeze::offset, PageGetItem(), PageGetItemId(), TransactionIdDidCommit(), TransactionIdIsNormal, and unlikely.

Referenced by heap_page_prune_and_freeze().

heap_prepare_freeze_tuple()

bool heap_prepare_freeze_tuple	(	HeapTupleHeader	tuple,
		const struct VacuumCutoffs *	cutoffs,
		HeapPageFreeze *	pagefrz,
		HeapTupleFreeze *	frz,
		bool *	totally_frozen
	)

Definition at line 7018 of file heapam.c.

{
    bool        xmin_already_frozen = false,
                xmax_already_frozen = false;
    bool        freeze_xmin = false,
                replace_xvac = false,
                replace_xmax = false,
                freeze_xmax = false;
    TransactionId xid;
 
    frz->xmax = HeapTupleHeaderGetRawXmax(tuple);
    frz->t_infomask2 = tuple->t_infomask2;
    frz->t_infomask = tuple->t_infomask;
    frz->frzflags = 0;
    frz->checkflags = 0;
 
    /*
     * Process xmin, while keeping track of whether it's already frozen, or
     * will become frozen iff our freeze plan is executed by caller (could be
     * neither).
     */
    xid = HeapTupleHeaderGetXmin(tuple);
    if (!TransactionIdIsNormal(xid))
        xmin_already_frozen = true;
    else
    {
        if (TransactionIdPrecedes(xid, cutoffs->relfrozenxid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg_internal("found xmin %u from before relfrozenxid %u",
                                     xid, cutoffs->relfrozenxid)));
 
        /* Will set freeze_xmin flags in freeze plan below */
        freeze_xmin = TransactionIdPrecedes(xid, cutoffs->OldestXmin);
 
        /* Verify that xmin committed if and when freeze plan is executed */
        if (freeze_xmin)
            frz->checkflags |= HEAP_FREEZE_CHECK_XMIN_COMMITTED;
    }
 
    /*
     * Old-style VACUUM FULL is gone, but we have to process xvac for as long
     * as we support having MOVED_OFF/MOVED_IN tuples in the database
     */
    xid = HeapTupleHeaderGetXvac(tuple);
    if (TransactionIdIsNormal(xid))
    {
        Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
        Assert(TransactionIdPrecedes(xid, cutoffs->OldestXmin));
 
        /*
         * For Xvac, we always freeze proactively.  This allows totally_frozen
         * tracking to ignore xvac.
         */
        replace_xvac = pagefrz->freeze_required = true;
 
        /* Will set replace_xvac flags in freeze plan below */
    }
 
    /* Now process xmax */
    xid = frz->xmax;
    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
    {
        /* Raw xmax is a MultiXactId */
        TransactionId newxmax;
        uint16      flags;
 
        /*
         * We will either remove xmax completely (in the "freeze_xmax" path),
         * process xmax by replacing it (in the "replace_xmax" path), or
         * perform no-op xmax processing.  The only constraint is that the
         * FreezeLimit/MultiXactCutoff postcondition must never be violated.
         */
        newxmax = FreezeMultiXactId(xid, tuple->t_infomask, cutoffs,
                                    &flags, pagefrz);
 
        if (flags & FRM_NOOP)
        {
            /*
             * xmax is a MultiXactId, and nothing about it changes for now.
             * This is the only case where 'freeze_required' won't have been
             * set for us by FreezeMultiXactId, as well as the only case where
             * neither freeze_xmax nor replace_xmax are set (given a multi).
             *
             * This is a no-op, but the call to FreezeMultiXactId might have
             * ratcheted back NewRelfrozenXid and/or NewRelminMxid trackers
             * for us (the "freeze page" variants, specifically).  That'll
             * make it safe for our caller to freeze the page later on, while
             * leaving this particular xmax undisturbed.
             *
             * FreezeMultiXactId is _not_ responsible for the "no freeze"
             * NewRelfrozenXid/NewRelminMxid trackers, though -- that's our
             * job.  A call to heap_tuple_should_freeze for this same tuple
             * will take place below if 'freeze_required' isn't set already.
             * (This repeats work from FreezeMultiXactId, but allows "no
             * freeze" tracker maintenance to happen in only one place.)
             */
            Assert(!MultiXactIdPrecedes(newxmax, cutoffs->MultiXactCutoff));
            Assert(MultiXactIdIsValid(newxmax) && xid == newxmax);
        }
        else if (flags & FRM_RETURN_IS_XID)
        {
            /*
             * xmax will become an updater Xid (original MultiXact's updater
             * member Xid will be carried forward as a simple Xid in Xmax).
             */
            Assert(!TransactionIdPrecedes(newxmax, cutoffs->OldestXmin));
 
            /*
             * NB -- some of these transformations are only valid because we
             * know the return Xid is a tuple updater (i.e. not merely a
             * locker.) Also note that the only reason we don't explicitly
             * worry about HEAP_KEYS_UPDATED is because it lives in
             * t_infomask2 rather than t_infomask.
             */
            frz->t_infomask &= ~HEAP_XMAX_BITS;
            frz->xmax = newxmax;
            if (flags & FRM_MARK_COMMITTED)
                frz->t_infomask |= HEAP_XMAX_COMMITTED;
            replace_xmax = true;
        }
        else if (flags & FRM_RETURN_IS_MULTI)
        {
            uint16      newbits;
            uint16      newbits2;
 
            /*
             * xmax is an old MultiXactId that we have to replace with a new
             * MultiXactId, to carry forward two or more original member XIDs.
             */
            Assert(!MultiXactIdPrecedes(newxmax, cutoffs->OldestMxact));
 
            /*
             * We can't use GetMultiXactIdHintBits directly on the new multi
             * here; that routine initializes the masks to all zeroes, which
             * would lose other bits we need.  Doing it this way ensures all
             * unrelated bits remain untouched.
             */
            frz->t_infomask &= ~HEAP_XMAX_BITS;
            frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
            GetMultiXactIdHintBits(newxmax, &newbits, &newbits2);
            frz->t_infomask |= newbits;
            frz->t_infomask2 |= newbits2;
            frz->xmax = newxmax;
            replace_xmax = true;
        }
        else
        {
            /*
             * Freeze plan for tuple "freezes xmax" in the strictest sense:
             * it'll leave nothing in xmax (neither an Xid nor a MultiXactId).
             */
            Assert(flags & FRM_INVALIDATE_XMAX);
            Assert(!TransactionIdIsValid(newxmax));
 
            /* Will set freeze_xmax flags in freeze plan below */
            freeze_xmax = true;
        }
 
        /* MultiXactId processing forces freezing (barring FRM_NOOP case) */
        Assert(pagefrz->freeze_required || (!freeze_xmax && !replace_xmax));
    }
    else if (TransactionIdIsNormal(xid))
    {
        /* Raw xmax is normal XID */
        if (TransactionIdPrecedes(xid, cutoffs->relfrozenxid))
            ereport(ERROR,
                    (errcode(ERRCODE_DATA_CORRUPTED),
                     errmsg_internal("found xmax %u from before relfrozenxid %u",
                                     xid, cutoffs->relfrozenxid)));
 
        /* Will set freeze_xmax flags in freeze plan below */
        freeze_xmax = TransactionIdPrecedes(xid, cutoffs->OldestXmin);
 
        /*
         * Verify that xmax aborted if and when freeze plan is executed,
         * provided it's from an update. (A lock-only xmax can be removed
         * independent of this, since the lock is released at xact end.)
         */
        if (freeze_xmax && !HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
            frz->checkflags |= HEAP_FREEZE_CHECK_XMAX_ABORTED;
    }
    else if (!TransactionIdIsValid(xid))
    {
        /* Raw xmax is InvalidTransactionId XID */
        Assert((tuple->t_infomask & HEAP_XMAX_IS_MULTI) == 0);
        xmax_already_frozen = true;
    }
    else
        ereport(ERROR,
                (errcode(ERRCODE_DATA_CORRUPTED),
                 errmsg_internal("found raw xmax %u (infomask 0x%04x) not invalid and not multi",
                                 xid, tuple->t_infomask)));
 
    if (freeze_xmin)
    {
        Assert(!xmin_already_frozen);
 
        frz->t_infomask |= HEAP_XMIN_FROZEN;
    }
    if (replace_xvac)
    {
        /*
         * If a MOVED_OFF tuple is not dead, the xvac transaction must have
         * failed; whereas a non-dead MOVED_IN tuple must mean the xvac
         * transaction succeeded.
         */
        Assert(pagefrz->freeze_required);
        if (tuple->t_infomask & HEAP_MOVED_OFF)
            frz->frzflags |= XLH_INVALID_XVAC;
        else
            frz->frzflags |= XLH_FREEZE_XVAC;
    }
    if (replace_xmax)
    {
        Assert(!xmax_already_frozen && !freeze_xmax);
        Assert(pagefrz->freeze_required);
 
        /* Already set replace_xmax flags in freeze plan earlier */
    }
    if (freeze_xmax)
    {
        Assert(!xmax_already_frozen && !replace_xmax);
 
        frz->xmax = InvalidTransactionId;
 
        /*
         * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
         * LOCKED.  Normalize to INVALID just to be sure no one gets confused.
         * Also get rid of the HEAP_KEYS_UPDATED bit.
         */
        frz->t_infomask &= ~HEAP_XMAX_BITS;
        frz->t_infomask |= HEAP_XMAX_INVALID;
        frz->t_infomask2 &= ~HEAP_HOT_UPDATED;
        frz->t_infomask2 &= ~HEAP_KEYS_UPDATED;
    }
 
    /*
     * Determine if this tuple is already totally frozen, or will become
     * totally frozen (provided caller executes freeze plans for the page)
     */
    *totally_frozen = ((freeze_xmin || xmin_already_frozen) &&
                       (freeze_xmax || xmax_already_frozen));
 
    if (!pagefrz->freeze_required && !(xmin_already_frozen &&
                                       xmax_already_frozen))
    {
        /*
         * So far no previous tuple from the page made freezing mandatory.
         * Does this tuple force caller to freeze the entire page?
         */
        pagefrz->freeze_required =
            heap_tuple_should_freeze(tuple, cutoffs,
                                     &pagefrz->NoFreezePageRelfrozenXid,
                                     &pagefrz->NoFreezePageRelminMxid);
    }
 
    /* Tell caller if this tuple has a usable freeze plan set in *frz */
    return freeze_xmin || replace_xvac || replace_xmax || freeze_xmax;
}

References Assert(), HeapTupleFreeze::checkflags, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, HeapPageFreeze::freeze_required, FreezeMultiXactId(), FRM_INVALIDATE_XMAX, FRM_MARK_COMMITTED, FRM_NOOP, FRM_RETURN_IS_MULTI, FRM_RETURN_IS_XID, HeapTupleFreeze::frzflags, GetMultiXactIdHintBits(), HEAP_FREEZE_CHECK_XMAX_ABORTED, HEAP_FREEZE_CHECK_XMIN_COMMITTED, HEAP_MOVED_OFF, heap_tuple_should_freeze(), HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMIN_FROZEN, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), InvalidTransactionId, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), HeapPageFreeze::NoFreezePageRelfrozenXid, HeapPageFreeze::NoFreezePageRelminMxid, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumCutoffs::relfrozenxid, HeapTupleFreeze::t_infomask, HeapTupleHeaderData::t_infomask, HeapTupleFreeze::t_infomask2, HeapTupleHeaderData::t_infomask2, TransactionIdIsNormal, TransactionIdIsValid, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), XLH_FREEZE_XVAC, XLH_INVALID_XVAC, and HeapTupleFreeze::xmax.

Referenced by heap_freeze_tuple(), and heap_prune_record_unchanged_lp_normal().

heap_prepare_pagescan()

void heap_prepare_pagescan

(

TableScanDesc

sscan

)

Definition at line 531 of file heapam.c.

{
    HeapScanDesc scan = (HeapScanDesc) sscan;
    Buffer      buffer = scan->rs_cbuf;
    BlockNumber block = scan->rs_cblock;
    Snapshot    snapshot;
    Page        page;
    int         lines;
    bool        all_visible;
    bool        check_serializable;
 
    Assert(BufferGetBlockNumber(buffer) == block);
 
    /* ensure we're not accidentally being used when not in pagemode */
    Assert(scan->rs_base.rs_flags & SO_ALLOW_PAGEMODE);
    snapshot = scan->rs_base.rs_snapshot;
 
    /*
     * Prune and repair fragmentation for the whole page, if possible.
     */
    heap_page_prune_opt(scan->rs_base.rs_rd, buffer);
 
    /*
     * We must hold share lock on the buffer content while examining tuple
     * visibility.  Afterwards, however, the tuples we have found to be
     * visible are guaranteed good as long as we hold the buffer pin.
     */
    LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
    page = BufferGetPage(buffer);
    lines = PageGetMaxOffsetNumber(page);
 
    /*
     * If the all-visible flag indicates that all tuples on the page are
     * visible to everyone, we can skip the per-tuple visibility tests.
     *
     * Note: In hot standby, a tuple that's already visible to all
     * transactions on the primary might still be invisible to a read-only
     * transaction in the standby. We partly handle this problem by tracking
     * the minimum xmin of visible tuples as the cut-off XID while marking a
     * page all-visible on the primary and WAL log that along with the
     * visibility map SET operation. In hot standby, we wait for (or abort)
     * all transactions that can potentially may not see one or more tuples on
     * the page. That's how index-only scans work fine in hot standby. A
     * crucial difference between index-only scans and heap scans is that the
     * index-only scan completely relies on the visibility map where as heap
     * scan looks at the page-level PD_ALL_VISIBLE flag. We are not sure if
     * the page-level flag can be trusted in the same way, because it might
     * get propagated somehow without being explicitly WAL-logged, e.g. via a
     * full page write. Until we can prove that beyond doubt, let's check each
     * tuple for visibility the hard way.
     */
    all_visible = PageIsAllVisible(page) && !snapshot->takenDuringRecovery;
    check_serializable =
        CheckForSerializableConflictOutNeeded(scan->rs_base.rs_rd, snapshot);
 
    /*
     * We call page_collect_tuples() with constant arguments, to get the
     * compiler to constant fold the constant arguments. Separate calls with
     * constant arguments, rather than variables, are needed on several
     * compilers to actually perform constant folding.
     */
    if (likely(all_visible))
    {
        if (likely(!check_serializable))
            scan->rs_ntuples = page_collect_tuples(scan, snapshot, page, buffer,
                                                   block, lines, true, false);
        else
            scan->rs_ntuples = page_collect_tuples(scan, snapshot, page, buffer,
                                                   block, lines, true, true);
    }
    else
    {
        if (likely(!check_serializable))
            scan->rs_ntuples = page_collect_tuples(scan, snapshot, page, buffer,
                                                   block, lines, false, false);
        else
            scan->rs_ntuples = page_collect_tuples(scan, snapshot, page, buffer,
                                                   block, lines, false, true);
    }
 
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
}

References Assert(), BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), CheckForSerializableConflictOutNeeded(), heap_page_prune_opt(), likely, LockBuffer(), page_collect_tuples(), PageGetMaxOffsetNumber(), PageIsAllVisible(), HeapScanDescData::rs_base, HeapScanDescData::rs_cblock, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, HeapScanDescData::rs_ntuples, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, and SnapshotData::takenDuringRecovery.

Referenced by heapam_scan_sample_next_block(), and heapgettup_pagemode().

heap_rescan()

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

Definition at line 1222 of file heapam.c.

{
    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);
        scan->rs_cbuf = InvalidBuffer;
    }
 
    /*
     * SO_TYPE_BITMAPSCAN would be cleaned up here, but it does not hold any
     * additional data vs a normal HeapScan
     */
 
    /*
     * The read stream is reset on rescan. This must be done before
     * initscan(), as some state referred to by read_stream_reset() is reset
     * in initscan().
     */
    if (scan->rs_read_stream)
        read_stream_reset(scan->rs_read_stream);
 
    /*
     * reinitialize scan descriptor
     */
    initscan(scan, key, true);
}

References BufferIsValid(), initscan(), InvalidBuffer, IsMVCCSnapshot, sort-test::key, read_stream_reset(), ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, and SO_ALLOW_SYNC.

heap_set_tidrange()

void heap_set_tidrange	(	TableScanDesc	sscan,
		ItemPointer	mintid,
		ItemPointer	maxtid
	)

Definition at line 1393 of file heapam.c.

{
    HeapScanDesc scan = (HeapScanDesc) sscan;
    BlockNumber startBlk;
    BlockNumber numBlks;
    ItemPointerData highestItem;
    ItemPointerData lowestItem;
 
    /*
     * For relations without any pages, we can simply leave the TID range
     * unset.  There will be no tuples to scan, therefore no tuples outside
     * the given TID range.
     */
    if (scan->rs_nblocks == 0)
        return;
 
    /*
     * Set up some ItemPointers which point to the first and last possible
     * tuples in the heap.
     */
    ItemPointerSet(&highestItem, scan->rs_nblocks - 1, MaxOffsetNumber);
    ItemPointerSet(&lowestItem, 0, FirstOffsetNumber);
 
    /*
     * If the given maximum TID is below the highest possible TID in the
     * relation, then restrict the range to that, otherwise we scan to the end
     * of the relation.
     */
    if (ItemPointerCompare(maxtid, &highestItem) < 0)
        ItemPointerCopy(maxtid, &highestItem);
 
    /*
     * If the given minimum TID is above the lowest possible TID in the
     * relation, then restrict the range to only scan for TIDs above that.
     */
    if (ItemPointerCompare(mintid, &lowestItem) > 0)
        ItemPointerCopy(mintid, &lowestItem);
 
    /*
     * Check for an empty range and protect from would be negative results
     * from the numBlks calculation below.
     */
    if (ItemPointerCompare(&highestItem, &lowestItem) < 0)
    {
        /* Set an empty range of blocks to scan */
        heap_setscanlimits(sscan, 0, 0);
        return;
    }
 
    /*
     * Calculate the first block and the number of blocks we must scan. We
     * could be more aggressive here and perform some more validation to try
     * and further narrow the scope of blocks to scan by checking if the
     * lowestItem has an offset above MaxOffsetNumber.  In this case, we could
     * advance startBlk by one.  Likewise, if highestItem has an offset of 0
     * we could scan one fewer blocks.  However, such an optimization does not
     * seem worth troubling over, currently.
     */
    startBlk = ItemPointerGetBlockNumberNoCheck(&lowestItem);
 
    numBlks = ItemPointerGetBlockNumberNoCheck(&highestItem) -
        ItemPointerGetBlockNumberNoCheck(&lowestItem) + 1;
 
    /* Set the start block and number of blocks to scan */
    heap_setscanlimits(sscan, startBlk, numBlks);
 
    /* Finally, set the TID range in sscan */
    ItemPointerCopy(&lowestItem, &sscan->st.tidrange.rs_mintid);
    ItemPointerCopy(&highestItem, &sscan->st.tidrange.rs_maxtid);
}

References FirstOffsetNumber, heap_setscanlimits(), ItemPointerCompare(), ItemPointerCopy(), ItemPointerGetBlockNumberNoCheck(), ItemPointerSet(), MaxOffsetNumber, TableScanDescData::rs_maxtid, TableScanDescData::rs_mintid, HeapScanDescData::rs_nblocks, TableScanDescData::st, and TableScanDescData::tidrange.

heap_setscanlimits()

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

Definition at line 459 of file heapam.c.

{
    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;
}

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

Referenced by heap_set_tidrange(), and heapam_index_build_range_scan().

heap_tuple_needs_eventual_freeze()

bool heap_tuple_needs_eventual_freeze

(

HeapTupleHeader

tuple

)

Definition at line 7774 of file heapam.c.

{
    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;
}

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

heap_tuple_should_freeze()

bool heap_tuple_should_freeze	(	HeapTupleHeader	tuple,
		const struct VacuumCutoffs *	cutoffs,
		TransactionId *	NoFreezePageRelfrozenXid,
		MultiXactId *	NoFreezePageRelminMxid
	)

Definition at line 7829 of file heapam.c.

{
    TransactionId xid;
    MultiXactId multi;
    bool        freeze = false;
 
    /* First deal with xmin */
    xid = HeapTupleHeaderGetXmin(tuple);
    if (TransactionIdIsNormal(xid))
    {
        Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
        if (TransactionIdPrecedes(xid, *NoFreezePageRelfrozenXid))
            *NoFreezePageRelfrozenXid = xid;
        if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
            freeze = true;
    }
 
    /* Now deal with xmax */
    xid = InvalidTransactionId;
    multi = InvalidMultiXactId;
    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
        multi = HeapTupleHeaderGetRawXmax(tuple);
    else
        xid = HeapTupleHeaderGetRawXmax(tuple);
 
    if (TransactionIdIsNormal(xid))
    {
        Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
        /* xmax is a non-permanent XID */
        if (TransactionIdPrecedes(xid, *NoFreezePageRelfrozenXid))
            *NoFreezePageRelfrozenXid = xid;
        if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
            freeze = true;
    }
    else if (!MultiXactIdIsValid(multi))
    {
        /* xmax is a permanent XID or invalid MultiXactId/XID */
    }
    else if (HEAP_LOCKED_UPGRADED(tuple->t_infomask))
    {
        /* xmax is a pg_upgrade'd MultiXact, which can't have updater XID */
        if (MultiXactIdPrecedes(multi, *NoFreezePageRelminMxid))
            *NoFreezePageRelminMxid = multi;
        /* heap_prepare_freeze_tuple always freezes pg_upgrade'd xmax */
        freeze = true;
    }
    else
    {
        /* xmax is a MultiXactId that may have an updater XID */
        MultiXactMember *members;
        int         nmembers;
 
        Assert(MultiXactIdPrecedesOrEquals(cutoffs->relminmxid, multi));
        if (MultiXactIdPrecedes(multi, *NoFreezePageRelminMxid))
            *NoFreezePageRelminMxid = multi;
        if (MultiXactIdPrecedes(multi, cutoffs->MultiXactCutoff))
            freeze = true;
 
        /* need to check whether any member of the mxact is old */
        nmembers = GetMultiXactIdMembers(multi, &members, false,
                                         HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
 
        for (int i = 0; i < nmembers; i++)
        {
            xid = members[i].xid;
            Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
            if (TransactionIdPrecedes(xid, *NoFreezePageRelfrozenXid))
                *NoFreezePageRelfrozenXid = xid;
            if (TransactionIdPrecedes(xid, cutoffs->FreezeLimit))
                freeze = true;
        }
        if (nmembers > 0)
            pfree(members);
    }
 
    if (tuple->t_infomask & HEAP_MOVED)
    {
        xid = HeapTupleHeaderGetXvac(tuple);
        if (TransactionIdIsNormal(xid))
        {
            Assert(TransactionIdPrecedesOrEquals(cutoffs->relfrozenxid, xid));
            if (TransactionIdPrecedes(xid, *NoFreezePageRelfrozenXid))
                *NoFreezePageRelfrozenXid = xid;
            /* heap_prepare_freeze_tuple forces xvac freezing */
            freeze = true;
        }
    }
 
    return freeze;
}

References Assert(), VacuumCutoffs::FreezeLimit, GetMultiXactIdMembers(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetXmin(), HeapTupleHeaderGetXvac(), i, InvalidMultiXactId, InvalidTransactionId, VacuumCutoffs::MultiXactCutoff, MultiXactIdIsValid, MultiXactIdPrecedes(), MultiXactIdPrecedesOrEquals(), pfree(), VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, HeapTupleHeaderData::t_infomask, TransactionIdIsNormal, TransactionIdPrecedes(), TransactionIdPrecedesOrEquals(), and MultiXactMember::xid.

Referenced by heap_prepare_freeze_tuple(), and lazy_scan_noprune().

heap_update()

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

Definition at line 3212 of file heapam.c.

{
    TM_Result   result;
    TransactionId xid = GetCurrentTransactionId();
    Bitmapset  *hot_attrs;
    Bitmapset  *sum_attrs;
    Bitmapset  *key_attrs;
    Bitmapset  *id_attrs;
    Bitmapset  *interesting_attrs;
    Bitmapset  *modified_attrs;
    ItemId      lp;
    HeapTupleData oldtup;
    HeapTuple   heaptup;
    HeapTuple   old_key_tuple = NULL;
    bool        old_key_copied = false;
    Page        page;
    BlockNumber block;
    MultiXactStatus mxact_status;
    Buffer      buffer,
                newbuf,
                vmbuffer = InvalidBuffer,
                vmbuffer_new = InvalidBuffer;
    bool        need_toast;
    Size        newtupsize,
                pagefree;
    bool        have_tuple_lock = false;
    bool        iscombo;
    bool        use_hot_update = false;
    bool        summarized_update = false;
    bool        key_intact;
    bool        all_visible_cleared = false;
    bool        all_visible_cleared_new = false;
    bool        checked_lockers;
    bool        locker_remains;
    bool        id_has_external = false;
    TransactionId xmax_new_tuple,
                xmax_old_tuple;
    uint16      infomask_old_tuple,
                infomask2_old_tuple,
                infomask_new_tuple,
                infomask2_new_tuple;
 
    Assert(ItemPointerIsValid(otid));
 
    /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
    Assert(HeapTupleHeaderGetNatts(newtup->t_data) <=
           RelationGetNumberOfAttributes(relation));
 
    /*
     * Forbid this during a parallel operation, lest it allocate a combo CID.
     * Other workers might need that combo CID for visibility checks, and we
     * have no provision for broadcasting it to them.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot update tuples during a parallel operation")));
 
#ifdef USE_ASSERT_CHECKING
    check_lock_if_inplace_updateable_rel(relation, otid, newtup);
#endif
 
    /*
     * Fetch the list of attributes to be checked for various operations.
     *
     * For HOT considerations, this is wasted effort if we fail to update or
     * have to put the new tuple on a different page.  But we must compute the
     * list before obtaining buffer lock --- in the worst case, if we are
     * doing an update on one of the relevant system catalogs, we could
     * deadlock if we try to fetch the list later.  In any case, the relcache
     * caches the data so this is usually pretty cheap.
     *
     * We also need columns used by the replica identity and columns that are
     * considered the "key" of rows in the table.
     *
     * Note that we get copies of each bitmap, so we need not worry about
     * relcache flush happening midway through.
     */
    hot_attrs = RelationGetIndexAttrBitmap(relation,
                                           INDEX_ATTR_BITMAP_HOT_BLOCKING);
    sum_attrs = RelationGetIndexAttrBitmap(relation,
                                           INDEX_ATTR_BITMAP_SUMMARIZED);
    key_attrs = RelationGetIndexAttrBitmap(relation, INDEX_ATTR_BITMAP_KEY);
    id_attrs = RelationGetIndexAttrBitmap(relation,
                                          INDEX_ATTR_BITMAP_IDENTITY_KEY);
    interesting_attrs = NULL;
    interesting_attrs = bms_add_members(interesting_attrs, hot_attrs);
    interesting_attrs = bms_add_members(interesting_attrs, sum_attrs);
    interesting_attrs = bms_add_members(interesting_attrs, key_attrs);
    interesting_attrs = bms_add_members(interesting_attrs, id_attrs);
 
    block = ItemPointerGetBlockNumber(otid);
    INJECTION_POINT("heap_update-before-pin", NULL);
    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);
 
    lp = PageGetItemId(page, ItemPointerGetOffsetNumber(otid));
 
    /*
     * Usually, a buffer pin and/or snapshot blocks pruning of otid, ensuring
     * we see LP_NORMAL here.  When the otid origin is a syscache, we may have
     * neither a pin nor a snapshot.  Hence, we may see other LP_ states, each
     * of which indicates concurrent pruning.
     *
     * Failing with TM_Updated would be most accurate.  However, unlike other
     * TM_Updated scenarios, we don't know the successor ctid in LP_UNUSED and
     * LP_DEAD cases.  While the distinction between TM_Updated and TM_Deleted
     * does matter to SQL statements UPDATE and MERGE, those SQL statements
     * hold a snapshot that ensures LP_NORMAL.  Hence, the choice between
     * TM_Updated and TM_Deleted affects only the wording of error messages.
     * Settle on TM_Deleted, for two reasons.  First, it avoids complicating
     * the specification of when tmfd->ctid is valid.  Second, it creates
     * error log evidence that we took this branch.
     *
     * Since it's possible to see LP_UNUSED at otid, it's also possible to see
     * LP_NORMAL for a tuple that replaced LP_UNUSED.  If it's a tuple for an
     * unrelated row, we'll fail with "duplicate key value violates unique".
     * XXX if otid is the live, newer version of the newtup row, we'll discard
     * changes originating in versions of this catalog row after the version
     * the caller got from syscache.  See syscache-update-pruned.spec.
     */
    if (!ItemIdIsNormal(lp))
    {
        Assert(RelationSupportsSysCache(RelationGetRelid(relation)));
 
        UnlockReleaseBuffer(buffer);
        Assert(!have_tuple_lock);
        if (vmbuffer != InvalidBuffer)
            ReleaseBuffer(vmbuffer);
        tmfd->ctid = *otid;
        tmfd->xmax = InvalidTransactionId;
        tmfd->cmax = InvalidCommandId;
        *update_indexes = TU_None;
 
        bms_free(hot_attrs);
        bms_free(sum_attrs);
        bms_free(key_attrs);
        bms_free(id_attrs);
        /* modified_attrs not yet initialized */
        bms_free(interesting_attrs);
        return TM_Deleted;
    }
 
    /*
     * Fill in enough data in oldtup for HeapDetermineColumnsInfo to work
     * properly.
     */
    oldtup.t_tableOid = RelationGetRelid(relation);
    oldtup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
    oldtup.t_len = ItemIdGetLength(lp);
    oldtup.t_self = *otid;
 
    /* the new tuple is ready, except for this: */
    newtup->t_tableOid = RelationGetRelid(relation);
 
    /*
     * Determine columns modified by the update.  Additionally, identify
     * whether any of the unmodified replica identity key attributes in the
     * old tuple is externally stored or not.  This is required because for
     * such attributes the flattened value won't be WAL logged as part of the
     * new tuple so we must include it as part of the old_key_tuple.  See
     * ExtractReplicaIdentity.
     */
    modified_attrs = HeapDetermineColumnsInfo(relation, interesting_attrs,
                                              id_attrs, &oldtup,
                                              newtup, &id_has_external);
 
    /*
     * If we're not updating any "key" column, we can grab a weaker lock type.
     * This allows for more concurrency when we are running simultaneously
     * with foreign key checks.
     *
     * Note that if a column gets detoasted while executing the update, but
     * the value ends up being the same, this test will fail and we will use
     * the stronger lock.  This is acceptable; the important case to optimize
     * is updates that don't manipulate key columns, not those that
     * serendipitously arrive at the same key values.
     */
    if (!bms_overlap(modified_attrs, key_attrs))
    {
        *lockmode = LockTupleNoKeyExclusive;
        mxact_status = MultiXactStatusNoKeyUpdate;
        key_intact = true;
 
        /*
         * 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();
    }
    else
    {
        *lockmode = LockTupleExclusive;
        mxact_status = MultiXactStatusUpdate;
        key_intact = false;
    }
 
    /*
     * Note: beyond this point, use oldtup not otid to refer to old tuple.
     * otid may very well point at newtup->t_self, which we will overwrite
     * with the new tuple's location, so there's great risk of confusion if we
     * use otid anymore.
     */
 
l2:
    checked_lockers = false;
    locker_remains = false;
    result = HeapTupleSatisfiesUpdate(&oldtup, cid, buffer);
 
    /* see below about the "no wait" case */
    Assert(result != TM_BeingModified || wait);
 
    if (result == TM_Invisible)
    {
        UnlockReleaseBuffer(buffer);
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("attempted to update invisible tuple")));
    }
    else if (result == TM_BeingModified && wait)
    {
        TransactionId xwait;
        uint16      infomask;
        bool        can_continue = false;
 
        /*
         * XXX note that we don't consider the "no wait" case here.  This
         * isn't a problem currently because no caller uses that case, but it
         * should be fixed if such a caller is introduced.  It wasn't a
         * problem previously because this code would always wait, but now
         * that some tuple locks do not conflict with one of the lock modes we
         * use, it is possible that this case is interesting to handle
         * specially.
         *
         * This may cause failures with third-party code that calls
         * heap_update directly.
         */
 
        /* must copy state data before unlocking buffer */
        xwait = HeapTupleHeaderGetRawXmax(oldtup.t_data);
        infomask = oldtup.t_data->t_infomask;
 
        /*
         * Now we have to do something about the existing locker.  If it's a
         * multi, sleep on it; we might be awakened before it is completely
         * gone (or even not sleep at all in some cases); we need to preserve
         * it as locker, unless it is gone completely.
         *
         * If it's not a multi, we need to check for sleeping conditions
         * before actually going to sleep.  If the update doesn't conflict
         * with the locks, we just continue without sleeping (but making sure
         * it is preserved).
         *
         * 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.  Note we must
         * not acquire the tuple lock until we're sure we're going to sleep;
         * otherwise we're open for race conditions with other transactions
         * holding the tuple lock which sleep on us.
         *
         * 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)
        {
            TransactionId update_xact;
            int         remain;
            bool        current_is_member = false;
 
            if (DoesMultiXactIdConflict((MultiXactId) xwait, infomask,
                                        *lockmode, &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, &(oldtup.t_self), *lockmode,
                                         LockWaitBlock, &have_tuple_lock);
 
                /* wait for multixact */
                MultiXactIdWait((MultiXactId) xwait, mxact_status, infomask,
                                relation, &oldtup.t_self, XLTW_Update,
                                &remain);
                checked_lockers = true;
                locker_remains = remain != 0;
                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(oldtup.t_data->t_infomask,
                                          infomask) ||
                    !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
                                         xwait))
                    goto l2;
            }
 
            /*
             * Note that the multixact may not be done by now.  It could have
             * surviving members; our own xact or other subxacts of this
             * backend, and also any other concurrent transaction that locked
             * the tuple with LockTupleKeyShare if we only got
             * LockTupleNoKeyExclusive.  If this is the case, we have to be
             * careful to mark the updated tuple with the surviving members in
             * Xmax.
             *
             * Note that there could have been another update in the
             * MultiXact. In that case, we need to check whether it committed
             * or aborted. If it aborted we are safe to update it again;
             * otherwise there is an update conflict, and we have to return
             * TableTuple{Deleted, Updated} below.
             *
             * In the LockTupleExclusive case, we still need to preserve the
             * surviving members: those would include the tuple locks we had
             * before this one, which are important to keep in case this
             * subxact aborts.
             */
            if (!HEAP_XMAX_IS_LOCKED_ONLY(oldtup.t_data->t_infomask))
                update_xact = HeapTupleGetUpdateXid(oldtup.t_data);
            else
                update_xact = InvalidTransactionId;
 
            /*
             * There was no UPDATE in the MultiXact; or it aborted. No
             * TransactionIdIsInProgress() call needed here, since we called
             * MultiXactIdWait() above.
             */
            if (!TransactionIdIsValid(update_xact) ||
                TransactionIdDidAbort(update_xact))
                can_continue = true;
        }
        else if (TransactionIdIsCurrentTransactionId(xwait))
        {
            /*
             * The only locker is ourselves; we can avoid grabbing the tuple
             * lock here, but must preserve our locking information.
             */
            checked_lockers = true;
            locker_remains = true;
            can_continue = true;
        }
        else if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) && key_intact)
        {
            /*
             * If it's just a key-share locker, and we're not changing the key
             * columns, we don't need to wait for it to end; but we need to
             * preserve it as locker.
             */
            checked_lockers = true;
            locker_remains = true;
            can_continue = true;
        }
        else
        {
            /*
             * Wait for regular transaction to end; but first, acquire tuple
             * lock.
             */
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            heap_acquire_tuplock(relation, &(oldtup.t_self), *lockmode,
                                 LockWaitBlock, &have_tuple_lock);
            XactLockTableWait(xwait, relation, &oldtup.t_self,
                              XLTW_Update);
            checked_lockers = true;
            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(oldtup.t_data->t_infomask, infomask) ||
                !TransactionIdEquals(xwait,
                                     HeapTupleHeaderGetRawXmax(oldtup.t_data)))
                goto l2;
 
            /* Otherwise check if it committed or aborted */
            UpdateXmaxHintBits(oldtup.t_data, buffer, xwait);
            if (oldtup.t_data->t_infomask & HEAP_XMAX_INVALID)
                can_continue = true;
        }
 
        if (can_continue)
            result = TM_Ok;
        else if (!ItemPointerEquals(&oldtup.t_self, &oldtup.t_data->t_ctid))
            result = TM_Updated;
        else
            result = TM_Deleted;
    }
 
    /* Sanity check the result HeapTupleSatisfiesUpdate() and the logic above */
    if (result != TM_Ok)
    {
        Assert(result == TM_SelfModified ||
               result == TM_Updated ||
               result == TM_Deleted ||
               result == TM_BeingModified);
        Assert(!(oldtup.t_data->t_infomask & HEAP_XMAX_INVALID));
        Assert(result != TM_Updated ||
               !ItemPointerEquals(&oldtup.t_self, &oldtup.t_data->t_ctid));
    }
 
    if (crosscheck != InvalidSnapshot && result == TM_Ok)
    {
        /* Perform additional check for transaction-snapshot mode RI updates */
        if (!HeapTupleSatisfiesVisibility(&oldtup, crosscheck, buffer))
            result = TM_Updated;
    }
 
    if (result != TM_Ok)
    {
        tmfd->ctid = oldtup.t_data->t_ctid;
        tmfd->xmax = HeapTupleHeaderGetUpdateXid(oldtup.t_data);
        if (result == TM_SelfModified)
            tmfd->cmax = HeapTupleHeaderGetCmax(oldtup.t_data);
        else
            tmfd->cmax = InvalidCommandId;
        UnlockReleaseBuffer(buffer);
        if (have_tuple_lock)
            UnlockTupleTuplock(relation, &(oldtup.t_self), *lockmode);
        if (vmbuffer != InvalidBuffer)
            ReleaseBuffer(vmbuffer);
        *update_indexes = TU_None;
 
        bms_free(hot_attrs);
        bms_free(sum_attrs);
        bms_free(key_attrs);
        bms_free(id_attrs);
        bms_free(modified_attrs);
        bms_free(interesting_attrs);
        return result;
    }
 
    /*
     * 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 an 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 l2;
    }
 
    /* Fill in transaction status data */
 
    /*
     * If the tuple we're updating is locked, we need to preserve the locking
     * info in the old tuple's Xmax.  Prepare a new Xmax value for this.
     */
    compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
                              oldtup.t_data->t_infomask,
                              oldtup.t_data->t_infomask2,
                              xid, *lockmode, true,
                              &xmax_old_tuple, &infomask_old_tuple,
                              &infomask2_old_tuple);
 
    /*
     * And also prepare an Xmax value for the new copy of the tuple.  If there
     * was no xmax previously, or there was one but all lockers are now gone,
     * then use InvalidTransactionId; otherwise, get the xmax from the old
     * tuple.  (In rare cases that might also be InvalidTransactionId and yet
     * not have the HEAP_XMAX_INVALID bit set; that's fine.)
     */
    if ((oldtup.t_data->t_infomask & HEAP_XMAX_INVALID) ||
        HEAP_LOCKED_UPGRADED(oldtup.t_data->t_infomask) ||
        (checked_lockers && !locker_remains))
        xmax_new_tuple = InvalidTransactionId;
    else
        xmax_new_tuple = HeapTupleHeaderGetRawXmax(oldtup.t_data);
 
    if (!TransactionIdIsValid(xmax_new_tuple))
    {
        infomask_new_tuple = HEAP_XMAX_INVALID;
        infomask2_new_tuple = 0;
    }
    else
    {
        /*
         * If we found a valid Xmax for the new tuple, then the infomask bits
         * to use on the new tuple depend on what was there on the old one.
         * Note that since we're doing an update, the only possibility is that
         * the lockers had FOR KEY SHARE lock.
         */
        if (oldtup.t_data->t_infomask & HEAP_XMAX_IS_MULTI)
        {
            GetMultiXactIdHintBits(xmax_new_tuple, &infomask_new_tuple,
                                   &infomask2_new_tuple);
        }
        else
        {
            infomask_new_tuple = HEAP_XMAX_KEYSHR_LOCK | HEAP_XMAX_LOCK_ONLY;
            infomask2_new_tuple = 0;
        }
    }
 
    /*
     * Prepare the new tuple with the appropriate initial values of Xmin and
     * Xmax, as well as initial infomask bits as computed above.
     */
    newtup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
    newtup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
    HeapTupleHeaderSetXmin(newtup->t_data, xid);
    HeapTupleHeaderSetCmin(newtup->t_data, cid);
    newtup->t_data->t_infomask |= HEAP_UPDATED | infomask_new_tuple;
    newtup->t_data->t_infomask2 |= infomask2_new_tuple;
    HeapTupleHeaderSetXmax(newtup->t_data, xmax_new_tuple);
 
    /*
     * Replace cid with a combo CID if necessary.  Note that we already put
     * the plain cid into the new tuple.
     */
    HeapTupleHeaderAdjustCmax(oldtup.t_data, &cid, &iscombo);
 
    /*
     * If the toaster needs to be activated, OR if the new tuple will not fit
     * on the same page as the old, then we need to release the content lock
     * (but not the pin!) on the old tuple's buffer while we are off doing
     * TOAST and/or table-file-extension work.  We must mark the old tuple to
     * show that it's locked, else other processes may try to update it
     * themselves.
     *
     * We need to invoke the toaster if there are already any out-of-line
     * toasted values present, or if the new tuple is over-threshold.
     */
    if (relation->rd_rel->relkind != RELKIND_RELATION &&
        relation->rd_rel->relkind != RELKIND_MATVIEW)
    {
        /* toast table entries should never be recursively toasted */
        Assert(!HeapTupleHasExternal(&oldtup));
        Assert(!HeapTupleHasExternal(newtup));
        need_toast = false;
    }
    else
        need_toast = (HeapTupleHasExternal(&oldtup) ||
                      HeapTupleHasExternal(newtup) ||
                      newtup->t_len > TOAST_TUPLE_THRESHOLD);
 
    pagefree = PageGetHeapFreeSpace(page);
 
    newtupsize = MAXALIGN(newtup->t_len);
 
    if (need_toast || newtupsize > pagefree)
    {
        TransactionId xmax_lock_old_tuple;
        uint16      infomask_lock_old_tuple,
                    infomask2_lock_old_tuple;
        bool        cleared_all_frozen = false;
 
        /*
         * To prevent concurrent sessions from updating the tuple, we have to
         * temporarily mark it locked, while we release the page-level lock.
         *
         * To satisfy the rule that any xid potentially appearing in a buffer
         * written out to disk, we unfortunately have to WAL log this
         * temporary modification.  We can reuse xl_heap_lock for this
         * purpose.  If we crash/error before following through with the
         * actual update, xmax will be of an aborted transaction, allowing
         * other sessions to proceed.
         */
 
        /*
         * Compute xmax / infomask appropriate for locking the tuple. This has
         * to be done separately from the combo that's going to be used for
         * updating, because the potentially created multixact would otherwise
         * be wrong.
         */
        compute_new_xmax_infomask(HeapTupleHeaderGetRawXmax(oldtup.t_data),
                                  oldtup.t_data->t_infomask,
                                  oldtup.t_data->t_infomask2,
                                  xid, *lockmode, false,
                                  &xmax_lock_old_tuple, &infomask_lock_old_tuple,
                                  &infomask2_lock_old_tuple);
 
        Assert(HEAP_XMAX_IS_LOCKED_ONLY(infomask_lock_old_tuple));
 
        START_CRIT_SECTION();
 
        /* Clear obsolete visibility flags ... */
        oldtup.t_data->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
        oldtup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
        HeapTupleClearHotUpdated(&oldtup);
        /* ... and store info about transaction updating this tuple */
        Assert(TransactionIdIsValid(xmax_lock_old_tuple));
        HeapTupleHeaderSetXmax(oldtup.t_data, xmax_lock_old_tuple);
        oldtup.t_data->t_infomask |= infomask_lock_old_tuple;
        oldtup.t_data->t_infomask2 |= infomask2_lock_old_tuple;
        HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
 
        /* temporarily make it look not-updated, but locked */
        oldtup.t_data->t_ctid = oldtup.t_self;
 
        /*
         * Clear all-frozen bit on visibility map if needed. We could
         * immediately reset ALL_VISIBLE, but given that the WAL logging
         * overhead would be unchanged, that doesn't seem necessarily
         * worthwhile.
         */
        if (PageIsAllVisible(page) &&
            visibilitymap_clear(relation, block, vmbuffer,
                                VISIBILITYMAP_ALL_FROZEN))
            cleared_all_frozen = true;
 
        MarkBufferDirty(buffer);
 
        if (RelationNeedsWAL(relation))
        {
            xl_heap_lock xlrec;
            XLogRecPtr  recptr;
 
            XLogBeginInsert();
            XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
            xlrec.offnum = ItemPointerGetOffsetNumber(&oldtup.t_self);
            xlrec.xmax = xmax_lock_old_tuple;
            xlrec.infobits_set = compute_infobits(oldtup.t_data->t_infomask,
                                                  oldtup.t_data->t_infomask2);
            xlrec.flags =
                cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
            XLogRegisterData(&xlrec, SizeOfHeapLock);
            recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_LOCK);
            PageSetLSN(page, recptr);
        }
 
        END_CRIT_SECTION();
 
        LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
        /*
         * Let the toaster do its thing, if needed.
         *
         * Note: below this point, heaptup is the data we actually intend to
         * store into the relation; newtup is the caller's original untoasted
         * data.
         */
        if (need_toast)
        {
            /* Note we always use WAL and FSM during updates */
            heaptup = heap_toast_insert_or_update(relation, newtup, &oldtup, 0);
            newtupsize = MAXALIGN(heaptup->t_len);
        }
        else
            heaptup = newtup;
 
        /*
         * Now, do we need a new page for the tuple, or not?  This is a bit
         * tricky since someone else could have added tuples to the page while
         * we weren't looking.  We have to recheck the available space after
         * reacquiring the buffer lock.  But don't bother to do that if the
         * former amount of free space is still not enough; it's unlikely
         * there's more free now than before.
         *
         * What's more, if we need to get a new page, we will need to acquire
         * buffer locks on both old and new pages.  To avoid deadlock against
         * some other backend trying to get the same two locks in the other
         * order, we must be consistent about the order we get the locks in.
         * We use the rule "lock the lower-numbered page of the relation
         * first".  To implement this, we must do RelationGetBufferForTuple
         * while not holding the lock on the old page, and we must rely on it
         * to get the locks on both pages in the correct order.
         *
         * Another consideration is that we need visibility map page pin(s) if
         * we will have to clear the all-visible flag on either page.  If we
         * call RelationGetBufferForTuple, we rely on it to acquire any such
         * pins; but if we don't, we have to handle that here.  Hence we need
         * a loop.
         */
        for (;;)
        {
            if (newtupsize > pagefree)
            {
                /* It doesn't fit, must use RelationGetBufferForTuple. */
                newbuf = RelationGetBufferForTuple(relation, heaptup->t_len,
                                                   buffer, 0, NULL,
                                                   &vmbuffer_new, &vmbuffer,
                                                   0);
                /* We're all done. */
                break;
            }
            /* Acquire VM page pin if needed and we don't have it. */
            if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
                visibilitymap_pin(relation, block, &vmbuffer);
            /* Re-acquire the lock on the old tuple's page. */
            LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
            /* Re-check using the up-to-date free space */
            pagefree = PageGetHeapFreeSpace(page);
            if (newtupsize > pagefree ||
                (vmbuffer == InvalidBuffer && PageIsAllVisible(page)))
            {
                /*
                 * Rats, it doesn't fit anymore, or somebody just now set the
                 * all-visible flag.  We must now unlock and loop to avoid
                 * deadlock.  Fortunately, this path should seldom be taken.
                 */
                LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            }
            else
            {
                /* We're all done. */
                newbuf = buffer;
                break;
            }
        }
    }
    else
    {
        /* No TOAST work needed, and it'll fit on same page */
        newbuf = buffer;
        heaptup = newtup;
    }
 
    /*
     * We're about to do the actual update -- 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 pages between this check and the update
     * being visible to the scan (i.e., exclusive buffer content lock(s) are
     * continuously held from this point until the tuple update is visible).
     *
     * For the new tuple the only check needed is at the relation level, but
     * since both tuples are in the same relation and the check for oldtup
     * will include checking the relation level, there is no benefit to a
     * separate check for the new tuple.
     */
    CheckForSerializableConflictIn(relation, &oldtup.t_self,
                                   BufferGetBlockNumber(buffer));
 
    /*
     * At this point newbuf and buffer are both pinned and locked, and newbuf
     * has enough space for the new tuple.  If they are the same buffer, only
     * one pin is held.
     */
 
    if (newbuf == buffer)
    {
        /*
         * Since the new tuple is going into the same page, we might be able
         * to do a HOT update.  Check if any of the index columns have been
         * changed.
         */
        if (!bms_overlap(modified_attrs, hot_attrs))
        {
            use_hot_update = true;
 
            /*
             * If none of the columns that are used in hot-blocking indexes
             * were updated, we can apply HOT, but we do still need to check
             * if we need to update the summarizing indexes, and update those
             * indexes if the columns were updated, or we may fail to detect
             * e.g. value bound changes in BRIN minmax indexes.
             */
            if (bms_overlap(modified_attrs, sum_attrs))
                summarized_update = true;
        }
    }
    else
    {
        /* Set a hint that the old page could use prune/defrag */
        PageSetFull(page);
    }
 
    /*
     * Compute replica identity tuple before entering the critical section so
     * we don't PANIC upon a memory allocation failure.
     * ExtractReplicaIdentity() will return NULL if nothing needs to be
     * logged.  Pass old key required as true only if the replica identity key
     * columns are modified or it has external data.
     */
    old_key_tuple = ExtractReplicaIdentity(relation, &oldtup,
                                           bms_overlap(modified_attrs, id_attrs) ||
                                           id_has_external,
                                           &old_key_copied);
 
    /* NO EREPORT(ERROR) from here till changes are logged */
    START_CRIT_SECTION();
 
    /*
     * If this transaction commits, the old 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.
     *
     * XXX Should we set hint on newbuf as well?  If the transaction aborts,
     * there would be a prunable tuple in the newbuf; but for now we choose
     * not to optimize for aborts.  Note that heap_xlog_update must be kept in
     * sync if this decision changes.
     */
    PageSetPrunable(page, xid);
 
    if (use_hot_update)
    {
        /* Mark the old tuple as HOT-updated */
        HeapTupleSetHotUpdated(&oldtup);
        /* And mark the new tuple as heap-only */
        HeapTupleSetHeapOnly(heaptup);
        /* Mark the caller's copy too, in case different from heaptup */
        HeapTupleSetHeapOnly(newtup);
    }
    else
    {
        /* Make sure tuples are correctly marked as not-HOT */
        HeapTupleClearHotUpdated(&oldtup);
        HeapTupleClearHeapOnly(heaptup);
        HeapTupleClearHeapOnly(newtup);
    }
 
    RelationPutHeapTuple(relation, newbuf, heaptup, false); /* insert new tuple */
 
 
    /* Clear obsolete visibility flags, possibly set by ourselves above... */
    oldtup.t_data->t_infomask &= ~(HEAP_XMAX_BITS | HEAP_MOVED);
    oldtup.t_data->t_infomask2 &= ~HEAP_KEYS_UPDATED;
    /* ... and store info about transaction updating this tuple */
    Assert(TransactionIdIsValid(xmax_old_tuple));
    HeapTupleHeaderSetXmax(oldtup.t_data, xmax_old_tuple);
    oldtup.t_data->t_infomask |= infomask_old_tuple;
    oldtup.t_data->t_infomask2 |= infomask2_old_tuple;
    HeapTupleHeaderSetCmax(oldtup.t_data, cid, iscombo);
 
    /* record address of new tuple in t_ctid of old one */
    oldtup.t_data->t_ctid = heaptup->t_self;
 
    /* clear PD_ALL_VISIBLE flags, reset all visibilitymap bits */
    if (PageIsAllVisible(BufferGetPage(buffer)))
    {
        all_visible_cleared = true;
        PageClearAllVisible(BufferGetPage(buffer));
        visibilitymap_clear(relation, BufferGetBlockNumber(buffer),
                            vmbuffer, VISIBILITYMAP_VALID_BITS);
    }
    if (newbuf != buffer && PageIsAllVisible(BufferGetPage(newbuf)))
    {
        all_visible_cleared_new = true;
        PageClearAllVisible(BufferGetPage(newbuf));
        visibilitymap_clear(relation, BufferGetBlockNumber(newbuf),
                            vmbuffer_new, VISIBILITYMAP_VALID_BITS);
    }
 
    if (newbuf != buffer)
        MarkBufferDirty(newbuf);
    MarkBufferDirty(buffer);
 
    /* XLOG stuff */
    if (RelationNeedsWAL(relation))
    {
        XLogRecPtr  recptr;
 
        /*
         * For logical decoding we need combo CIDs to properly decode the
         * catalog.
         */
        if (RelationIsAccessibleInLogicalDecoding(relation))
        {
            log_heap_new_cid(relation, &oldtup);
            log_heap_new_cid(relation, heaptup);
        }
 
        recptr = log_heap_update(relation, buffer,
                                 newbuf, &oldtup, heaptup,
                                 old_key_tuple,
                                 all_visible_cleared,
                                 all_visible_cleared_new);
        if (newbuf != buffer)
        {
            PageSetLSN(BufferGetPage(newbuf), recptr);
        }
        PageSetLSN(BufferGetPage(buffer), recptr);
    }
 
    END_CRIT_SECTION();
 
    if (newbuf != buffer)
        LockBuffer(newbuf, BUFFER_LOCK_UNLOCK);
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
    /*
     * Mark old tuple for invalidation from system caches at next command
     * boundary, and mark the new tuple for invalidation in case we abort. We
     * have to do this before releasing the buffer because oldtup is in the
     * buffer.  (heaptup is all in local memory, but it's necessary to process
     * both tuple versions in one call to inval.c so we can avoid redundant
     * sinval messages.)
     */
    CacheInvalidateHeapTuple(relation, &oldtup, heaptup);
 
    /* Now we can release the buffer(s) */
    if (newbuf != buffer)
        ReleaseBuffer(newbuf);
    ReleaseBuffer(buffer);
    if (BufferIsValid(vmbuffer_new))
        ReleaseBuffer(vmbuffer_new);
    if (BufferIsValid(vmbuffer))
        ReleaseBuffer(vmbuffer);
 
    /*
     * Release the lmgr tuple lock, if we had it.
     */
    if (have_tuple_lock)
        UnlockTupleTuplock(relation, &(oldtup.t_self), *lockmode);
 
    pgstat_count_heap_update(relation, use_hot_update, newbuf != buffer);
 
    /*
     * If heaptup is a private copy, release it.  Don't forget to copy t_self
     * back to the caller's image, too.
     */
    if (heaptup != newtup)
    {
        newtup->t_self = heaptup->t_self;
        heap_freetuple(heaptup);
    }
 
    /*
     * If it is a HOT update, the update may still need to update summarized
     * indexes, lest we fail to update those summaries and get incorrect
     * results (for example, minmax bounds of the block may change with this
     * update).
     */
    if (use_hot_update)
    {
        if (summarized_update)
            *update_indexes = TU_Summarizing;
        else
            *update_indexes = TU_None;
    }
    else
        *update_indexes = TU_All;
 
    if (old_key_tuple != NULL && old_key_copied)
        heap_freetuple(old_key_tuple);
 
    bms_free(hot_attrs);
    bms_free(sum_attrs);
    bms_free(key_attrs);
    bms_free(id_attrs);
    bms_free(modified_attrs);
    bms_free(interesting_attrs);
 
    return TM_Ok;
}

References Assert(), bms_add_members(), bms_free(), bms_overlap(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), 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_lock::flags, GetCurrentTransactionId(), GetMultiXactIdHintBits(), HEAP2_XACT_MASK, heap_acquire_tuplock(), heap_freetuple(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED, heap_toast_insert_or_update(), HEAP_UPDATED, HEAP_XACT_MASK, HEAP_XMAX_BITS, HEAP_XMAX_INVALID, HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMAX_KEYSHR_LOCK, HEAP_XMAX_LOCK_ONLY, HeapDetermineColumnsInfo(), HeapTupleClearHeapOnly(), HeapTupleClearHotUpdated(), HeapTupleGetUpdateXid(), HeapTupleHasExternal(), HeapTupleHeaderAdjustCmax(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetNatts, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderSetCmax(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), HeapTupleSatisfiesUpdate(), HeapTupleSatisfiesVisibility(), HeapTupleSetHeapOnly(), HeapTupleSetHotUpdated(), INDEX_ATTR_BITMAP_HOT_BLOCKING, INDEX_ATTR_BITMAP_IDENTITY_KEY, INDEX_ATTR_BITMAP_KEY, INDEX_ATTR_BITMAP_SUMMARIZED, xl_heap_lock::infobits_set, INJECTION_POINT, InvalidBuffer, InvalidCommandId, InvalidSnapshot, InvalidTransactionId, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockTupleNoKeyExclusive, LockWaitBlock, log_heap_new_cid(), log_heap_update(), MarkBufferDirty(), MAXALIGN, MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, MultiXactStatusUpdate, xl_heap_lock::offnum, PageClearAllVisible(), PageGetHeapFreeSpace(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetFull(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_update(), RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetBufferForTuple(), RelationGetIndexAttrBitmap(), RelationGetNumberOfAttributes, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, RelationPutHeapTuple(), RelationSupportsSysCache(), ReleaseBuffer(), SizeOfHeapLock, START_CRIT_SECTION, 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, TOAST_TUPLE_THRESHOLD, TransactionIdDidAbort(), TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TransactionIdIsValid, TU_All, TU_None, TU_Summarizing, UnlockReleaseBuffer(), UnlockTupleTuplock, UpdateXmaxHintBits(), VISIBILITYMAP_ALL_FROZEN, visibilitymap_clear(), visibilitymap_pin(), VISIBILITYMAP_VALID_BITS, XactLockTableWait(), XLH_LOCK_ALL_FROZEN_CLEARED, XLOG_HEAP_LOCK, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLTW_Update, xl_heap_lock::xmax, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_update(), and simple_heap_update().

heap_vacuum_rel()

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

Definition at line 615 of file vacuumlazy.c.

{
    LVRelState *vacrel;
    bool        verbose,
                instrument,
                skipwithvm,
                frozenxid_updated,
                minmulti_updated;
    BlockNumber orig_rel_pages,
                new_rel_pages,
                new_rel_allvisible,
                new_rel_allfrozen;
    PGRUsage    ru0;
    TimestampTz starttime = 0;
    PgStat_Counter startreadtime = 0,
                startwritetime = 0;
    WalUsage    startwalusage = pgWalUsage;
    BufferUsage startbufferusage = pgBufferUsage;
    ErrorContextCallback errcallback;
    char      **indnames = NULL;
 
    verbose = (params->options & VACOPT_VERBOSE) != 0;
    instrument = (verbose || (AmAutoVacuumWorkerProcess() &&
                              params->log_min_duration >= 0));
    if (instrument)
    {
        pg_rusage_init(&ru0);
        if (track_io_timing)
        {
            startreadtime = pgStatBlockReadTime;
            startwritetime = pgStatBlockWriteTime;
        }
    }
 
    /* Used for instrumentation and stats report */
    starttime = GetCurrentTimestamp();
 
    pgstat_progress_start_command(PROGRESS_COMMAND_VACUUM,
                                  RelationGetRelid(rel));
 
    /*
     * Setup error traceback support for ereport() first.  The idea is to set
     * up an error context callback to display additional information on any
     * error during a vacuum.  During different phases of vacuum, we update
     * the state so that the error context callback always display current
     * information.
     *
     * Copy the names of heap rel into local memory for error reporting
     * purposes, too.  It isn't always safe to assume that we can get the name
     * of each rel.  It's convenient for code in lazy_scan_heap to always use
     * these temp copies.
     */
    vacrel = (LVRelState *) palloc0(sizeof(LVRelState));
    vacrel->dbname = get_database_name(MyDatabaseId);
    vacrel->relnamespace = get_namespace_name(RelationGetNamespace(rel));
    vacrel->relname = pstrdup(RelationGetRelationName(rel));
    vacrel->indname = NULL;
    vacrel->phase = VACUUM_ERRCB_PHASE_UNKNOWN;
    vacrel->verbose = verbose;
    errcallback.callback = vacuum_error_callback;
    errcallback.arg = vacrel;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /* Set up high level stuff about rel and its indexes */
    vacrel->rel = rel;
    vac_open_indexes(vacrel->rel, RowExclusiveLock, &vacrel->nindexes,
                     &vacrel->indrels);
    vacrel->bstrategy = bstrategy;
    if (instrument && vacrel->nindexes > 0)
    {
        /* Copy index names used by instrumentation (not error reporting) */
        indnames = palloc(sizeof(char *) * vacrel->nindexes);
        for (int i = 0; i < vacrel->nindexes; i++)
            indnames[i] = pstrdup(RelationGetRelationName(vacrel->indrels[i]));
    }
 
    /*
     * The index_cleanup param either disables index vacuuming and cleanup or
     * forces it to go ahead when we would otherwise apply the index bypass
     * optimization.  The default is 'auto', which leaves the final decision
     * up to lazy_vacuum().
     *
     * The truncate param allows user to avoid attempting relation truncation,
     * though it can't force truncation to happen.
     */
    Assert(params->index_cleanup != VACOPTVALUE_UNSPECIFIED);
    Assert(params->truncate != VACOPTVALUE_UNSPECIFIED &&
           params->truncate != VACOPTVALUE_AUTO);
 
    /*
     * While VacuumFailSafeActive is reset to false before calling this, we
     * still need to reset it here due to recursive calls.
     */
    VacuumFailsafeActive = false;
    vacrel->consider_bypass_optimization = true;
    vacrel->do_index_vacuuming = true;
    vacrel->do_index_cleanup = true;
    vacrel->do_rel_truncate = (params->truncate != VACOPTVALUE_DISABLED);
    if (params->index_cleanup == VACOPTVALUE_DISABLED)
    {
        /* Force disable index vacuuming up-front */
        vacrel->do_index_vacuuming = false;
        vacrel->do_index_cleanup = false;
    }
    else if (params->index_cleanup == VACOPTVALUE_ENABLED)
    {
        /* Force index vacuuming.  Note that failsafe can still bypass. */
        vacrel->consider_bypass_optimization = false;
    }
    else
    {
        /* Default/auto, make all decisions dynamically */
        Assert(params->index_cleanup == VACOPTVALUE_AUTO);
    }
 
    /* Initialize page counters explicitly (be tidy) */
    vacrel->scanned_pages = 0;
    vacrel->eager_scanned_pages = 0;
    vacrel->removed_pages = 0;
    vacrel->new_frozen_tuple_pages = 0;
    vacrel->lpdead_item_pages = 0;
    vacrel->missed_dead_pages = 0;
    vacrel->nonempty_pages = 0;
    /* dead_items_alloc allocates vacrel->dead_items later on */
 
    /* Allocate/initialize output statistics state */
    vacrel->new_rel_tuples = 0;
    vacrel->new_live_tuples = 0;
    vacrel->indstats = (IndexBulkDeleteResult **)
        palloc0(vacrel->nindexes * sizeof(IndexBulkDeleteResult *));
 
    /* Initialize remaining counters (be tidy) */
    vacrel->num_index_scans = 0;
    vacrel->tuples_deleted = 0;
    vacrel->tuples_frozen = 0;
    vacrel->lpdead_items = 0;
    vacrel->live_tuples = 0;
    vacrel->recently_dead_tuples = 0;
    vacrel->missed_dead_tuples = 0;
 
    vacrel->vm_new_visible_pages = 0;
    vacrel->vm_new_visible_frozen_pages = 0;
    vacrel->vm_new_frozen_pages = 0;
    vacrel->rel_pages = orig_rel_pages = RelationGetNumberOfBlocks(rel);
 
    /*
     * Get cutoffs that determine which deleted tuples are considered DEAD,
     * not just RECENTLY_DEAD, and which XIDs/MXIDs to freeze.  Then determine
     * the extent of the blocks that we'll scan in lazy_scan_heap.  It has to
     * happen in this order to ensure that the OldestXmin cutoff field works
     * as an upper bound on the XIDs stored in the pages we'll actually scan
     * (NewRelfrozenXid tracking must never be allowed to miss unfrozen XIDs).
     *
     * Next acquire vistest, a related cutoff that's used in pruning.  We use
     * vistest in combination with OldestXmin to ensure that
     * heap_page_prune_and_freeze() always removes any deleted tuple whose
     * xmax is < OldestXmin.  lazy_scan_prune must never become confused about
     * whether a tuple should be frozen or removed.  (In the future we might
     * want to teach lazy_scan_prune to recompute vistest from time to time,
     * to increase the number of dead tuples it can prune away.)
     */
    vacrel->aggressive = vacuum_get_cutoffs(rel, params, &vacrel->cutoffs);
    vacrel->vistest = GlobalVisTestFor(rel);
    /* Initialize state used to track oldest extant XID/MXID */
    vacrel->NewRelfrozenXid = vacrel->cutoffs.OldestXmin;
    vacrel->NewRelminMxid = vacrel->cutoffs.OldestMxact;
 
    /*
     * Initialize state related to tracking all-visible page skipping. This is
     * very important to determine whether or not it is safe to advance the
     * relfrozenxid/relminmxid.
     */
    vacrel->skippedallvis = false;
    skipwithvm = true;
    if (params->options & VACOPT_DISABLE_PAGE_SKIPPING)
    {
        /*
         * Force aggressive mode, and disable skipping blocks using the
         * visibility map (even those set all-frozen)
         */
        vacrel->aggressive = true;
        skipwithvm = false;
    }
 
    vacrel->skipwithvm = skipwithvm;
 
    /*
     * Set up eager scan tracking state. This must happen after determining
     * whether or not the vacuum must be aggressive, because only normal
     * vacuums use the eager scan algorithm.
     */
    heap_vacuum_eager_scan_setup(vacrel, params);
 
    if (verbose)
    {
        if (vacrel->aggressive)
            ereport(INFO,
                    (errmsg("aggressively vacuuming \"%s.%s.%s\"",
                            vacrel->dbname, vacrel->relnamespace,
                            vacrel->relname)));
        else
            ereport(INFO,
                    (errmsg("vacuuming \"%s.%s.%s\"",
                            vacrel->dbname, vacrel->relnamespace,
                            vacrel->relname)));
    }
 
    /*
     * Allocate dead_items memory using dead_items_alloc.  This handles
     * parallel VACUUM initialization as part of allocating shared memory
     * space used for dead_items.  (But do a failsafe precheck first, to
     * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
     * is already dangerously old.)
     */
    lazy_check_wraparound_failsafe(vacrel);
    dead_items_alloc(vacrel, params->nworkers);
 
    /*
     * Call lazy_scan_heap to perform all required heap pruning, index
     * vacuuming, and heap vacuuming (plus related processing)
     */
    lazy_scan_heap(vacrel);
 
    /*
     * Free resources managed by dead_items_alloc.  This ends parallel mode in
     * passing when necessary.
     */
    dead_items_cleanup(vacrel);
    Assert(!IsInParallelMode());
 
    /*
     * Update pg_class entries for each of rel's indexes where appropriate.
     *
     * Unlike the later update to rel's pg_class entry, this is not critical.
     * Maintains relpages/reltuples statistics used by the planner only.
     */
    if (vacrel->do_index_cleanup)
        update_relstats_all_indexes(vacrel);
 
    /* Done with rel's indexes */
    vac_close_indexes(vacrel->nindexes, vacrel->indrels, NoLock);
 
    /* Optionally truncate rel */
    if (should_attempt_truncation(vacrel))
        lazy_truncate_heap(vacrel);
 
    /* Pop the error context stack */
    error_context_stack = errcallback.previous;
 
    /* Report that we are now doing final cleanup */
    pgstat_progress_update_param(PROGRESS_VACUUM_PHASE,
                                 PROGRESS_VACUUM_PHASE_FINAL_CLEANUP);
 
    /*
     * Prepare to update rel's pg_class entry.
     *
     * Aggressive VACUUMs must always be able to advance relfrozenxid to a
     * value >= FreezeLimit, and relminmxid to a value >= MultiXactCutoff.
     * Non-aggressive VACUUMs may advance them by any amount, or not at all.
     */
    Assert(vacrel->NewRelfrozenXid == vacrel->cutoffs.OldestXmin ||
           TransactionIdPrecedesOrEquals(vacrel->aggressive ? vacrel->cutoffs.FreezeLimit :
                                         vacrel->cutoffs.relfrozenxid,
                                         vacrel->NewRelfrozenXid));
    Assert(vacrel->NewRelminMxid == vacrel->cutoffs.OldestMxact ||
           MultiXactIdPrecedesOrEquals(vacrel->aggressive ? vacrel->cutoffs.MultiXactCutoff :
                                       vacrel->cutoffs.relminmxid,
                                       vacrel->NewRelminMxid));
    if (vacrel->skippedallvis)
    {
        /*
         * Must keep original relfrozenxid in a non-aggressive VACUUM that
         * chose to skip an all-visible page range.  The state that tracks new
         * values will have missed unfrozen XIDs from the pages we skipped.
         */
        Assert(!vacrel->aggressive);
        vacrel->NewRelfrozenXid = InvalidTransactionId;
        vacrel->NewRelminMxid = InvalidMultiXactId;
    }
 
    /*
     * For safety, clamp relallvisible to be not more than what we're setting
     * pg_class.relpages to
     */
    new_rel_pages = vacrel->rel_pages;  /* After possible rel truncation */
    visibilitymap_count(rel, &new_rel_allvisible, &new_rel_allfrozen);
    if (new_rel_allvisible > new_rel_pages)
        new_rel_allvisible = new_rel_pages;
 
    /*
     * An all-frozen block _must_ be all-visible. As such, clamp the count of
     * all-frozen blocks to the count of all-visible blocks. This matches the
     * clamping of relallvisible above.
     */
    if (new_rel_allfrozen > new_rel_allvisible)
        new_rel_allfrozen = new_rel_allvisible;
 
    /*
     * Now actually update rel's pg_class entry.
     *
     * In principle new_live_tuples could be -1 indicating that we (still)
     * don't know the tuple count.  In practice that can't happen, since we
     * scan every page that isn't skipped using the visibility map.
     */
    vac_update_relstats(rel, new_rel_pages, vacrel->new_live_tuples,
                        new_rel_allvisible, new_rel_allfrozen,
                        vacrel->nindexes > 0,
                        vacrel->NewRelfrozenXid, vacrel->NewRelminMxid,
                        &frozenxid_updated, &minmulti_updated, false);
 
    /*
     * Report results to the cumulative stats system, too.
     *
     * Deliberately avoid telling the stats system about LP_DEAD items that
     * remain in the table due to VACUUM bypassing index and heap vacuuming.
     * ANALYZE will consider the remaining LP_DEAD items to be dead "tuples".
     * It seems like a good idea to err on the side of not vacuuming again too
     * soon in cases where the failsafe prevented significant amounts of heap
     * vacuuming.
     */
    pgstat_report_vacuum(RelationGetRelid(rel),
                         rel->rd_rel->relisshared,
                         Max(vacrel->new_live_tuples, 0),
                         vacrel->recently_dead_tuples +
                         vacrel->missed_dead_tuples,
                         starttime);
    pgstat_progress_end_command();
 
    if (instrument)
    {
        TimestampTz endtime = GetCurrentTimestamp();
 
        if (verbose || params->log_min_duration == 0 ||
            TimestampDifferenceExceeds(starttime, endtime,
                                       params->log_min_duration))
        {
            long        secs_dur;
            int         usecs_dur;
            WalUsage    walusage;
            BufferUsage bufferusage;
            StringInfoData buf;
            char       *msgfmt;
            int32       diff;
            double      read_rate = 0,
                        write_rate = 0;
            int64       total_blks_hit;
            int64       total_blks_read;
            int64       total_blks_dirtied;
 
            TimestampDifference(starttime, endtime, &secs_dur, &usecs_dur);
            memset(&walusage, 0, sizeof(WalUsage));
            WalUsageAccumDiff(&walusage, &pgWalUsage, &startwalusage);
            memset(&bufferusage, 0, sizeof(BufferUsage));
            BufferUsageAccumDiff(&bufferusage, &pgBufferUsage, &startbufferusage);
 
            total_blks_hit = bufferusage.shared_blks_hit +
                bufferusage.local_blks_hit;
            total_blks_read = bufferusage.shared_blks_read +
                bufferusage.local_blks_read;
            total_blks_dirtied = bufferusage.shared_blks_dirtied +
                bufferusage.local_blks_dirtied;
 
            initStringInfo(&buf);
            if (verbose)
            {
                /*
                 * Aggressiveness already reported earlier, in dedicated
                 * VACUUM VERBOSE ereport
                 */
                Assert(!params->is_wraparound);
                msgfmt = _("finished vacuuming \"%s.%s.%s\": index scans: %d\n");
            }
            else if (params->is_wraparound)
            {
                /*
                 * While it's possible for a VACUUM to be both is_wraparound
                 * and !aggressive, that's just a corner-case -- is_wraparound
                 * implies aggressive.  Produce distinct output for the corner
                 * case all the same, just in case.
                 */
                if (vacrel->aggressive)
                    msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
                else
                    msgfmt = _("automatic vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
            }
            else
            {
                if (vacrel->aggressive)
                    msgfmt = _("automatic aggressive vacuum of table \"%s.%s.%s\": index scans: %d\n");
                else
                    msgfmt = _("automatic vacuum of table \"%s.%s.%s\": index scans: %d\n");
            }
            appendStringInfo(&buf, msgfmt,
                             vacrel->dbname,
                             vacrel->relnamespace,
                             vacrel->relname,
                             vacrel->num_index_scans);
            appendStringInfo(&buf, _("pages: %u removed, %u remain, %u scanned (%.2f%% of total), %u eagerly scanned\n"),
                             vacrel->removed_pages,
                             new_rel_pages,
                             vacrel->scanned_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->scanned_pages /
                             orig_rel_pages,
                             vacrel->eager_scanned_pages);
            appendStringInfo(&buf,
                             _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
                             vacrel->tuples_deleted,
                             (int64) vacrel->new_rel_tuples,
                             vacrel->recently_dead_tuples);
            if (vacrel->missed_dead_tuples > 0)
                appendStringInfo(&buf,
                                 _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
                                 vacrel->missed_dead_tuples,
                                 vacrel->missed_dead_pages);
            diff = (int32) (ReadNextTransactionId() -
                            vacrel->cutoffs.OldestXmin);
            appendStringInfo(&buf,
                             _("removable cutoff: %u, which was %d XIDs old when operation ended\n"),
                             vacrel->cutoffs.OldestXmin, diff);
            if (frozenxid_updated)
            {
                diff = (int32) (vacrel->NewRelfrozenXid -
                                vacrel->cutoffs.relfrozenxid);
                appendStringInfo(&buf,
                                 _("new relfrozenxid: %u, which is %d XIDs ahead of previous value\n"),
                                 vacrel->NewRelfrozenXid, diff);
            }
            if (minmulti_updated)
            {
                diff = (int32) (vacrel->NewRelminMxid -
                                vacrel->cutoffs.relminmxid);
                appendStringInfo(&buf,
                                 _("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
                                 vacrel->NewRelminMxid, diff);
            }
            appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
                             vacrel->new_frozen_tuple_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->new_frozen_tuple_pages /
                             orig_rel_pages,
                             vacrel->tuples_frozen);
 
            appendStringInfo(&buf,
                             _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
                             vacrel->vm_new_visible_pages,
                             vacrel->vm_new_visible_frozen_pages +
                             vacrel->vm_new_frozen_pages,
                             vacrel->vm_new_frozen_pages);
            if (vacrel->do_index_vacuuming)
            {
                if (vacrel->nindexes == 0 || vacrel->num_index_scans == 0)
                    appendStringInfoString(&buf, _("index scan not needed: "));
                else
                    appendStringInfoString(&buf, _("index scan needed: "));
 
                msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
            }
            else
            {
                if (!VacuumFailsafeActive)
                    appendStringInfoString(&buf, _("index scan bypassed: "));
                else
                    appendStringInfoString(&buf, _("index scan bypassed by failsafe: "));
 
                msgfmt = _("%u pages from table (%.2f%% of total) have %" PRId64 " dead item identifiers\n");
            }
            appendStringInfo(&buf, msgfmt,
                             vacrel->lpdead_item_pages,
                             orig_rel_pages == 0 ? 100.0 :
                             100.0 * vacrel->lpdead_item_pages / orig_rel_pages,
                             vacrel->lpdead_items);
            for (int i = 0; i < vacrel->nindexes; i++)
            {
                IndexBulkDeleteResult *istat = vacrel->indstats[i];
 
                if (!istat)
                    continue;
 
                appendStringInfo(&buf,
                                 _("index \"%s\": pages: %u in total, %u newly deleted, %u currently deleted, %u reusable\n"),
                                 indnames[i],
                                 istat->num_pages,
                                 istat->pages_newly_deleted,
                                 istat->pages_deleted,
                                 istat->pages_free);
            }
            if (track_cost_delay_timing)
            {
                /*
                 * We bypass the changecount mechanism because this value is
                 * only updated by the calling process.  We also rely on the
                 * above call to pgstat_progress_end_command() to not clear
                 * the st_progress_param array.
                 */
                appendStringInfo(&buf, _("delay time: %.3f ms\n"),
                                 (double) MyBEEntry->st_progress_param[PROGRESS_VACUUM_DELAY_TIME] / 1000000.0);
            }
            if (track_io_timing)
            {
                double      read_ms = (double) (pgStatBlockReadTime - startreadtime) / 1000;
                double      write_ms = (double) (pgStatBlockWriteTime - startwritetime) / 1000;
 
                appendStringInfo(&buf, _("I/O timings: read: %.3f ms, write: %.3f ms\n"),
                                 read_ms, write_ms);
            }
            if (secs_dur > 0 || usecs_dur > 0)
            {
                read_rate = (double) BLCKSZ * total_blks_read /
                    (1024 * 1024) / (secs_dur + usecs_dur / 1000000.0);
                write_rate = (double) BLCKSZ * total_blks_dirtied /
                    (1024 * 1024) / (secs_dur + usecs_dur / 1000000.0);
            }
            appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
                             read_rate, write_rate);
            appendStringInfo(&buf,
                             _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
                             total_blks_hit,
                             total_blks_read,
                             total_blks_dirtied);
            appendStringInfo(&buf,
                             _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
                             walusage.wal_records,
                             walusage.wal_fpi,
                             walusage.wal_bytes,
                             walusage.wal_buffers_full);
            appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
 
            ereport(verbose ? INFO : LOG,
                    (errmsg_internal("%s", buf.data)));
            pfree(buf.data);
        }
    }
 
    /* Cleanup index statistics and index names */
    for (int i = 0; i < vacrel->nindexes; i++)
    {
        if (vacrel->indstats[i])
            pfree(vacrel->indstats[i]);
 
        if (instrument)
            pfree(indnames[i]);
    }
}

References _, LVRelState::aggressive, AmAutoVacuumWorkerProcess, appendStringInfo(), appendStringInfoString(), ErrorContextCallback::arg, Assert(), LVRelState::bstrategy, buf, BufferUsageAccumDiff(), ErrorContextCallback::callback, LVRelState::consider_bypass_optimization, LVRelState::cutoffs, LVRelState::dbname, dead_items_alloc(), dead_items_cleanup(), LVRelState::do_index_cleanup, LVRelState::do_index_vacuuming, LVRelState::do_rel_truncate, LVRelState::eager_scanned_pages, ereport, errmsg(), errmsg_internal(), error_context_stack, VacuumCutoffs::FreezeLimit, get_database_name(), get_namespace_name(), GetCurrentTimestamp(), GlobalVisTestFor(), heap_vacuum_eager_scan_setup(), i, VacuumParams::index_cleanup, LVRelState::indname, LVRelState::indrels, LVRelState::indstats, INFO, initStringInfo(), InvalidMultiXactId, InvalidTransactionId, VacuumParams::is_wraparound, IsInParallelMode(), lazy_check_wraparound_failsafe(), lazy_scan_heap(), lazy_truncate_heap(), LVRelState::live_tuples, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, LOG, VacuumParams::log_min_duration, LVRelState::lpdead_item_pages, LVRelState::lpdead_items, Max, LVRelState::missed_dead_pages, LVRelState::missed_dead_tuples, VacuumCutoffs::MultiXactCutoff, MultiXactIdPrecedesOrEquals(), MyBEEntry, MyDatabaseId, LVRelState::new_frozen_tuple_pages, LVRelState::new_live_tuples, LVRelState::new_rel_tuples, LVRelState::NewRelfrozenXid, LVRelState::NewRelminMxid, LVRelState::nindexes, NoLock, LVRelState::nonempty_pages, LVRelState::num_index_scans, IndexBulkDeleteResult::num_pages, VacuumParams::nworkers, VacuumCutoffs::OldestMxact, VacuumCutoffs::OldestXmin, VacuumParams::options, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, palloc(), palloc0(), pfree(), pg_rusage_init(), pg_rusage_show(), pgBufferUsage, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), pgstat_report_vacuum(), pgStatBlockReadTime, pgStatBlockWriteTime, pgWalUsage, LVRelState::phase, ErrorContextCallback::previous, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_DELAY_TIME, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, pstrdup(), RelationData::rd_rel, ReadNextTransactionId(), LVRelState::recently_dead_tuples, LVRelState::rel, LVRelState::rel_pages, RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, VacuumCutoffs::relfrozenxid, VacuumCutoffs::relminmxid, LVRelState::relname, LVRelState::relnamespace, LVRelState::removed_pages, RowExclusiveLock, LVRelState::scanned_pages, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, should_attempt_truncation(), LVRelState::skippedallvis, LVRelState::skipwithvm, PgBackendStatus::st_progress_param, TimestampDifference(), TimestampDifferenceExceeds(), track_cost_delay_timing, track_io_timing, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, LVRelState::tuples_deleted, LVRelState::tuples_frozen, update_relstats_all_indexes(), vac_close_indexes(), vac_open_indexes(), vac_update_relstats(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_VERBOSE, VACOPTVALUE_AUTO, VACOPTVALUE_DISABLED, VACOPTVALUE_ENABLED, VACOPTVALUE_UNSPECIFIED, VACUUM_ERRCB_PHASE_UNKNOWN, vacuum_error_callback(), vacuum_get_cutoffs(), VacuumFailsafeActive, LVRelState::verbose, verbose, visibilitymap_count(), LVRelState::vistest, LVRelState::vm_new_frozen_pages, LVRelState::vm_new_visible_frozen_pages, LVRelState::vm_new_visible_pages, WalUsage::wal_buffers_full, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_records, and WalUsageAccumDiff().

HeapCheckForSerializableConflictOut()

void HeapCheckForSerializableConflictOut	(	bool	visible,
		Relation	relation,
		HeapTuple	tuple,
		Buffer	buffer,
		Snapshot	snapshot
	)

Definition at line 9209 of file heapam.c.

{
    TransactionId xid;
    HTSV_Result htsvResult;
 
    if (!CheckForSerializableConflictOutNeeded(relation, snapshot))
        return;
 
    /*
     * Check to see whether the tuple has been written to by a concurrent
     * transaction, either to create it not visible to us, or to delete it
     * while it is visible to us.  The "visible" bool indicates whether the
     * tuple is visible to us, while HeapTupleSatisfiesVacuum checks what else
     * is going on with it.
     *
     * In the event of a concurrently inserted tuple that also happens to have
     * been concurrently updated (by a separate transaction), the xmin of the
     * tuple will be used -- not the updater's xid.
     */
    htsvResult = HeapTupleSatisfiesVacuum(tuple, TransactionXmin, buffer);
    switch (htsvResult)
    {
        case HEAPTUPLE_LIVE:
            if (visible)
                return;
            xid = HeapTupleHeaderGetXmin(tuple->t_data);
            break;
        case HEAPTUPLE_RECENTLY_DEAD:
        case HEAPTUPLE_DELETE_IN_PROGRESS:
            if (visible)
                xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
            else
                xid = HeapTupleHeaderGetXmin(tuple->t_data);
 
            if (TransactionIdPrecedes(xid, TransactionXmin))
            {
                /* This is like the HEAPTUPLE_DEAD case */
                Assert(!visible);
                return;
            }
            break;
        case HEAPTUPLE_INSERT_IN_PROGRESS:
            xid = HeapTupleHeaderGetXmin(tuple->t_data);
            break;
        case HEAPTUPLE_DEAD:
            Assert(!visible);
            return;
        default:
 
            /*
             * The only way to get to this default clause is if a new value is
             * added to the enum type without adding it to this switch
             * statement.  That's a bug, so elog.
             */
            elog(ERROR, "unrecognized return value from HeapTupleSatisfiesVacuum: %u", htsvResult);
 
            /*
             * In spite of having all enum values covered and calling elog on
             * this default, some compilers think this is a code path which
             * allows xid to be used below without initialization. Silence
             * that warning.
             */
            xid = InvalidTransactionId;
    }
 
    Assert(TransactionIdIsValid(xid));
    Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));
 
    /*
     * Find top level xid.  Bail out if xid is too early to be a conflict, or
     * if it's our own xid.
     */
    if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
        return;
    xid = SubTransGetTopmostTransaction(xid);
    if (TransactionIdPrecedes(xid, TransactionXmin))
        return;
 
    CheckForSerializableConflictOut(relation, xid, snapshot);
}

References Assert(), CheckForSerializableConflictOut(), CheckForSerializableConflictOutNeeded(), elog, ERROR, GetTopTransactionIdIfAny(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVacuum(), InvalidTransactionId, SubTransGetTopmostTransaction(), HeapTupleData::t_data, TransactionIdEquals, TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), and TransactionXmin.

Referenced by BitmapHeapScanNextBlock(), heap_fetch(), heap_get_latest_tid(), heap_hot_search_buffer(), heapam_scan_sample_next_tuple(), heapgettup(), and page_collect_tuples().

HeapTupleHeaderIsOnlyLocked()

bool HeapTupleHeaderIsOnlyLocked

(

HeapTupleHeader

tuple

)

Definition at line 1529 of file heapam_visibility.c.

{
    TransactionId xmax;
 
    /* if there's no valid Xmax, then there's obviously no update either */
    if (tuple->t_infomask & HEAP_XMAX_INVALID)
        return true;
 
    if (tuple->t_infomask & HEAP_XMAX_LOCK_ONLY)
        return true;
 
    /* invalid xmax means no update */
    if (!TransactionIdIsValid(HeapTupleHeaderGetRawXmax(tuple)))
        return true;
 
    /*
     * if HEAP_XMAX_LOCK_ONLY is not set and not a multi, then this must
     * necessarily have been updated
     */
    if (!(tuple->t_infomask & HEAP_XMAX_IS_MULTI))
        return false;
 
    /* ... but if it's a multi, then perhaps the updating Xid aborted. */
    xmax = HeapTupleGetUpdateXid(tuple);
 
    /* not LOCKED_ONLY, so it has to have an xmax */
    Assert(TransactionIdIsValid(xmax));
 
    if (TransactionIdIsCurrentTransactionId(xmax))
        return false;
    if (TransactionIdIsInProgress(xmax))
        return false;
    if (TransactionIdDidCommit(xmax))
        return false;
 
    /*
     * not current, not in progress, not committed -- must have aborted or
     * crashed
     */
    return true;
}

References Assert(), HEAP_XMAX_INVALID, HEAP_XMAX_IS_MULTI, HEAP_XMAX_LOCK_ONLY, HeapTupleGetUpdateXid(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderData::t_infomask, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), and TransactionIdIsValid.

Referenced by heap_delete(), heap_get_latest_tid(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), HeapTupleSatisfiesVacuumHorizon(), and rewrite_heap_tuple().

HeapTupleIsSurelyDead()

bool HeapTupleIsSurelyDead	(	HeapTuple	htup,
		struct GlobalVisState *	vistest
	)

Definition at line 1474 of file heapam_visibility.c.

{
    HeapTupleHeader tuple = htup->t_data;
 
    Assert(ItemPointerIsValid(&htup->t_self));
    Assert(htup->t_tableOid != InvalidOid);
 
    /*
     * If the inserting transaction is marked invalid, then it aborted, and
     * the tuple is definitely dead.  If it's marked neither committed nor
     * invalid, then we assume it's still alive (since the presumption is that
     * all relevant hint bits were just set moments ago).
     */
    if (!HeapTupleHeaderXminCommitted(tuple))
        return HeapTupleHeaderXminInvalid(tuple);
 
    /*
     * If the inserting transaction committed, but any deleting transaction
     * aborted, the tuple is still alive.
     */
    if (tuple->t_infomask & HEAP_XMAX_INVALID)
        return false;
 
    /*
     * If the XMAX is just a lock, the tuple is still alive.
     */
    if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
        return false;
 
    /*
     * If the Xmax is a MultiXact, it might be dead or alive, but we cannot
     * know without checking pg_multixact.
     */
    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
        return false;
 
    /* If deleter isn't known to have committed, assume it's still running. */
    if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
        return false;
 
    /* Deleter committed, so tuple is dead if the XID is old enough. */
    return GlobalVisTestIsRemovableXid(vistest,
                                       HeapTupleHeaderGetRawXmax(tuple));
}

References Assert(), GlobalVisTestIsRemovableXid(), HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderXminCommitted(), HeapTupleHeaderXminInvalid(), InvalidOid, ItemPointerIsValid(), HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by heap_hot_search_buffer().

HeapTupleSatisfiesUpdate()

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

Definition at line 458 of file heapam_visibility.c.

{
    HeapTupleHeader tuple = htup->t_data;
 
    Assert(ItemPointerIsValid(&htup->t_self));
    Assert(htup->t_tableOid != InvalidOid);
 
    if (!HeapTupleHeaderXminCommitted(tuple))
    {
        if (HeapTupleHeaderXminInvalid(tuple))
            return TM_Invisible;
 
        /* Used by pre-9.0 binary upgrades */
        if (tuple->t_infomask & HEAP_MOVED_OFF)
        {
            TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
 
            if (TransactionIdIsCurrentTransactionId(xvac))
                return TM_Invisible;
            if (!TransactionIdIsInProgress(xvac))
            {
                if (TransactionIdDidCommit(xvac))
                {
                    SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                                InvalidTransactionId);
                    return TM_Invisible;
                }
                SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                            InvalidTransactionId);
            }
        }
        /* Used by pre-9.0 binary upgrades */
        else if (tuple->t_infomask & HEAP_MOVED_IN)
        {
            TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
 
            if (!TransactionIdIsCurrentTransactionId(xvac))
            {
                if (TransactionIdIsInProgress(xvac))
                    return TM_Invisible;
                if (TransactionIdDidCommit(xvac))
                    SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                                InvalidTransactionId);
                else
                {
                    SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                                InvalidTransactionId);
                    return TM_Invisible;
                }
            }
        }
        else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
        {
            if (HeapTupleHeaderGetCmin(tuple) >= curcid)
                return TM_Invisible;    /* inserted after scan started */
 
            if (tuple->t_infomask & HEAP_XMAX_INVALID)  /* xid invalid */
                return TM_Ok;
 
            if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
            {
                TransactionId xmax;
 
                xmax = HeapTupleHeaderGetRawXmax(tuple);
 
                /*
                 * Careful here: even though this tuple was created by our own
                 * transaction, it might be locked by other transactions, if
                 * the original version was key-share locked when we updated
                 * it.
                 */
 
                if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
                {
                    if (MultiXactIdIsRunning(xmax, true))
                        return TM_BeingModified;
                    else
                        return TM_Ok;
                }
 
                /*
                 * If the locker is gone, then there is nothing of interest
                 * left in this Xmax; otherwise, report the tuple as
                 * locked/updated.
                 */
                if (!TransactionIdIsInProgress(xmax))
                    return TM_Ok;
                return TM_BeingModified;
            }
 
            if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
            {
                TransactionId xmax;
 
                xmax = HeapTupleGetUpdateXid(tuple);
 
                /* not LOCKED_ONLY, so it has to have an xmax */
                Assert(TransactionIdIsValid(xmax));
 
                /* deleting subtransaction must have aborted */
                if (!TransactionIdIsCurrentTransactionId(xmax))
                {
                    if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
                                             false))
                        return TM_BeingModified;
                    return TM_Ok;
                }
                else
                {
                    if (HeapTupleHeaderGetCmax(tuple) >= curcid)
                        return TM_SelfModified; /* updated after scan started */
                    else
                        return TM_Invisible;    /* updated before scan started */
                }
            }
 
            if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
            {
                /* deleting subtransaction must have aborted */
                SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                            InvalidTransactionId);
                return TM_Ok;
            }
 
            if (HeapTupleHeaderGetCmax(tuple) >= curcid)
                return TM_SelfModified; /* updated after scan started */
            else
                return TM_Invisible;    /* updated before scan started */
        }
        else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
            return TM_Invisible;
        else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
            SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                        HeapTupleHeaderGetRawXmin(tuple));
        else
        {
            /* it must have aborted or crashed */
            SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                        InvalidTransactionId);
            return TM_Invisible;
        }
    }
 
    /* by here, the inserting transaction has committed */
 
    if (tuple->t_infomask & HEAP_XMAX_INVALID)  /* xid invalid or aborted */
        return TM_Ok;
 
    if (tuple->t_infomask & HEAP_XMAX_COMMITTED)
    {
        if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
            return TM_Ok;
        if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
            return TM_Updated;  /* updated by other */
        else
            return TM_Deleted;  /* deleted by other */
    }
 
    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
    {
        TransactionId xmax;
 
        if (HEAP_LOCKED_UPGRADED(tuple->t_infomask))
            return TM_Ok;
 
        if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
        {
            if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), true))
                return TM_BeingModified;
 
            SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
            return TM_Ok;
        }
 
        xmax = HeapTupleGetUpdateXid(tuple);
        if (!TransactionIdIsValid(xmax))
        {
            if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
                return TM_BeingModified;
        }
 
        /* not LOCKED_ONLY, so it has to have an xmax */
        Assert(TransactionIdIsValid(xmax));
 
        if (TransactionIdIsCurrentTransactionId(xmax))
        {
            if (HeapTupleHeaderGetCmax(tuple) >= curcid)
                return TM_SelfModified; /* updated after scan started */
            else
                return TM_Invisible;    /* updated before scan started */
        }
 
        if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
            return TM_BeingModified;
 
        if (TransactionIdDidCommit(xmax))
        {
            if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
                return TM_Updated;
            else
                return TM_Deleted;
        }
 
        /*
         * By here, the update in the Xmax is either aborted or crashed, but
         * what about the other members?
         */
 
        if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
        {
            /*
             * There's no member, even just a locker, alive anymore, so we can
             * mark the Xmax as invalid.
             */
            SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                        InvalidTransactionId);
            return TM_Ok;
        }
        else
        {
            /* There are lockers running */
            return TM_BeingModified;
        }
    }
 
    if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
    {
        if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
            return TM_BeingModified;
        if (HeapTupleHeaderGetCmax(tuple) >= curcid)
            return TM_SelfModified; /* updated after scan started */
        else
            return TM_Invisible;    /* updated before scan started */
    }
 
    if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
        return TM_BeingModified;
 
    if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
    {
        /* it must have aborted or crashed */
        SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                    InvalidTransactionId);
        return TM_Ok;
    }
 
    /* xmax transaction committed */
 
    if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
    {
        SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                    InvalidTransactionId);
        return TM_Ok;
    }
 
    SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
                HeapTupleHeaderGetRawXmax(tuple));
    if (!ItemPointerEquals(&htup->t_self, &tuple->t_ctid))
        return TM_Updated;      /* updated by other */
    else
        return TM_Deleted;      /* deleted by other */
}

References Assert(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED_IN, HEAP_MOVED_OFF, HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMIN_COMMITTED, HEAP_XMIN_INVALID, HeapTupleGetUpdateXid(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderGetXvac(), HeapTupleHeaderXminCommitted(), HeapTupleHeaderXminInvalid(), InvalidOid, InvalidTransactionId, ItemPointerEquals(), ItemPointerIsValid(), MultiXactIdIsRunning(), SetHintBits(), HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_BeingModified, TM_Deleted, TM_Invisible, TM_Ok, TM_SelfModified, TM_Updated, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), and TransactionIdIsValid.

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

HeapTupleSatisfiesVacuum()

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

Definition at line 1171 of file heapam_visibility.c.

{
    TransactionId dead_after = InvalidTransactionId;
    HTSV_Result res;
 
    res = HeapTupleSatisfiesVacuumHorizon(htup, buffer, &dead_after);
 
    if (res == HEAPTUPLE_RECENTLY_DEAD)
    {
        Assert(TransactionIdIsValid(dead_after));
 
        if (TransactionIdPrecedes(dead_after, OldestXmin))
            res = HEAPTUPLE_DEAD;
    }
    else
        Assert(!TransactionIdIsValid(dead_after));
 
    return res;
}

References Assert(), HEAPTUPLE_DEAD, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuumHorizon(), InvalidTransactionId, TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by heap_page_is_all_visible(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), heapam_scan_analyze_next_tuple(), HeapCheckForSerializableConflictOut(), lazy_scan_noprune(), statapprox_heap(), and tuple_all_visible().

HeapTupleSatisfiesVacuumHorizon()

HTSV_Result HeapTupleSatisfiesVacuumHorizon	(	HeapTuple	htup,
		Buffer	buffer,
		TransactionId *	dead_after
	)

Definition at line 1205 of file heapam_visibility.c.

{
    HeapTupleHeader tuple = htup->t_data;
 
    Assert(ItemPointerIsValid(&htup->t_self));
    Assert(htup->t_tableOid != InvalidOid);
    Assert(dead_after != NULL);
 
    *dead_after = InvalidTransactionId;
 
    /*
     * Has inserting transaction committed?
     *
     * If the inserting transaction aborted, then the tuple was never visible
     * to any other transaction, so we can delete it immediately.
     */
    if (!HeapTupleHeaderXminCommitted(tuple))
    {
        if (HeapTupleHeaderXminInvalid(tuple))
            return HEAPTUPLE_DEAD;
        /* Used by pre-9.0 binary upgrades */
        else if (tuple->t_infomask & HEAP_MOVED_OFF)
        {
            TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
 
            if (TransactionIdIsCurrentTransactionId(xvac))
                return HEAPTUPLE_DELETE_IN_PROGRESS;
            if (TransactionIdIsInProgress(xvac))
                return HEAPTUPLE_DELETE_IN_PROGRESS;
            if (TransactionIdDidCommit(xvac))
            {
                SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                            InvalidTransactionId);
                return HEAPTUPLE_DEAD;
            }
            SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                        InvalidTransactionId);
        }
        /* Used by pre-9.0 binary upgrades */
        else if (tuple->t_infomask & HEAP_MOVED_IN)
        {
            TransactionId xvac = HeapTupleHeaderGetXvac(tuple);
 
            if (TransactionIdIsCurrentTransactionId(xvac))
                return HEAPTUPLE_INSERT_IN_PROGRESS;
            if (TransactionIdIsInProgress(xvac))
                return HEAPTUPLE_INSERT_IN_PROGRESS;
            if (TransactionIdDidCommit(xvac))
                SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                            InvalidTransactionId);
            else
            {
                SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                            InvalidTransactionId);
                return HEAPTUPLE_DEAD;
            }
        }
        else if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
        {
            if (tuple->t_infomask & HEAP_XMAX_INVALID)  /* xid invalid */
                return HEAPTUPLE_INSERT_IN_PROGRESS;
            /* only locked? run infomask-only check first, for performance */
            if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask) ||
                HeapTupleHeaderIsOnlyLocked(tuple))
                return HEAPTUPLE_INSERT_IN_PROGRESS;
            /* inserted and then deleted by same xact */
            if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple)))
                return HEAPTUPLE_DELETE_IN_PROGRESS;
            /* deleting subtransaction must have aborted */
            return HEAPTUPLE_INSERT_IN_PROGRESS;
        }
        else if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmin(tuple)))
        {
            /*
             * It'd be possible to discern between INSERT/DELETE in progress
             * here by looking at xmax - but that doesn't seem beneficial for
             * the majority of callers and even detrimental for some. We'd
             * rather have callers look at/wait for xmin than xmax. It's
             * always correct to return INSERT_IN_PROGRESS because that's
             * what's happening from the view of other backends.
             */
            return HEAPTUPLE_INSERT_IN_PROGRESS;
        }
        else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
            SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED,
                        HeapTupleHeaderGetRawXmin(tuple));
        else
        {
            /*
             * Not in Progress, Not Committed, so either Aborted or crashed
             */
            SetHintBits(tuple, buffer, HEAP_XMIN_INVALID,
                        InvalidTransactionId);
            return HEAPTUPLE_DEAD;
        }
 
        /*
         * At this point the xmin is known committed, but we might not have
         * been able to set the hint bit yet; so we can no longer Assert that
         * it's set.
         */
    }
 
    /*
     * Okay, the inserter committed, so it was good at some point.  Now what
     * about the deleting transaction?
     */
    if (tuple->t_infomask & HEAP_XMAX_INVALID)
        return HEAPTUPLE_LIVE;
 
    if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
    {
        /*
         * "Deleting" xact really only locked it, so the tuple is live in any
         * case.  However, we should make sure that either XMAX_COMMITTED or
         * XMAX_INVALID gets set once the xact is gone, to reduce the costs of
         * examining the tuple for future xacts.
         */
        if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
        {
            if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
            {
                /*
                 * If it's a pre-pg_upgrade tuple, the multixact cannot
                 * possibly be running; otherwise have to check.
                 */
                if (!HEAP_LOCKED_UPGRADED(tuple->t_infomask) &&
                    MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple),
                                         true))
                    return HEAPTUPLE_LIVE;
                SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
            }
            else
            {
                if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
                    return HEAPTUPLE_LIVE;
                SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                            InvalidTransactionId);
            }
        }
 
        /*
         * We don't really care whether xmax did commit, abort or crash. We
         * know that xmax did lock the tuple, but it did not and will never
         * actually update it.
         */
 
        return HEAPTUPLE_LIVE;
    }
 
    if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
    {
        TransactionId xmax = HeapTupleGetUpdateXid(tuple);
 
        /* already checked above */
        Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
 
        /* not LOCKED_ONLY, so it has to have an xmax */
        Assert(TransactionIdIsValid(xmax));
 
        if (TransactionIdIsInProgress(xmax))
            return HEAPTUPLE_DELETE_IN_PROGRESS;
        else if (TransactionIdDidCommit(xmax))
        {
            /*
             * The multixact might still be running due to lockers.  Need to
             * allow for pruning if below the xid horizon regardless --
             * otherwise we could end up with a tuple where the updater has to
             * be removed due to the horizon, but is not pruned away.  It's
             * not a problem to prune that tuple, because any remaining
             * lockers will also be present in newer tuple versions.
             */
            *dead_after = xmax;
            return HEAPTUPLE_RECENTLY_DEAD;
        }
        else if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
        {
            /*
             * Not in Progress, Not Committed, so either Aborted or crashed.
             * Mark the Xmax as invalid.
             */
            SetHintBits(tuple, buffer, HEAP_XMAX_INVALID, InvalidTransactionId);
        }
 
        return HEAPTUPLE_LIVE;
    }
 
    if (!(tuple->t_infomask & HEAP_XMAX_COMMITTED))
    {
        if (TransactionIdIsInProgress(HeapTupleHeaderGetRawXmax(tuple)))
            return HEAPTUPLE_DELETE_IN_PROGRESS;
        else if (TransactionIdDidCommit(HeapTupleHeaderGetRawXmax(tuple)))
            SetHintBits(tuple, buffer, HEAP_XMAX_COMMITTED,
                        HeapTupleHeaderGetRawXmax(tuple));
        else
        {
            /*
             * Not in Progress, Not Committed, so either Aborted or crashed
             */
            SetHintBits(tuple, buffer, HEAP_XMAX_INVALID,
                        InvalidTransactionId);
            return HEAPTUPLE_LIVE;
        }
 
        /*
         * At this point the xmax is known committed, but we might not have
         * been able to set the hint bit yet; so we can no longer Assert that
         * it's set.
         */
    }
 
    /*
     * Deleter committed, allow caller to check if it was recent enough that
     * some open transactions could still see the tuple.
     */
    *dead_after = HeapTupleHeaderGetRawXmax(tuple);
    return HEAPTUPLE_RECENTLY_DEAD;
}

References Assert(), HEAP_LOCKED_UPGRADED(), HEAP_MOVED_IN, HEAP_MOVED_OFF, HEAP_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMIN_COMMITTED, HEAP_XMIN_INVALID, HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleGetUpdateXid(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXvac(), HeapTupleHeaderIsOnlyLocked(), HeapTupleHeaderXminCommitted(), HeapTupleHeaderXminInvalid(), InvalidOid, InvalidTransactionId, ItemPointerIsValid(), MultiXactIdIsRunning(), SetHintBits(), HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdDidCommit(), TransactionIdIsCurrentTransactionId(), TransactionIdIsInProgress(), and TransactionIdIsValid.

Referenced by heap_prune_satisfies_vacuum(), HeapTupleSatisfiesNonVacuumable(), and HeapTupleSatisfiesVacuum().

HeapTupleSatisfiesVisibility()

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

Definition at line 1776 of file heapam_visibility.c.

{
    switch (snapshot->snapshot_type)
    {
        case SNAPSHOT_MVCC:
            return HeapTupleSatisfiesMVCC(htup, snapshot, buffer);
        case SNAPSHOT_SELF:
            return HeapTupleSatisfiesSelf(htup, snapshot, buffer);
        case SNAPSHOT_ANY:
            return HeapTupleSatisfiesAny(htup, snapshot, buffer);
        case SNAPSHOT_TOAST:
            return HeapTupleSatisfiesToast(htup, snapshot, buffer);
        case SNAPSHOT_DIRTY:
            return HeapTupleSatisfiesDirty(htup, snapshot, buffer);
        case SNAPSHOT_HISTORIC_MVCC:
            return HeapTupleSatisfiesHistoricMVCC(htup, snapshot, buffer);
        case SNAPSHOT_NON_VACUUMABLE:
            return HeapTupleSatisfiesNonVacuumable(htup, snapshot, buffer);
    }
 
    return false;               /* keep compiler quiet */
}

References HeapTupleSatisfiesAny(), HeapTupleSatisfiesDirty(), HeapTupleSatisfiesHistoricMVCC(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesNonVacuumable(), HeapTupleSatisfiesSelf(), HeapTupleSatisfiesToast(), SNAPSHOT_ANY, SNAPSHOT_DIRTY, SNAPSHOT_HISTORIC_MVCC, SNAPSHOT_MVCC, SNAPSHOT_NON_VACUUMABLE, SNAPSHOT_SELF, SNAPSHOT_TOAST, and SnapshotData::snapshot_type.

Referenced by BitmapHeapScanNextBlock(), heap_delete(), heap_fetch(), heap_get_latest_tid(), heap_hot_search_buffer(), heap_update(), heapam_tuple_satisfies_snapshot(), heapgettup(), page_collect_tuples(), pgstat_heap(), SampleHeapTupleVisible(), and ScanSourceDatabasePgClassPage().

HeapTupleSetHintBits()

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

Definition at line 141 of file heapam_visibility.c.

{
    SetHintBits(tuple, buffer, infomask, xid);
}

References SetHintBits().

Referenced by UpdateXmaxHintBits().

log_heap_prune_and_freeze()

void log_heap_prune_and_freeze	(	Relation	relation,
		Buffer	buffer,
		TransactionId	conflict_xid,
		bool	cleanup_lock,
		PruneReason	reason,
		HeapTupleFreeze *	frozen,
		int	nfrozen,
		OffsetNumber *	redirected,
		int	nredirected,
		OffsetNumber *	dead,
		int	ndead,
		OffsetNumber *	unused,
		int	nunused
	)

Definition at line 2053 of file pruneheap.c.

{
    xl_heap_prune xlrec;
    XLogRecPtr  recptr;
    uint8       info;
 
    /* The following local variables hold data registered in the WAL record: */
    xlhp_freeze_plan plans[MaxHeapTuplesPerPage];
    xlhp_freeze_plans freeze_plans;
    xlhp_prune_items redirect_items;
    xlhp_prune_items dead_items;
    xlhp_prune_items unused_items;
    OffsetNumber frz_offsets[MaxHeapTuplesPerPage];
 
    xlrec.flags = 0;
 
    /*
     * Prepare data for the buffer.  The arrays are not actually in the
     * buffer, but we pretend that they are.  When XLogInsert stores a full
     * page image, the arrays can be omitted.
     */
    XLogBeginInsert();
    XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
    if (nfrozen > 0)
    {
        int         nplans;
 
        xlrec.flags |= XLHP_HAS_FREEZE_PLANS;
 
        /*
         * Prepare deduplicated representation for use in the WAL record. This
         * destructively sorts frozen tuples array in-place.
         */
        nplans = heap_log_freeze_plan(frozen, nfrozen, plans, frz_offsets);
 
        freeze_plans.nplans = nplans;
        XLogRegisterBufData(0, &freeze_plans,
                            offsetof(xlhp_freeze_plans, plans));
        XLogRegisterBufData(0, plans,
                            sizeof(xlhp_freeze_plan) * nplans);
    }
    if (nredirected > 0)
    {
        xlrec.flags |= XLHP_HAS_REDIRECTIONS;
 
        redirect_items.ntargets = nredirected;
        XLogRegisterBufData(0, &redirect_items,
                            offsetof(xlhp_prune_items, data));
        XLogRegisterBufData(0, redirected,
                            sizeof(OffsetNumber[2]) * nredirected);
    }
    if (ndead > 0)
    {
        xlrec.flags |= XLHP_HAS_DEAD_ITEMS;
 
        dead_items.ntargets = ndead;
        XLogRegisterBufData(0, &dead_items,
                            offsetof(xlhp_prune_items, data));
        XLogRegisterBufData(0, dead,
                            sizeof(OffsetNumber) * ndead);
    }
    if (nunused > 0)
    {
        xlrec.flags |= XLHP_HAS_NOW_UNUSED_ITEMS;
 
        unused_items.ntargets = nunused;
        XLogRegisterBufData(0, &unused_items,
                            offsetof(xlhp_prune_items, data));
        XLogRegisterBufData(0, unused,
                            sizeof(OffsetNumber) * nunused);
    }
    if (nfrozen > 0)
        XLogRegisterBufData(0, frz_offsets,
                            sizeof(OffsetNumber) * nfrozen);
 
    /*
     * Prepare the main xl_heap_prune record.  We already set the XLHP_HAS_*
     * flag above.
     */
    if (RelationIsAccessibleInLogicalDecoding(relation))
        xlrec.flags |= XLHP_IS_CATALOG_REL;
    if (TransactionIdIsValid(conflict_xid))
        xlrec.flags |= XLHP_HAS_CONFLICT_HORIZON;
    if (cleanup_lock)
        xlrec.flags |= XLHP_CLEANUP_LOCK;
    else
    {
        Assert(nredirected == 0 && ndead == 0);
        /* also, any items in 'unused' must've been LP_DEAD previously */
    }
    XLogRegisterData(&xlrec, SizeOfHeapPrune);
    if (TransactionIdIsValid(conflict_xid))
        XLogRegisterData(&conflict_xid, sizeof(TransactionId));
 
    switch (reason)
    {
        case PRUNE_ON_ACCESS:
            info = XLOG_HEAP2_PRUNE_ON_ACCESS;
            break;
        case PRUNE_VACUUM_SCAN:
            info = XLOG_HEAP2_PRUNE_VACUUM_SCAN;
            break;
        case PRUNE_VACUUM_CLEANUP:
            info = XLOG_HEAP2_PRUNE_VACUUM_CLEANUP;
            break;
        default:
            elog(ERROR, "unrecognized prune reason: %d", (int) reason);
            break;
    }
    recptr = XLogInsert(RM_HEAP2_ID, info);
 
    PageSetLSN(BufferGetPage(buffer), recptr);
}

References Assert(), BufferGetPage(), data, elog, ERROR, xl_heap_prune::flags, heap_log_freeze_plan(), MaxHeapTuplesPerPage, xlhp_freeze_plans::nplans, xlhp_prune_items::ntargets, PageSetLSN(), PRUNE_ON_ACCESS, PRUNE_VACUUM_CLEANUP, PRUNE_VACUUM_SCAN, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfHeapPrune, TransactionIdIsValid, XLHP_CLEANUP_LOCK, XLHP_HAS_CONFLICT_HORIZON, XLHP_HAS_DEAD_ITEMS, XLHP_HAS_FREEZE_PLANS, XLHP_HAS_NOW_UNUSED_ITEMS, XLHP_HAS_REDIRECTIONS, XLHP_IS_CATALOG_REL, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by heap_page_prune_and_freeze(), and lazy_vacuum_heap_page().

ReleaseBulkInsertStatePin()

void ReleaseBulkInsertStatePin

(

BulkInsertState

bistate

)

Definition at line 2018 of file heapam.c.

{
    if (bistate->current_buf != InvalidBuffer)
        ReleaseBuffer(bistate->current_buf);
    bistate->current_buf = InvalidBuffer;
 
    /*
     * Despite the name, we also reset bulk relation extension state.
     * Otherwise we can end up erroring out due to looking for free space in
     * ->next_free of one partition, even though ->next_free was set when
     * extending another partition. It could obviously also be bad for
     * efficiency to look at existing blocks at offsets from another
     * partition, even if we don't error out.
     */
    bistate->next_free = InvalidBlockNumber;
    bistate->last_free = InvalidBlockNumber;
}

References BulkInsertStateData::current_buf, InvalidBlockNumber, InvalidBuffer, BulkInsertStateData::last_free, BulkInsertStateData::next_free, and ReleaseBuffer().

Referenced by CopyFrom().

ResolveCminCmaxDuringDecoding()

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

Definition at line 5397 of file reorderbuffer.c.

{
    ReorderBufferTupleCidKey key;
    ReorderBufferTupleCidEnt *ent;
    ForkNumber  forkno;
    BlockNumber blockno;
    bool        updated_mapping = false;
 
    /*
     * Return unresolved if tuplecid_data is not valid.  That's because when
     * streaming in-progress transactions we may run into tuples with the CID
     * before actually decoding them.  Think e.g. about INSERT followed by
     * TRUNCATE, where the TRUNCATE may not be decoded yet when applying the
     * INSERT.  So in such cases, we assume the CID is from the future
     * command.
     */
    if (tuplecid_data == NULL)
        return false;
 
    /* be careful about padding */
    memset(&key, 0, sizeof(key));
 
    Assert(!BufferIsLocal(buffer));
 
    /*
     * get relfilelocator from the buffer, no convenient way to access it
     * other than that.
     */
    BufferGetTag(buffer, &key.rlocator, &forkno, &blockno);
 
    /* tuples can only be in the main fork */
    Assert(forkno == MAIN_FORKNUM);
    Assert(blockno == ItemPointerGetBlockNumber(&htup->t_self));
 
    ItemPointerCopy(&htup->t_self,
                    &key.tid);
 
restart:
    ent = (ReorderBufferTupleCidEnt *)
        hash_search(tuplecid_data, &key, HASH_FIND, NULL);
 
    /*
     * failed to find a mapping, check whether the table was rewritten and
     * apply mapping if so, but only do that once - there can be no new
     * mappings while we are in here since we have to hold a lock on the
     * relation.
     */
    if (ent == NULL && !updated_mapping)
    {
        UpdateLogicalMappings(tuplecid_data, htup->t_tableOid, snapshot);
        /* now check but don't update for a mapping again */
        updated_mapping = true;
        goto restart;
    }
    else if (ent == NULL)
        return false;
 
    if (cmin)
        *cmin = ent->cmin;
    if (cmax)
        *cmax = ent->cmax;
    return true;
}

References Assert(), BufferGetTag(), BufferIsLocal, ReorderBufferTupleCidEnt::cmax, ReorderBufferTupleCidEnt::cmin, HASH_FIND, hash_search(), ItemPointerCopy(), ItemPointerGetBlockNumber(), sort-test::key, MAIN_FORKNUM, HeapTupleData::t_self, HeapTupleData::t_tableOid, tuplecid_data, and UpdateLogicalMappings().

Referenced by HeapTupleSatisfiesHistoricMVCC().

simple_heap_delete()

void simple_heap_delete	(	Relation	relation,
		ItemPointer	tid
	)

Definition at line 3166 of file heapam.c.

{
    TM_Result   result;
    TM_FailureData tmfd;
 
    result = heap_delete(relation, tid,
                         GetCurrentCommandId(true), InvalidSnapshot,
                         true /* wait for commit */ ,
                         &tmfd, false /* changingPart */ );
    switch (result)
    {
        case TM_SelfModified:
            /* Tuple was already updated in current command? */
            elog(ERROR, "tuple already updated by self");
            break;
 
        case TM_Ok:
            /* done successfully */
            break;
 
        case TM_Updated:
            elog(ERROR, "tuple concurrently updated");
            break;
 
        case TM_Deleted:
            elog(ERROR, "tuple concurrently deleted");
            break;
 
        default:
            elog(ERROR, "unrecognized heap_delete status: %u", result);
            break;
    }
}

References elog, ERROR, GetCurrentCommandId(), heap_delete(), InvalidSnapshot, TM_Deleted, TM_Ok, TM_SelfModified, and TM_Updated.

Referenced by CatalogTupleDelete(), and toast_delete_datum().

simple_heap_insert()

void simple_heap_insert	(	Relation	relation,
		HeapTuple	tup
	)

Definition at line 2687 of file heapam.c.

{
    heap_insert(relation, tup, GetCurrentCommandId(true), 0, NULL);
}

References GetCurrentCommandId(), and heap_insert().

Referenced by CatalogTupleInsert(), CatalogTupleInsertWithInfo(), and InsertOneTuple().

simple_heap_update()

void simple_heap_update	(	Relation	relation,
		ItemPointer	otid,
		HeapTuple	tup,
		TU_UpdateIndexes *	update_indexes
	)

Definition at line 4454 of file heapam.c.

{
    TM_Result   result;
    TM_FailureData tmfd;
    LockTupleMode lockmode;
 
    result = heap_update(relation, otid, tup,
                         GetCurrentCommandId(true), InvalidSnapshot,
                         true /* wait for commit */ ,
                         &tmfd, &lockmode, update_indexes);
    switch (result)
    {
        case TM_SelfModified:
            /* Tuple was already updated in current command? */
            elog(ERROR, "tuple already updated by self");
            break;
 
        case TM_Ok:
            /* done successfully */
            break;
 
        case TM_Updated:
            elog(ERROR, "tuple concurrently updated");
            break;
 
        case TM_Deleted:
            elog(ERROR, "tuple concurrently deleted");
            break;
 
        default:
            elog(ERROR, "unrecognized heap_update status: %u", result);
            break;
    }
}

References elog, ERROR, GetCurrentCommandId(), heap_update(), InvalidSnapshot, TM_Deleted, TM_Ok, TM_SelfModified, and TM_Updated.

Referenced by CatalogTupleUpdate(), and CatalogTupleUpdateWithInfo().