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	PruneFreezeParams
struct	PruneFreezeResult
struct	BatchMVCCState

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	HEAP_PAGE_PRUNE_ALLOW_FAST_PATH   (1 << 2)
#define	HEAP_PAGE_PRUNE_SET_VM   (1 << 3)
#define	MaxLockTupleMode   LockTupleExclusive
#define	HEAP_FREEZE_CHECK_XMIN_COMMITTED   0x01
#define	HEAP_FREEZE_CHECK_XMAX_ABORTED   0x02

Typedefs
typedef struct BulkInsertStateData *	BulkInsertState
typedef struct GlobalVisState	GlobalVisState
typedef struct TupleTableSlot	TupleTableSlot
typedef struct VacuumCutoffs	VacuumCutoffs
typedef struct VacuumParams	VacuumParams
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 PruneFreezeParams	PruneFreezeParams
typedef struct PruneFreezeResult	PruneFreezeResult
typedef struct BatchMVCCState	BatchMVCCState

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, 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)
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, uint32 options, BulkInsertState bistate)
void	heap_multi_insert (Relation relation, TupleTableSlot **slots, int ntuples, CommandId cid, uint32 options, BulkInsertState bistate)
TM_Result	heap_delete (Relation relation, const ItemPointerData *tid, CommandId cid, uint32 options, Snapshot crosscheck, bool wait, TM_FailureData *tmfd)
void	heap_finish_speculative (Relation relation, const ItemPointerData *tid)
void	heap_abort_speculative (Relation relation, const ItemPointerData *tid)
TM_Result	heap_update (Relation relation, const ItemPointerData *otid, HeapTuple newtup, CommandId cid, uint32 options, Snapshot crosscheck, bool wait, 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, 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 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 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, const ItemPointerData *tid)
void	simple_heap_update (Relation relation, const ItemPointerData *otid, HeapTuple tup, TU_UpdateIndexes *update_indexes)
TransactionId	heap_index_delete_tuples (Relation rel, TM_IndexDeleteOp *delstate)
IndexFetchTableData *	heapam_index_fetch_begin (Relation rel, uint32 flags)
void	heapam_index_fetch_reset (IndexFetchTableData *scan)
void	heapam_index_fetch_end (IndexFetchTableData *scan)
bool	heap_hot_search_buffer (ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
bool	heapam_index_fetch_tuple (struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *heap_continue, bool *all_dead)
void	heap_page_prune_opt (Relation relation, Buffer buffer, Buffer *vmbuffer, bool rel_read_only)
void	heap_page_prune_and_freeze (PruneFreezeParams *params, PruneFreezeResult *presult, 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, Buffer vmbuffer, uint8 vmflags, 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, const 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, GlobalVisState *vistest)
int	HeapTupleSatisfiesMVCCBatch (Snapshot snapshot, Buffer buffer, int ntups, BatchMVCCState *batchmvcc, OffsetNumber *vistuples_dense)
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 150 of file heapam.h.

HEAP_FREEZE_CHECK_XMIN_COMMITTED

#define HEAP_FREEZE_CHECK_XMIN_COMMITTED   0x01

Definition at line 149 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_ALLOW_FAST_PATH

#define HEAP_PAGE_PRUNE_ALLOW_FAST_PATH   (1 << 2)

Definition at line 44 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.

HEAP_PAGE_PRUNE_SET_VM

#define HEAP_PAGE_PRUNE_SET_VM   (1 << 3)

Definition at line 45 of file heapam.h.

MaxLockTupleMode

#define MaxLockTupleMode   LockTupleExclusive

Definition at line 53 of file heapam.h.

Typedef Documentation

BatchMVCCState

typedef struct BatchMVCCState BatchMVCCState

BitmapHeapScanDesc

typedef struct BitmapHeapScanDescData* BitmapHeapScanDesc

Definition at line 115 of file heapam.h.

BitmapHeapScanDescData

typedef struct BitmapHeapScanDescData BitmapHeapScanDescData

BulkInsertState

typedef struct BulkInsertStateData* BulkInsertState

Definition at line 47 of file heapam.h.

GlobalVisState

typedef struct GlobalVisState GlobalVisState

Definition at line 48 of file heapam.h.

HeapPageFreeze

typedef struct HeapPageFreeze HeapPageFreeze

HeapScanDesc

typedef struct HeapScanDescData* HeapScanDesc

Definition at line 107 of file heapam.h.

HeapScanDescData

typedef struct HeapScanDescData HeapScanDescData

HeapTupleFreeze

typedef struct HeapTupleFreeze HeapTupleFreeze

IndexFetchHeapData

typedef struct IndexFetchHeapData IndexFetchHeapData

PruneFreezeParams

typedef struct PruneFreezeParams PruneFreezeParams

PruneFreezeResult

typedef struct PruneFreezeResult PruneFreezeResult

TupleTableSlot

typedef struct TupleTableSlot TupleTableSlot

Definition at line 49 of file heapam.h.

VacuumCutoffs

typedef struct VacuumCutoffs VacuumCutoffs

Definition at line 50 of file heapam.h.

VacuumParams

typedef struct VacuumParams VacuumParams

Definition at line 51 of file heapam.h.

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 136 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 250 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 )

extern

Definition at line 1955 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(), deleteSplitPartitionContext(), heapam_relation_copy_for_cluster(), intorel_shutdown(), MergePartitionsMoveRows(), and transientrel_shutdown().

GetBulkInsertState()

BulkInsertState GetBulkInsertState ( void  )

extern

Definition at line 1938 of file heapam.c.

{
    BulkInsertState bistate;
 
    bistate = (BulkInsertState) palloc_object(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_object, and BulkInsertStateData::strategy.

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

heap_abort_speculative()

void heap_abort_speculative ( Relation  relation, const ItemPointerData *  tid  )

extern

Definition at line 6390 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, fb(), xl_heap_delete::flags, GetCurrentTransactionId(), HEAP_MOVED, heap_toast_delete(), HEAP_XMAX_BITS, HeapTupleHasExternal(), HeapTupleHeaderIsHeapOnly(), HeapTupleHeaderIsSpeculative(), HeapTupleHeaderSetXmin(), InvalidTransactionId, IsToastRelation(), ItemIdGetLength, ItemIdIsNormal, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), MarkBufferDirty(), 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(), and XLogRegisterData().

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  )

extern

Definition at line 1168 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_object(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_object(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_base.rs_instrument = NULL;
    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;
 
    /* Check that a historic snapshot is not used for non-catalog tables */
    if (snapshot &&
        IsHistoricMVCCSnapshot(snapshot) &&
        !RelationIsAccessibleInLogicalDecoding(relation))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot query non-catalog table \"%s\" during logical decoding",
                        RelationGetRelationName(relation))));
    }
 
    /*
     * 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_object(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 = palloc_array(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));
    }
 
    /* enable read stream instrumentation */
    if ((flags & SO_SCAN_INSTRUMENT) && (scan->rs_read_stream != NULL))
    {
        scan->rs_base.rs_instrument = palloc0_object(TableScanInstrumentation);
        read_stream_enable_stats(scan->rs_read_stream,
                                 &scan->rs_base.rs_instrument->io);
    }
 
    scan->rs_vmbuffer = InvalidBuffer;
 
    return (TableScanDesc) scan;
}

References Assert, bitmapheap_stream_read_next(), ereport, errcode(), errmsg, ERROR, fb(), heap_scan_stream_read_next_parallel(), heap_scan_stream_read_next_serial(), initscan(), InvalidBuffer, TableScanInstrumentation::io, IsHistoricMVCCSnapshot, IsMVCCSnapshot, MAIN_FORKNUM, palloc0_object, palloc_array, palloc_object, PredicateLockRelation(), read_stream_begin_relation(), READ_STREAM_DEFAULT, read_stream_enable_stats(), READ_STREAM_SEQUENTIAL, READ_STREAM_USE_BATCHING, RelationGetRelationName, RelationGetRelid, RelationIncrementReferenceCount(), RelationIsAccessibleInLogicalDecoding, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_instrument, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_parallel, HeapScanDescData::rs_parallelworkerdata, TableScanDescData::rs_rd, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_strategy, HeapScanDescData::rs_vmbuffer, SO_SCAN_INSTRUMENT, SO_TYPE_BITMAPSCAN, SO_TYPE_SAMPLESCAN, SO_TYPE_SEQSCAN, SO_TYPE_TIDRANGESCAN, and HeapTupleData::t_tableOid.

heap_delete()

TM_Result heap_delete ( Relation  relation, const ItemPointerData *  tid, CommandId  cid, uint32  options, Snapshot  crosscheck, bool  wait, TM_FailureData *  tmfd  )

extern

Definition at line 2759 of file heapam.c.

{
    TM_Result   result;
    TransactionId xid = GetCurrentTransactionId();
    ItemId      lp;
    HeapTupleData tp;
    Page        page;
    BlockNumber block;
    Buffer      buffer;
    Buffer      vmbuffer = InvalidBuffer;
    bool        vmbuffer_modified = false;
    TransactionId new_xmax;
    uint16      new_infomask,
                new_infomask2;
    bool        changingPart = (options & TABLE_DELETE_CHANGING_PARTITION) != 0;
    bool        walLogical = (options & TABLE_DELETE_NO_LOGICAL) == 0;
    bool        have_tuple_lock = false;
    bool        iscombo;
    bool        clear_all_visible = false;
    HeapTuple   old_key_tuple = NULL;   /* replica identity of the tuple */
    bool        old_key_copied = false;
 
    Assert(ItemPointerIsValid(tid));
 
    AssertHasSnapshotForToast(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 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 = walLogical ?
        ExtractReplicaIdentity(relation, &tp, true, &old_key_copied) : NULL;
 
    /*
     * 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);
 
    /* Lock the VM before entering the critical section */
    if (PageIsAllVisible(page))
    {
        clear_all_visible = true;
        LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
    }
 
    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 (clear_all_visible)
    {
        /* It's possible the VM bits were already clear */
        if (visibilitymap_clear(relation->rd_locator, BufferGetBlockNumber(buffer),
                                vmbuffer, VISIBILITYMAP_VALID_BITS))
            vmbuffer_modified = true;
 
        PageClearAllVisible(page);
    }
 
    /* 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 (clear_all_visible)
            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;
        }
 
        /*
         * Mark the change as not-for-logical-decoding if caller requested so.
         *
         * (This is used for changes that affect relations not visible to
         * other transactions, such as the transient table during concurrent
         * repack.)
         */
        if (!walLogical)
            xlrec.flags |= XLH_DELETE_NO_LOGICAL;
 
        XLogBeginInsert();
        XLogRegisterData(&xlrec, SizeOfHeapDelete);
 
        XLogRegisterBuffer(HEAP_DELETE_BLKREF_HEAP, 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);
 
        if (vmbuffer_modified)
            XLogRegisterBuffer(HEAP_DELETE_BLKREF_VM, vmbuffer, 0);
 
        recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_DELETE);
 
        PageSetLSN(page, recptr);
 
        if (vmbuffer_modified)
            PageSetLSN(BufferGetPage(vmbuffer), recptr);
    }
 
    END_CRIT_SECTION();
 
    /*
     * Release VM lock first, since it covers many heap blocks. We locked
     * vmbuffer if clear_all_visible was true regardless of whether or not we
     * ended up modifying the vmbuffer.
     */
    if (clear_all_visible)
        LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
 
    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, AssertHasSnapshotForToast(), 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(), fb(), GetCurrentTransactionId(), heap_acquire_tuplock(), HEAP_DELETE_BLKREF_HEAP, HEAP_DELETE_BLKREF_VM, 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(), InvalidBuffer, InvalidCommandId, InvalidSnapshot, IsInParallelMode(), ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), LockTupleExclusive, LockWaitBlock, log_heap_new_cid(), MarkBufferDirty(), MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusUpdate, PageClearAllVisible(), PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_delete(), RelationData::rd_locator, RelationData::rd_rel, ReadBuffer(), REGBUF_STANDARD, RelationGetRelid, RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, ReleaseBuffer(), result, SizeOfHeapDelete, SizeOfHeapHeader, SizeofHeapTupleHeader, START_CRIT_SECTION, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TABLE_DELETE_CHANGING_PARTITION, TABLE_DELETE_NO_LOGICAL, 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, XLH_DELETE_NO_LOGICAL, XLOG_HEAP_DELETE, XLOG_INCLUDE_ORIGIN, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), XLogRegisterData(), XLogSetRecordFlags(), XLTW_Delete, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_delete(), and simple_heap_delete().

heap_endscan()

void heap_endscan ( TableScanDesc  sscan )

extern

Definition at line 1391 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);
 
    if (BufferIsValid(scan->rs_vmbuffer))
        ReleaseBuffer(scan->rs_vmbuffer);
 
    /*
     * 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);
 
    if (scan->rs_base.rs_instrument)
        pfree(scan->rs_base.rs_instrument);
 
    pfree(scan);
}

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

heap_execute_freeze_tuple()

static void heap_execute_freeze_tuple ( HeapTupleHeader  tuple, HeapTupleFreeze *  frz  )

inlinestatic

Definition at line 533 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 fb(), FrozenTransactionId, HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXvac(), InvalidTransactionId, HeapTupleHeaderData::t_infomask, HeapTupleHeaderData::t_infomask2, XLH_FREEZE_XVAC, and XLH_INVALID_XVAC.

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  )

extern

Definition at line 1685 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))
    {
        UnlockReleaseBuffer(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))
    {
        UnlockReleaseBuffer(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(), fb(), 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, HeapTupleData::t_tableOid, and UnlockReleaseBuffer().

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

heap_finish_speculative()

void heap_finish_speculative ( Relation  relation, const ItemPointerData *  tid  )

extern

Definition at line 6303 of file heapam.c.

{
    Buffer      buffer;
    Page        page;
    OffsetNumber offnum;
    ItemId      lp;
    HeapTupleHeader htup;
 
    buffer = ReadBuffer(relation, ItemPointerGetBlockNumber(tid));
    LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
    page = BufferGetPage(buffer);
 
    offnum = ItemPointerGetOffsetNumber(tid);
    if (offnum < 1 || offnum > PageGetMaxOffsetNumber(page))
        elog(ERROR, "offnum out of range");
    lp = PageGetItemId(page, offnum);
    if (!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, fb(), 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  )

extern

Definition at line 7600 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(), fb(), heap_execute_freeze_tuple(), i, 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  )

extern

Definition at line 7622 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.FreezePageConflictXid = InvalidTransactionId;
    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 fb(), VacuumCutoffs::FreezeLimit, heap_execute_freeze_tuple(), heap_prepare_freeze_tuple(), InvalidTransactionId, 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  )

extern

Definition at line 1794 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(), fb(), HEAP_XMAX_INVALID, HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIndicatesMovedPartitions(), HeapTupleHeaderIsOnlyLocked(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdIsNormal, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), LockBuffer(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), ReadBuffer(), RelationGetRelid, 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  )

extern

Definition at line 2311 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 (nextoffnum < FirstOffsetNumber)
                break;
 
            /*
             * An offset past the end of page's line pointer array is possible
             * when the array was truncated
             */
            if (nextoffnum > 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, fb(), 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  )

extern

Definition at line 1436 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")));
 
    /* 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 ereport, errcode(), errmsg_internal(), ERROR, fb(), GetHeapamTableAmRoutine(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_ctup, TableScanDescData::rs_flags, TableScanDescData::rs_key, TableScanDescData::rs_nkeys, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, HeapTupleData::t_data, and unlikely.

Referenced by AlterTableMoveAll(), AlterTableSpaceOptions(), BuildDatabaseList(), BuildRelationList(), 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_repack(), get_tablespace_name(), get_tablespace_oid(), GetAllPublicationRelations(), getRelationsInNamespace(), GetSchemaPublicationRelations(), heapam_index_build_range_scan(), heapam_index_validate_scan(), objectsInSchemaToOids(), pg_stat_get_autovacuum_scores(), pgrowlocks(), pgstat_heap(), populate_typ_list(), ReindexMultipleTables(), remove_dbtablespaces(), RemoveSubscriptionRel(), RenameTableSpace(), ThereIsAtLeastOneRole(), and vac_truncate_clog().

heap_getnextslot()

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

extern

Definition at line 1475 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(), fb(), heapgettup(), heapgettup_pagemode(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, and HeapTupleData::t_data.

heap_getnextslot_tidrange()

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

extern

Definition at line 1578 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(), fb(), heapgettup(), heapgettup_pagemode(), ItemPointerCompare(), pgstat_count_heap_getnext, HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, HeapScanDescData::rs_ctup, TableScanDescData::rs_rd, ScanDirectionIsBackward, ScanDirectionIsForward, SO_ALLOW_PAGEMODE, HeapTupleData::t_data, and HeapTupleData::t_self.

heap_hot_search_buffer()

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

extern

Definition at line 90 of file heapam_indexscan.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(), fb(), GlobalVisTestFor(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleIsHeapOnly(), HeapTupleIsHotUpdated(), HeapTupleIsSurelyDead(), HeapTupleSatisfiesVisibility(), InvalidTransactionId, ItemIdGetLength, ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerSet(), ItemPointerSetOffsetNumber(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), RecentXmin, RelationGetRelid, skip, 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  )

extern

Definition at line 8339 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, BOTTOMUP_MAX_NBLOCKS, bottomup_sort_and_shrink(), buf, BUFFER_LOCK_SHARE, BufferGetPage(), BufferIsValid(), fb(), FirstOffsetNumber, get_tablespace_maintenance_io_concurrency(), GlobalVisTestFor(), heap_hot_search_buffer(), HeapTupleHeaderAdvanceConflictHorizon(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIsHotUpdated(), i, index_delete_check_htid(), index_delete_sort(), InitNonVacuumableSnapshot, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, IsCatalogRelation(), ItemIdGetRedirect, ItemIdIsNormal, ItemIdIsRedirected, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), maintenance_io_concurrency, Min, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationData::rd_rel, ReadBuffer(), HeapTupleHeaderData::t_ctid, TransactionIdEquals, TransactionIdIsValid, and UnlockReleaseBuffer().

heap_inplace_lock()

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

extern

Definition at line 6572 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));
 
    /*
     * Register shared cache invals if necessary.  Other sessions may finish
     * inplace updates of this tuple between this step and LockTuple().  Since
     * inplace updates don't change cache keys, that's harmless.
     *
     * While it's tempting to register invals only after confirming we can
     * return true, the following obstacle precludes reordering steps that
     * way.  Registering invals might reach a CatalogCacheInitializeCache()
     * that locks "buffer".  That would hang indefinitely if running after our
     * own LockBuffer().  Hence, we must register invals before LockBuffer().
     */
    CacheInvalidateHeapTupleInplace(relation, oldtup_ptr);
 
    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, fb(), ForgetInplace_Inval(), GetCurrentCommandId(), HEAP_XMAX_IS_KEYSHR_LOCKED(), HEAP_XMAX_IS_MULTI, HeapTupleHeaderGetRawXmax(), HeapTupleSatisfiesUpdate(), InplaceUpdateTupleLock, InvalidateCatalogSnapshot(), LockBuffer(), LockTuple(), LockTupleNoKeyExclusive, MultiXactIdWait(), MultiXactStatusNoKeyUpdate, RelationGetRelid, result, 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  )

extern

Definition at line 6850 of file heapam.c.

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

References BUFFER_LOCK_UNLOCK, fb(), ForgetInplace_Inval(), InplaceUpdateTupleLock, LockBuffer(), 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  )

extern

Definition at line 6710 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 exclusive buffer lock won't stop a reader having already pinned and
     * checked visibility for this tuple. With the usual order of changes
     * (i.e. updating the buffer contents before WAL logging), a reader could
     * observe our not-yet-persistent update to relfrozenxid and update
     * datfrozenxid based on that. A crash in that moment 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]
     *
     * We avoid that by using a temporary copy of the buffer to hide our
     * change from other backends until the change has been WAL-logged. We
     * apply our change to the temporary copy and WAL-log it, before modifying
     * the real page. That way any action a reader of the in-place-updated
     * value takes will be WAL logged after this change.
     */
    START_CRIT_SECTION();
 
    MarkBufferDirty(buffer);
 
    /* 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);
 
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
    /*
     * Send invalidations to shared queue.  SearchSysCacheLocked1() assumes we
     * do this before UnlockTuple().
     */
    AtInplace_Inval();
 
    END_CRIT_SECTION();
    UnlockTuple(relation, &tuple->t_self, InplaceUpdateTupleLock);
 
    AcceptInvalidationMessages();   /* local processing of just-sent inval */
 
    /*
     * Queue a transactional inval, for logical decoding and for third-party
     * code that might have been relying on it since long before inplace
     * update adopted immediate invalidation.  See README.tuplock section
     * "Reading inplace-updated columns" for logical decoding details.
     */
    if (!IsBootstrapProcessingMode())
        CacheInvalidateHeapTuple(relation, tuple, NULL);
}

References AcceptInvalidationMessages(), Assert, AtInplace_Inval(), BUFFER_LOCK_UNLOCK, BufferGetBlock(), BufferGetPage(), BufferGetTag(), CacheInvalidateHeapTuple(), elog, END_CRIT_SECTION, ERROR, fb(), inplaceGetInvalidationMessages(), InplaceUpdateTupleLock, IsBootstrapProcessingMode, ItemPointerEquals(), ItemPointerGetOffsetNumber(), LockBuffer(), lower(), MAIN_FORKNUM, MarkBufferDirty(), memcpy(), MinSizeOfHeapInplace, MyDatabaseId, MyDatabaseTableSpace, PageSetLSN(), PreInplace_Inval(), REGBUF_STANDARD, RelationNeedsWAL, START_CRIT_SECTION, HeapTupleData::t_data, HeapTupleHeaderData::t_hoff, HeapTupleData::t_len, HeapTupleData::t_self, 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, uint32  options, BulkInsertState  bistate  )

extern

Definition at line 2005 of file heapam.c.

{
    TransactionId xid = GetCurrentTransactionId();
    HeapTuple   heaptup;
    Buffer      buffer;
    Page        page;
    Buffer      vmbuffer = InvalidBuffer;
    bool        clear_all_visible = false;
    bool        vmbuffer_modified = false;
 
    /* Cheap, simplistic check that the tuple matches the rel's rowtype. */
    Assert(HeapTupleHeaderGetNatts(tup->t_data) <=
           RelationGetNumberOfAttributes(relation));
 
    AssertHasSnapshotForToast(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);
 
    page = BufferGetPage(buffer);
 
    /*
     * 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);
 
    /* Lock the vmbuffer before the critical section */
    if (PageIsAllVisible(page))
    {
        LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
        clear_all_visible = true;
    }
 
    /* NO EREPORT(ERROR) from here till changes are logged */
    START_CRIT_SECTION();
 
    RelationPutHeapTuple(relation, buffer, heaptup,
                         (options & HEAP_INSERT_SPECULATIVE) != 0);
 
    if (clear_all_visible)
    {
        /* It's possible the VM bits were already clear */
        if (visibilitymap_clear(relation->rd_locator,
                                ItemPointerGetBlockNumber(&(heaptup->t_self)),
                                vmbuffer, VISIBILITYMAP_VALID_BITS))
            vmbuffer_modified = true;
 
        PageClearAllVisible(page);
    }
 
    /*
     * Set pd_prune_xid to trigger heap_page_prune_and_freeze() once the page
     * is full so that we can set the page all-visible in the VM on the next
     * page access.
     *
     * Setting pd_prune_xid is also handy if the inserting transaction
     * eventually aborts making this tuple DEAD and hence available for
     * pruning. If no other tuple in this page is UPDATEd/DELETEd, the aborted
     * tuple would never otherwise be pruned until next vacuum is triggered.
     *
     * Don't set it if we are in bootstrap mode or we are inserting a frozen
     * tuple, as there is no further pruning/freezing needed in those cases.
     */
    if (TransactionIdIsNormal(xid) && !(options & HEAP_INSERT_FROZEN))
        PageSetPrunable(page, xid);
 
    MarkBufferDirty(buffer);
 
    /* XLOG stuff */
    if (RelationNeedsWAL(relation))
    {
        xl_heap_insert xlrec;
        xl_heap_header xlhdr;
        XLogRecPtr  recptr;
        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 (clear_all_visible)
            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(HEAP_INSERT_BLKREF_HEAP, buffer,
                           REGBUF_STANDARD | bufflags);
        XLogRegisterBufData(HEAP_INSERT_BLKREF_HEAP, &xlhdr,
                            SizeOfHeapHeader);
        /* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
        XLogRegisterBufData(HEAP_INSERT_BLKREF_HEAP,
                            (char *) heaptup->t_data + SizeofHeapTupleHeader,
                            heaptup->t_len - SizeofHeapTupleHeader);
 
        /* filtering by origin on a row level is much more efficient */
        XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
        if (vmbuffer_modified)
            XLogRegisterBuffer(HEAP_INSERT_BLKREF_VM, vmbuffer, 0);
 
        recptr = XLogInsert(RM_HEAP_ID, info);
 
        PageSetLSN(page, recptr);
 
        if (vmbuffer_modified)
            PageSetLSN(BufferGetPage(vmbuffer), recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(buffer);
 
    /*
     * We locked vmbuffer if clear_all_visible was true regardless of whether
     * or not we ended up modifying the vmbuffer.
     */
    if (clear_all_visible)
        LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
    if (BufferIsValid(vmbuffer))
        ReleaseBuffer(vmbuffer);
 
    /*
     * If tuple is cacheable, 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, AssertHasSnapshotForToast(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), CacheInvalidateHeapTuple(), CheckForSerializableConflictIn(), END_CRIT_SECTION, fb(), FirstOffsetNumber, GetCurrentTransactionId(), heap_freetuple(), HEAP_INSERT_BLKREF_HEAP, HEAP_INSERT_BLKREF_VM, HEAP_INSERT_FROZEN, HEAP_INSERT_NO_LOGICAL, HEAP_INSERT_SPECULATIVE, heap_prepare_insert(), HeapTupleHeaderGetNatts, InvalidBlockNumber, InvalidBuffer, IsToastRelation(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), log_heap_new_cid(), MarkBufferDirty(), PageClearAllVisible(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetLSN(), PageSetPrunable, pgstat_count_heap_insert(), RelationData::rd_locator, REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetNumberOfAttributes, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SizeOfHeapHeader, SizeOfHeapInsert, SizeofHeapTupleHeader, START_CRIT_SECTION, TransactionIdIsNormal, 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 heap_insert_for_repack(), heapam_tuple_insert(), heapam_tuple_insert_speculative(), simple_heap_insert(), and toast_save_datum().

heap_lock_tuple()

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

extern

Definition at line 4728 of file heapam.c.

{
    TM_Result   result;
    ItemPointer tid = &(tuple->t_self);
    ItemId      lp;
    Page        page;
    Buffer      vmbuffer = InvalidBuffer;
    bool        unlock_vmbuffer = false;
    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);
    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));
 
    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 DO
         * SELECT/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 &&
                    !ItemPointerEquals(&tuple->t_self, &t_ctid))
                {
                    TM_Result   res;
 
                    res = heap_lock_updated_tuple(relation,
                                                  infomask, xwait, &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_failures))
                            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_failures))
                            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) &&
                !ItemPointerEquals(&tuple->t_self, &t_ctid))
            {
                TM_Result   res;
 
                res = heap_lock_updated_tuple(relation,
                                              infomask, xwait, &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);
 
    /* Lock VM buffer before entering critical section */
    if (PageIsAllVisible(page))
    {
        LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
        unlock_vmbuffer = true;
    }
 
    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))
    {
        if (visibilitymap_clear(relation->rd_locator, 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(HEAP_LOCK_BLKREF_HEAP, *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);
 
        if (cleared_all_frozen)
            XLogRegisterBuffer(HEAP_LOCK_BLKREF_VM, vmbuffer, 0);
 
        /* 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);
 
        if (cleared_all_frozen)
            PageSetLSN(BufferGetPage(vmbuffer), recptr);
    }
 
    END_CRIT_SECTION();
 
    /* release VM lock first, since it covers many heap blocks */
    if (unlock_vmbuffer)
    {
        LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
        unlock_vmbuffer = false;
    }
 
    result = TM_Ok;
 
out_locked:
    LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
    Assert(!unlock_vmbuffer);
 
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, fb(), get_mxact_status_for_lock(), GetCurrentTransactionId(), GetMultiXactIdMembers(), heap_acquire_tuplock(), HEAP_KEYS_UPDATED, HEAP_LOCK_BLKREF_HEAP, HEAP_LOCK_BLKREF_VM, 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, InvalidBuffer, InvalidCommandId, ItemIdGetLength, ItemIdIsNormal, ItemPointerCopy(), ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), LockTupleExclusive, LockTupleKeyShare, LockTupleNoKeyExclusive, LockTupleShare, LockWaitBlock, LockWaitError, LockWaitSkip, log_lock_failures, MarkBufferDirty(), mode, MultiXactIdSetOldestMember(), MultiXactIdWait(), MultiXactStatusNoKeyUpdate, PageGetItem(), PageGetItemId(), PageIsAllVisible(), PageSetLSN(), pfree(), RelationData::rd_locator, ReadBuffer(), REGBUF_STANDARD, RelationGetRelationName, RelationGetRelid, RelationNeedsWAL, ReleaseBuffer(), result, 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, TM_FailureData::xmax, and xmax_infomask_changed().

Referenced by heapam_tuple_lock().

heap_multi_insert()

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

extern

Definition at line 2308 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));
 
    AssertHasSnapshotForToast(relation);
 
    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        clear_all_visible = false;
        bool        all_frozen_set = false;
        bool        vmbuffer_modified = 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;
            /* Lock the vmbuffer before entering the critical section */
            LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
        }
        else if (PageIsAllVisible(page) && !(options & HEAP_INSERT_FROZEN))
        {
            clear_all_visible = true;
            /* Lock the vmbuffer before entering the critical section */
            LockBuffer(vmbuffer, BUFFER_LOCK_EXCLUSIVE);
        }
 
        /* 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-frozen and update the visibility map. We're
         * already holding a pin on the vmbuffer.
         */
        if (clear_all_visible)
        {
            Assert(!(options & HEAP_INSERT_FROZEN));
            /* It's possible the VM bits were already clear */
            if (visibilitymap_clear(relation->rd_locator,
                                    BufferGetBlockNumber(buffer),
                                    vmbuffer, VISIBILITYMAP_VALID_BITS))
                vmbuffer_modified = true;
 
            PageClearAllVisible(page);
        }
        else if (all_frozen_set)
        {
            PageSetAllVisible(page);
            PageClearPrunable(page);
            visibilitymap_set(BufferGetBlockNumber(buffer),
                              vmbuffer,
                              VISIBILITYMAP_ALL_VISIBLE |
                              VISIBILITYMAP_ALL_FROZEN,
                              relation->rd_locator);
        }
 
        /*
         * Set pd_prune_xid. See heap_insert() for more on why we do this when
         * inserting tuples. This only makes sense if we aren't already
         * setting the page frozen in the VM and we're not in bootstrap mode.
         */
        if (!all_frozen_set && TransactionIdIsNormal(xid))
            PageSetPrunable(page, xid);
 
        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(!(clear_all_visible && all_frozen_set));
 
            xlrec->flags = 0;
            if (clear_all_visible)
                xlrec->flags = XLH_INSERT_ALL_VISIBLE_CLEARED;
 
            /*
             * We don't have to worry about including a conflict xid in the
             * WAL record, as HEAP_INSERT_FROZEN intentionally violates
             * visibility rules.
             */
            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(HEAP_MULTI_INSERT_BLKREF_HEAP, buffer,
                               REGBUF_STANDARD | bufflags);
            if (all_frozen_set || vmbuffer_modified)
                XLogRegisterBuffer(HEAP_MULTI_INSERT_BLKREF_VM, vmbuffer, 0);
 
            XLogRegisterBufData(HEAP_MULTI_INSERT_BLKREF_HEAP, 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);
            if (all_frozen_set || vmbuffer_modified)
            {
                Assert(BufferIsDirty(vmbuffer));
                PageSetLSN(BufferGetPage(vmbuffer), recptr);
            }
        }
 
        END_CRIT_SECTION();
 
        /*
         * We locked vmbuffer if clear_all_visible was true regardless of
         * whether or not we ended up modifying the vmbuffer.
         */
        if (all_frozen_set || clear_all_visible)
            LockBuffer(vmbuffer, BUFFER_LOCK_UNLOCK);
 
        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 cacheable, 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, AssertHasSnapshotForToast(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsDirty(), CacheInvalidateHeapTuple(), CHECK_FOR_INTERRUPTS, CheckForSerializableConflictIn(), xl_multi_insert_tuple::datalen, END_CRIT_SECTION, ExecFetchSlotHeapTuple(), fb(), GetCurrentTransactionId(), HEAP_DEFAULT_FILLFACTOR, HEAP_INSERT_FROZEN, HEAP_INSERT_NO_LOGICAL, HEAP_MULTI_INSERT_BLKREF_HEAP, HEAP_MULTI_INSERT_BLKREF_VM, heap_multi_insert_pages(), heap_prepare_insert(), i, init, InvalidBlockNumber, InvalidBuffer, IsCatalogRelation(), ItemPointerGetOffsetNumber(), LockBuffer(), log_heap_new_cid(), MarkBufferDirty(), MAXALIGN, memcpy(), PageClearAllVisible(), PageClearPrunable, PageGetHeapFreeSpace(), PageGetMaxOffsetNumber(), PageIsAllVisible(), PageSetAllVisible(), PageSetLSN(), PageSetPrunable, palloc(), pgstat_count_heap_insert(), RelationData::rd_locator, REGBUF_KEEP_DATA, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetBufferForTuple(), RelationGetRelid, RelationGetTargetPageFreeSpace, RelationIsAccessibleInLogicalDecoding, RelationIsLogicallyLogged, RelationNeedsWAL, RelationPutHeapTuple(), ReleaseBuffer(), SHORTALIGN, SizeOfHeapMultiInsert, SizeofHeapTupleHeader, SizeOfMultiInsertTuple, START_CRIT_SECTION, xl_multi_insert_tuple::t_hoff, xl_multi_insert_tuple::t_infomask, xl_multi_insert_tuple::t_infomask2, HeapTupleData::t_tableOid, TransactionIdIsNormal, TupleTableSlot::tts_tableOid, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_clear(), 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 ( PruneFreezeParams *  params, PruneFreezeResult *  presult, OffsetNumber *  off_loc, TransactionId *  new_relfrozen_xid, MultiXactId *  new_relmin_mxid  )

extern

Definition at line 1112 of file pruneheap.c.

{
    PruneState  prstate;
    bool        do_freeze;
    bool        do_prune;
    bool        do_hint_prune;
    bool        do_set_vm;
    bool        did_tuple_hint_fpi;
    int64       fpi_before = pgWalUsage.wal_fpi;
    TransactionId conflict_xid;
 
    /* Initialize prstate */
    prune_freeze_setup(params,
                       new_relfrozen_xid, new_relmin_mxid,
                       presult, &prstate);
 
    /*
     * If the VM is set but PD_ALL_VISIBLE is clear, fix that corruption
     * before pruning and freezing so that the page and VM start out in a
     * consistent state.
     */
    if ((prstate.old_vmbits & VISIBILITYMAP_VALID_BITS) &&
        !PageIsAllVisible(prstate.page))
        heap_page_fix_vm_corruption(&prstate, InvalidOffsetNumber,
                                    VM_CORRUPT_MISSING_PAGE_HINT);
 
    /*
     * If the page is already all-frozen, or already all-visible when freezing
     * is not being attempted, take the fast path, skipping pruning and
     * freezing code entirely. This must be done after fixing any discrepancy
     * between the page-level visibility hint and the VM, since that may have
     * cleared old_vmbits.
     */
    if ((params->options & HEAP_PAGE_PRUNE_ALLOW_FAST_PATH) != 0 &&
        ((prstate.old_vmbits & VISIBILITYMAP_ALL_FROZEN) ||
         ((prstate.old_vmbits & VISIBILITYMAP_ALL_VISIBLE) &&
          !prstate.attempt_freeze)))
    {
        prune_freeze_fast_path(&prstate, presult);
        return;
    }
 
    /*
     * Examine all line pointers and tuple visibility information to determine
     * which line pointers should change state and which tuples may be frozen.
     * Prepare queue of state changes to later be executed in a critical
     * section.
     */
    prune_freeze_plan(&prstate, off_loc);
 
    /*
     * After processing all the live tuples on the page, if the newest xmin
     * amongst them may be considered running by any snapshot, the page cannot
     * be all-visible. This should be done before determining whether or not
     * to opportunistically freeze.
     */
    if (prstate.set_all_visible &&
        TransactionIdIsNormal(prstate.newest_live_xid) &&
        GlobalVisTestXidConsideredRunning(prstate.vistest,
                                          prstate.newest_live_xid,
                                          true))
        prstate.set_all_visible = prstate.set_all_frozen = false;
 
    /*
     * If checksums are enabled, calling heap_prune_satisfies_vacuum() while
     * checking tuple visibility information in prune_freeze_plan() may have
     * caused an FPI to be emitted.
     */
    did_tuple_hint_fpi = fpi_before != pgWalUsage.wal_fpi;
 
    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_prune = PageGetPruneXid(prstate.page) != prstate.new_prune_xid ||
        PageIsFull(prstate.page);
 
    /*
     * Decide if we want to go ahead with freezing according to the freeze
     * plans we prepared, or not.
     */
    do_freeze = heap_page_will_freeze(did_tuple_hint_fpi,
                                      do_prune,
                                      do_hint_prune,
                                      &prstate);
 
    /*
     * While scanning the line pointers, we did not clear
     * set_all_visible/set_all_frozen when encountering LP_DEAD items because
     * we wanted the decision whether or not to freeze the page to be
     * unaffected by the short-term presence of LP_DEAD items.  These LP_DEAD
     * items are 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 we finished determining whether or not to freeze the page,
     * update set_all_visible and set_all_frozen so that they reflect the true
     * state of the page for setting PD_ALL_VISIBLE and VM bits.
     */
    if (prstate.lpdead_items > 0)
        prstate.set_all_visible = prstate.set_all_frozen = false;
 
    Assert(!prstate.set_all_frozen || prstate.set_all_visible);
    Assert(!prstate.set_all_visible || prstate.attempt_set_vm);
    Assert(!prstate.set_all_visible || (prstate.lpdead_items == 0));
 
    do_set_vm = heap_page_will_set_vm(&prstate, params->reason, do_prune, do_freeze);
 
    /*
     * new_vmbits should be 0 regardless of whether or not the page is
     * all-visible if we do not intend to set the VM.
     */
    Assert(do_set_vm || prstate.new_vmbits == 0);
 
    /*
     * The snapshot conflict horizon for the whole record is the most
     * conservative (newest) horizon required by any change in the record.
     */
    conflict_xid = InvalidTransactionId;
    if (do_set_vm)
        conflict_xid = prstate.newest_live_xid;
    if (do_freeze && TransactionIdFollows(prstate.pagefrz.FreezePageConflictXid, conflict_xid))
        conflict_xid = prstate.pagefrz.FreezePageConflictXid;
    if (do_prune && TransactionIdFollows(prstate.latest_xid_removed, conflict_xid))
        conflict_xid = prstate.latest_xid_removed;
 
    /* Lock vmbuffer before entering a critical section */
    if (do_set_vm)
        LockBuffer(prstate.vmbuffer, BUFFER_LOCK_EXCLUSIVE);
 
    /* Any error while applying the changes is critical */
    START_CRIT_SECTION();
 
    if (do_hint_prune)
    {
        /*
         * Update the page's pd_prune_xid field to either zero, or the lowest
         * XID of any soon-prunable tuple.
         */
        ((PageHeader) prstate.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(prstate.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 or set
         * PD_ALL_VISIBLE, we will mark the buffer dirty below.
         *
         * Setting PD_ALL_VISIBLE is fully WAL-logged because it is forbidden
         * for the VM to be set and PD_ALL_VISIBLE to be clear.
         */
        if (!do_freeze && !do_prune && !do_set_vm)
            MarkBufferDirtyHint(prstate.buffer, true);
    }
 
    if (do_prune || do_freeze || do_set_vm)
    {
        /* Apply the planned item changes and repair page fragmentation. */
        if (do_prune)
        {
            heap_page_prune_execute(prstate.buffer, false,
                                    prstate.redirected, prstate.nredirected,
                                    prstate.nowdead, prstate.ndead,
                                    prstate.nowunused, prstate.nunused);
        }
 
        if (do_freeze)
            heap_freeze_prepared_tuples(prstate.buffer, prstate.frozen, prstate.nfrozen);
 
        /* Set the visibility map and page visibility hint */
        if (do_set_vm)
        {
            /*
             * While it is valid for PD_ALL_VISIBLE to be set when the
             * corresponding VM bit is clear, we strongly prefer to keep them
             * in sync.
             *
             * The heap buffer must be marked dirty before adding it to the
             * WAL chain when setting the VM. We don't worry about
             * unnecessarily dirtying the heap buffer if PD_ALL_VISIBLE is
             * already set, though. It is extremely rare to have a clean heap
             * buffer with PD_ALL_VISIBLE already set and the VM bits clear,
             * so there is no point in optimizing it.
             */
            PageSetAllVisible(prstate.page);
            PageClearPrunable(prstate.page);
            visibilitymap_set(prstate.block, prstate.vmbuffer, prstate.new_vmbits,
                              prstate.relation->rd_locator);
        }
 
        MarkBufferDirty(prstate.buffer);
 
        /*
         * Emit a WAL XLOG_HEAP2_PRUNE* record showing what we did
         */
        if (RelationNeedsWAL(prstate.relation))
        {
            log_heap_prune_and_freeze(prstate.relation, prstate.buffer,
                                      do_set_vm ? prstate.vmbuffer : InvalidBuffer,
                                      do_set_vm ? prstate.new_vmbits : 0,
                                      conflict_xid,
                                      true, /* cleanup lock */
                                      params->reason,
                                      prstate.frozen, prstate.nfrozen,
                                      prstate.redirected, prstate.nredirected,
                                      prstate.nowdead, prstate.ndead,
                                      prstate.nowunused, prstate.nunused);
        }
    }
 
    END_CRIT_SECTION();
 
    if (do_set_vm)
        LockBuffer(prstate.vmbuffer, BUFFER_LOCK_UNLOCK);
 
    /*
     * During its second pass over the heap, VACUUM calls
     * heap_page_would_be_all_visible() to determine whether a page is
     * all-visible and all-frozen. The logic here is similar. After completing
     * pruning and freezing, use an assertion to verify that our results
     * remain consistent with heap_page_would_be_all_visible(). It's also a
     * valuable cross-check of the page state after pruning and freezing.
     */
#ifdef USE_ASSERT_CHECKING
    if (prstate.set_all_visible)
    {
        TransactionId debug_cutoff;
        bool        debug_all_frozen;
 
        Assert(prstate.lpdead_items == 0);
 
        Assert(heap_page_is_all_visible(prstate.relation, prstate.buffer,
                                        prstate.vistest,
                                        &debug_all_frozen,
                                        &debug_cutoff, off_loc));
 
        Assert(!TransactionIdIsValid(debug_cutoff) ||
               debug_cutoff == prstate.newest_live_xid);
 
        /*
         * It's possible the page is composed entirely of frozen tuples but is
         * not set all-frozen in the VM and did not pass
         * HEAP_PAGE_PRUNE_FREEZE. In this case, it's possible
         * heap_page_is_all_visible() finds the page completely frozen, even
         * though prstate.set_all_frozen is false.
         */
        Assert(!prstate.set_all_frozen || debug_all_frozen);
    }
#endif
 
    /* 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;
    presult->hastup = prstate.hastup;
 
    presult->lpdead_items = prstate.lpdead_items;
    /* the presult->deadoffsets array was already filled in */
 
    presult->newly_all_visible = false;
    presult->newly_all_frozen = false;
    presult->newly_all_visible_frozen = false;
    if (do_set_vm)
    {
        if ((prstate.old_vmbits & VISIBILITYMAP_ALL_VISIBLE) == 0)
        {
            presult->newly_all_visible = true;
            if (prstate.set_all_frozen)
                presult->newly_all_visible_frozen = true;
        }
        else if ((prstate.old_vmbits & VISIBILITYMAP_ALL_FROZEN) == 0 &&
                 prstate.set_all_frozen)
            presult->newly_all_frozen = true;
    }
 
    if (prstate.attempt_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 Assert, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, END_CRIT_SECTION, fb(), GlobalVisTestXidConsideredRunning(), heap_freeze_prepared_tuples(), heap_page_fix_vm_corruption(), HEAP_PAGE_PRUNE_ALLOW_FAST_PATH, heap_page_prune_execute(), heap_page_will_freeze(), heap_page_will_set_vm(), InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, LockBuffer(), log_heap_prune_and_freeze(), MarkBufferDirty(), MarkBufferDirtyHint(), PruneFreezeParams::options, PageClearFull(), PageClearPrunable, PageGetPruneXid(), PageIsAllVisible(), PageIsFull(), PageSetAllVisible(), pgWalUsage, prune_freeze_fast_path(), prune_freeze_plan(), prune_freeze_setup(), PruneFreezeParams::reason, RelationNeedsWAL, START_CRIT_SECTION, TransactionIdFollows(), TransactionIdIsNormal, TransactionIdIsValid, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_set(), VISIBILITYMAP_VALID_BITS, VM_CORRUPT_MISSING_PAGE_HINT, and WalUsage::wal_fpi.

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  )

extern

Definition at line 2087 of file pruneheap.c.

{
    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(), fb(), 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, Buffer *  vmbuffer, bool  rel_read_only  )

extern

Definition at line 272 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 and no
     * inserts inserted new tuples that may be visible to all).
     */
    prune_xid = PageGetPruneXid(page);
    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, true))
        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)
    {
        bool        record_free_space = false;
        Size        freespace = 0;
 
        /* 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;
            PruneFreezeParams params;
 
            visibilitymap_pin(relation, BufferGetBlockNumber(buffer),
                              vmbuffer);
 
            params.relation = relation;
            params.buffer = buffer;
            params.vmbuffer = *vmbuffer;
            params.reason = PRUNE_ON_ACCESS;
            params.vistest = vistest;
            params.cutoffs = NULL;
 
            /*
             * We don't pass the HEAP_PAGE_PRUNE_MARK_UNUSED_NOW option
             * regardless of whether or not the relation has indexes, since we
             * cannot safely determine that during on-access pruning with the
             * current implementation.
             */
            params.options = HEAP_PAGE_PRUNE_ALLOW_FAST_PATH;
            if (rel_read_only)
                params.options |= HEAP_PAGE_PRUNE_SET_VM;
 
            heap_page_prune_and_freeze(&params, &presult, &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);
 
            /*
             * If this prune newly set the page all-visible, VACUUM may later
             * skip the page and not update the free space map (FSM) for it.
             * Keep the FSM from going stale by recording it now. We do not
             * want to update the freespace map otherwise, to reserve
             * freespace on this page for HOT updates.
             */
            if (presult.newly_all_visible)
            {
                record_free_space = true;
                freespace = PageGetHeapFreeSpace(page);
            }
        }
 
        /* And release buffer lock */
        LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
        /*
         * RecordPageWithFreeSpace() only dirties the FSM when the recorded
         * free-space category actually changes. Note that vacuum will still
         * do FreeSpaceMapVacuum() for ranges of pages that are skipped, so we
         * don't have to worry about that here.
         */
        if (record_free_space)
            RecordPageWithFreeSpace(relation, BufferGetBlockNumber(buffer), freespace);
    }
}

References PruneFreezeParams::buffer, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), ConditionalLockBufferForCleanup(), PruneFreezeParams::cutoffs, fb(), GlobalVisTestFor(), GlobalVisTestIsRemovableXid(), HEAP_DEFAULT_FILLFACTOR, HEAP_PAGE_PRUNE_ALLOW_FAST_PATH, heap_page_prune_and_freeze(), HEAP_PAGE_PRUNE_SET_VM, LockBuffer(), Max, PruneFreezeParams::options, PageGetHeapFreeSpace(), PageGetPruneXid(), PageIsFull(), pgstat_update_heap_dead_tuples(), PRUNE_ON_ACCESS, PruneFreezeParams::reason, RecordPageWithFreeSpace(), RecoveryInProgress(), PruneFreezeParams::relation, RelationGetTargetPageFreeSpace, TransactionIdIsValid, visibilitymap_pin(), PruneFreezeParams::vistest, and PruneFreezeParams::vmbuffer.

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  )

extern

Definition at line 7547 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(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, fb(), HEAP_FREEZE_CHECK_XMAX_ABORTED, HEAP_FREEZE_CHECK_XMIN_COMMITTED, HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderXminFrozen(), i, PageGetItem(), PageGetItemId(), TransactionIdDidCommit(), TransactionIdIsNormal, and unlikely.

Referenced by heap_page_will_freeze().

heap_prepare_freeze_tuple()

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

extern

heap_prepare_pagescan()

void heap_prepare_pagescan ( TableScanDesc  sscan )

extern

Definition at line 619 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, &scan->rs_vmbuffer,
                        sscan->rs_flags & SO_HINT_REL_READ_ONLY);
 
    /*
     * 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(), fb(), 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, HeapScanDescData::rs_vmbuffer, SO_ALLOW_PAGEMODE, SO_HINT_REL_READ_ONLY, 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  )

extern

Definition at line 1332 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;
    }
 
    if (BufferIsValid(scan->rs_vmbuffer))
    {
        ReleaseBuffer(scan->rs_vmbuffer);
        scan->rs_vmbuffer = 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(), fb(), initscan(), InvalidBuffer, IsMVCCSnapshot, read_stream_reset(), ReleaseBuffer(), HeapScanDescData::rs_base, HeapScanDescData::rs_cbuf, TableScanDescData::rs_flags, HeapScanDescData::rs_read_stream, TableScanDescData::rs_snapshot, HeapScanDescData::rs_vmbuffer, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, and SO_ALLOW_SYNC.

heap_set_tidrange()

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

extern

Definition at line 1505 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 fb(), FirstOffsetNumber, heap_setscanlimits(), ItemPointerCompare(), ItemPointerCopy(), ItemPointerGetBlockNumberNoCheck(), ItemPointerSet(), MaxOffsetNumber, and HeapScanDescData::rs_nblocks.

heap_setscanlimits()

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

extern

Definition at line 503 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, fb(), 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 )

extern

Definition at line 8031 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_would_be_all_visible().

heap_tuple_should_freeze()

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

extern

heap_update()

TM_Result heap_update ( Relation  relation, const ItemPointerData *  otid, HeapTuple  newtup, CommandId  cid, uint32  options, Snapshot  crosscheck, bool  wait, TM_FailureData *  tmfd, LockTupleMode *  lockmode, TU_UpdateIndexes *  update_indexes  )

extern

heap_vacuum_rel()

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

extern

Definition at line 624 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;
    Size        dead_items_max_bytes = 0;
 
    verbose = (params->options & VACOPT_VERBOSE) != 0;
    instrument = (verbose || (AmAutoVacuumWorkerProcess() &&
                              params->log_vacuum_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));
    if (AmAutoVacuumWorkerProcess())
        pgstat_progress_update_param(PROGRESS_VACUUM_STARTED_BY,
                                     params->is_wraparound
                                     ? PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND
                                     : PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM);
    else
        pgstat_progress_update_param(PROGRESS_VACUUM_STARTED_BY,
                                     PROGRESS_VACUUM_STARTED_BY_MANUAL);
 
    /*
     * 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 = palloc0_object(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_array(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->num_dead_items_resets = 0;
    vacrel->total_dead_items_bytes = 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->new_all_visible_pages = 0;
    vacrel->new_all_visible_all_frozen_pages = 0;
    vacrel->new_all_frozen_pages = 0;
 
    vacrel->worker_usage.vacuum.nlaunched = 0;
    vacrel->worker_usage.vacuum.nplanned = 0;
    vacrel->worker_usage.cleanup.nlaunched = 0;
    vacrel->worker_usage.cleanup.nplanned = 0;
 
    /*
     * 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->rel_pages = orig_rel_pages = RelationGetNumberOfBlocks(rel);
    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);
 
    /* Report the vacuum mode: 'normal' or 'aggressive' */
    pgstat_progress_update_param(PROGRESS_VACUUM_MODE,
                                 vacrel->aggressive
                                 ? PROGRESS_VACUUM_MODE_AGGRESSIVE
                                 : PROGRESS_VACUUM_MODE_NORMAL);
 
    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);
 
#ifdef USE_INJECTION_POINTS
 
    /*
     * Used by tests to pause before parallel vacuum is launched, allowing
     * test code to modify configuration that the leader then propagates to
     * workers.
     */
    if (AmAutoVacuumWorkerProcess() && ParallelVacuumIsActive(vacrel))
        INJECTION_POINT("autovacuum-start-parallel-vacuum", NULL);
#endif
 
    /*
     * Call lazy_scan_heap to perform all required heap pruning, index
     * vacuuming, and heap vacuuming (plus related processing)
     */
    lazy_scan_heap(vacrel);
 
    /*
     * Save dead items max_bytes and update the memory usage statistics before
     * cleanup, they are freed in parallel vacuum cases during
     * dead_items_cleanup().
     */
    dead_items_max_bytes = vacrel->dead_items_info->max_bytes;
    vacrel->total_dead_items_bytes += TidStoreMemoryUsage(vacrel->dead_items);
 
    /*
     * 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(rel,
                         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_vacuum_min_duration == 0 ||
            TimestampDifferenceExceeds(starttime, endtime,
                                       params->log_vacuum_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->new_all_visible_pages,
                             vacrel->new_all_visible_all_frozen_pages +
                             vacrel->new_all_frozen_pages,
                             vacrel->new_all_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);
 
            if (vacrel->worker_usage.vacuum.nplanned > 0)
                appendStringInfo(&buf,
                                 _("parallel workers: index vacuum: %d planned, %d launched in total\n"),
                                 vacrel->worker_usage.vacuum.nplanned,
                                 vacrel->worker_usage.vacuum.nlaunched);
 
            if (vacrel->worker_usage.cleanup.nplanned > 0)
                appendStringInfo(&buf,
                                 _("parallel workers: index cleanup: %d planned, %d launched\n"),
                                 vacrel->worker_usage.cleanup.nplanned,
                                 vacrel->worker_usage.cleanup.nlaunched);
 
            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, %" PRIu64 " full page image bytes, %" PRId64 " buffers full\n"),
                             walusage.wal_records,
                             walusage.wal_fpi,
                             walusage.wal_bytes,
                             walusage.wal_fpi_bytes,
                             walusage.wal_buffers_full);
 
            /*
             * Report the dead items memory usage.
             *
             * The num_dead_items_resets counter increases when we reset the
             * collected dead items, so the counter is non-zero if at least
             * one dead items are collected, even if index vacuuming is
             * disabled.
             */
            appendStringInfo(&buf,
                             ngettext("memory usage: dead item storage %.2f MB accumulated across %d reset (limit %.2f MB each)\n",
                                      "memory usage: dead item storage %.2f MB accumulated across %d resets (limit %.2f MB each)\n",
                                      vacrel->num_dead_items_resets),
                             (double) vacrel->total_dead_items_bytes / (1024 * 1024),
                             vacrel->num_dead_items_resets,
                             (double) dead_items_max_bytes / (1024 * 1024));
            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 _, AmAutoVacuumWorkerProcess, appendStringInfo(), appendStringInfoString(), ErrorContextCallback::arg, Assert, buf, BufferUsageAccumDiff(), ErrorContextCallback::callback, dead_items_alloc(), dead_items_cleanup(), ereport, errmsg, errmsg_internal(), error_context_stack, fb(), get_database_name(), get_namespace_name(), GetCurrentTimestamp(), GlobalVisTestFor(), heap_vacuum_eager_scan_setup(), i, VacuumParams::index_cleanup, INFO, initStringInfo(), INJECTION_POINT, InvalidMultiXactId, InvalidTransactionId, VacuumParams::is_wraparound, IsInParallelMode(), lazy_check_wraparound_failsafe(), lazy_scan_heap(), lazy_truncate_heap(), BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, LOG, VacuumParams::log_vacuum_min_duration, Max, MultiXactIdPrecedesOrEquals(), MyBEEntry, MyDatabaseId, ngettext, NoLock, IndexBulkDeleteResult::num_pages, VacuumParams::nworkers, VacuumParams::options, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, palloc0(), palloc0_object, palloc_array, ParallelVacuumIsActive, 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, ErrorContextCallback::previous, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_DELAY_TIME, PROGRESS_VACUUM_MODE, PROGRESS_VACUUM_MODE_AGGRESSIVE, PROGRESS_VACUUM_MODE_NORMAL, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, PROGRESS_VACUUM_STARTED_BY, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND, PROGRESS_VACUUM_STARTED_BY_MANUAL, pstrdup(), ReadNextTransactionId(), RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, should_attempt_truncation(), PgBackendStatus::st_progress_param, TidStoreMemoryUsage(), TimestampDifference(), TimestampDifferenceExceeds(), track_cost_delay_timing, track_io_timing, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, 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, verbose, visibilitymap_count(), WalUsage::wal_buffers_full, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_fpi_bytes, WalUsage::wal_records, and WalUsageAccumDiff().

heapam_index_fetch_begin()

IndexFetchTableData * heapam_index_fetch_begin ( Relation  rel, uint32  flags  )

extern

Definition at line 28 of file heapam_indexscan.c.

{
    IndexFetchHeapData *hscan = palloc0_object(IndexFetchHeapData);
 
    hscan->xs_base.rel = rel;
    hscan->xs_base.flags = flags;
    hscan->xs_cbuf = InvalidBuffer;
    hscan->xs_blk = InvalidBlockNumber;
    hscan->xs_vmbuffer = InvalidBuffer;
 
    return &hscan->xs_base;
}

References fb(), InvalidBlockNumber, InvalidBuffer, and palloc0_object.

heapam_index_fetch_end()

void heapam_index_fetch_end ( IndexFetchTableData *  scan )

extern

Definition at line 54 of file heapam_indexscan.c.

{
    IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;
 
    /* drop pin if there's a pinned heap page */
    if (BufferIsValid(hscan->xs_cbuf))
        ReleaseBuffer(hscan->xs_cbuf);
 
    /* drop pin if there's a pinned visibility map page */
    if (BufferIsValid(hscan->xs_vmbuffer))
        ReleaseBuffer(hscan->xs_vmbuffer);
 
    pfree(hscan);
}

References BufferIsValid(), fb(), pfree(), and ReleaseBuffer().

heapam_index_fetch_reset()

void heapam_index_fetch_reset ( IndexFetchTableData *  scan )

extern

Definition at line 42 of file heapam_indexscan.c.

{
    /*
     * Resets are a no-op.
     *
     * Deliberately avoid dropping pins now held in xs_cbuf and xs_vmbuffer.
     * This saves cycles during certain tight nested loop joins (it can avoid
     * repeated pinning and unpinning of the same buffer across rescans).
     */
}

heapam_index_fetch_tuple()

bool heapam_index_fetch_tuple ( struct IndexFetchTableData *  scan, ItemPointer  tid, Snapshot  snapshot, TupleTableSlot *  slot, bool *  heap_continue, bool *  all_dead  )

extern

Definition at line 232 of file heapam_indexscan.c.

{
    IndexFetchHeapData *hscan = (IndexFetchHeapData *) scan;
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    bool        got_heap_tuple;
 
    Assert(TTS_IS_BUFFERTUPLE(slot));
 
    /* We can skip the buffer-switching logic if we're on the same page. */
    if (hscan->xs_blk != ItemPointerGetBlockNumber(tid))
    {
        Assert(!*heap_continue);
 
        /* Remember this buffer's block number for next time */
        hscan->xs_blk = ItemPointerGetBlockNumber(tid);
 
        if (BufferIsValid(hscan->xs_cbuf))
            ReleaseBuffer(hscan->xs_cbuf);
 
        hscan->xs_cbuf = ReadBuffer(hscan->xs_base.rel, hscan->xs_blk);
 
        /*
         * Prune page when it is pinned for the first time
         */
        heap_page_prune_opt(hscan->xs_base.rel, hscan->xs_cbuf,
                            &hscan->xs_vmbuffer,
                            hscan->xs_base.flags & SO_HINT_REL_READ_ONLY);
    }
 
    Assert(BufferGetBlockNumber(hscan->xs_cbuf) == hscan->xs_blk);
    Assert(hscan->xs_blk == ItemPointerGetBlockNumber(tid));
 
    /* Obtain share-lock on the buffer so we can examine visibility */
    LockBuffer(hscan->xs_cbuf, BUFFER_LOCK_SHARE);
    got_heap_tuple = heap_hot_search_buffer(tid,
                                            hscan->xs_base.rel,
                                            hscan->xs_cbuf,
                                            snapshot,
                                            &bslot->base.tupdata,
                                            all_dead,
                                            !*heap_continue);
    bslot->base.tupdata.t_self = *tid;
    LockBuffer(hscan->xs_cbuf, BUFFER_LOCK_UNLOCK);
 
    if (got_heap_tuple)
    {
        /*
         * Only in a non-MVCC snapshot can more than one member of the HOT
         * chain be visible.
         */
        *heap_continue = !IsMVCCLikeSnapshot(snapshot);
 
        slot->tts_tableOid = RelationGetRelid(scan->rel);
        ExecStoreBufferHeapTuple(&bslot->base.tupdata, slot, hscan->xs_cbuf);
    }
    else
    {
        /* We've reached the end of the HOT chain. */
        *heap_continue = false;
    }
 
    return got_heap_tuple;
}

References Assert, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferIsValid(), ExecStoreBufferHeapTuple(), fb(), heap_hot_search_buffer(), heap_page_prune_opt(), IsMVCCLikeSnapshot, ItemPointerGetBlockNumber(), LockBuffer(), ReadBuffer(), IndexFetchTableData::rel, RelationGetRelid, ReleaseBuffer(), SO_HINT_REL_READ_ONLY, TTS_IS_BUFFERTUPLE, and TupleTableSlot::tts_tableOid.

HeapCheckForSerializableConflictOut()

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

extern

Definition at line 9442 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, fb(), 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 )

extern

Definition at line 1437 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, GlobalVisState *  vistest  )

extern

Definition at line 1381 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),
                                       true);
}

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

HeapTupleSatisfiesMVCCBatch()

int HeapTupleSatisfiesMVCCBatch ( Snapshot  snapshot, Buffer  buffer, int  ntups, BatchMVCCState *  batchmvcc, OffsetNumber *  vistuples_dense  )

extern

Definition at line 1690 of file heapam_visibility.c.

{
    int         nvis = 0;
    SetHintBitsState state = SHB_INITIAL;
 
    Assert(IsMVCCSnapshot(snapshot));
 
    for (int i = 0; i < ntups; i++)
    {
        bool        valid;
        HeapTuple   tup = &batchmvcc->tuples[i];
 
        valid = HeapTupleSatisfiesMVCC(tup, snapshot, buffer, &state);
        batchmvcc->visible[i] = valid;
 
        if (likely(valid))
        {
            vistuples_dense[nvis] = tup->t_self.ip_posid;
            nvis++;
        }
    }
 
    if (state == SHB_ENABLED)
        BufferFinishSetHintBits(buffer, true, true);
 
    return nvis;
}

References Assert, BufferFinishSetHintBits(), fb(), HeapTupleSatisfiesMVCC(), i, IsMVCCSnapshot, likely, SHB_ENABLED, and SHB_INITIAL.

Referenced by page_collect_tuples().

HeapTupleSatisfiesUpdate()

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

extern

Definition at line 511 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;
 
        else if (!HeapTupleCleanMoved(tuple, buffer))
            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_XMAX_COMMITTED, HEAP_XMAX_INVALID, HEAP_XMAX_IS_LOCKED_ONLY(), HEAP_XMAX_IS_MULTI, HEAP_XMIN_COMMITTED, HEAP_XMIN_INVALID, HeapTupleCleanMoved(), HeapTupleGetUpdateXid(), HeapTupleHeaderGetCmax(), HeapTupleHeaderGetCmin(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), 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  )

extern

Definition at line 1113 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, fb(), HEAPTUPLE_DEAD, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuumHorizon(), InvalidTransactionId, TransactionIdIsValid, and TransactionIdPrecedes().

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

HeapTupleSatisfiesVacuumHorizon()

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

extern

Definition at line 1147 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;
        else if (!HeapTupleCleanMoved(tuple, buffer))
            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, fb(), HEAP_LOCKED_UPGRADED(), 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, HeapTupleCleanMoved(), HeapTupleGetUpdateXid(), HeapTupleHeaderGetRawXmax(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderGetUpdateXid(), 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_page_would_be_all_visible(), heap_prune_satisfies_vacuum(), heapam_scan_analyze_next_tuple(), HeapTupleSatisfiesNonVacuumable(), and HeapTupleSatisfiesVacuum().

HeapTupleSatisfiesVisibility()

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

extern

Definition at line 1732 of file heapam_visibility.c.

{
    switch (snapshot->snapshot_type)
    {
        case SNAPSHOT_MVCC:
            return HeapTupleSatisfiesMVCC(htup, snapshot, buffer, NULL);
        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 fb(), 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(), pgstat_heap(), SampleHeapTupleVisible(), and ScanSourceDatabasePgClassPage().

HeapTupleSetHintBits()

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

extern

Definition at line 212 of file heapam_visibility.c.

{
    /*
     * The uses from heapam.c rely on being able to perform the hint bit
     * updates, which can only be guaranteed if we are holding an exclusive
     * lock on the buffer - which all callers are doing.
     */
    Assert(BufferIsLockedByMeInMode(buffer, BUFFER_LOCK_EXCLUSIVE));
 
    SetHintBits(tuple, buffer, infomask, xid);
}

References Assert, BUFFER_LOCK_EXCLUSIVE, BufferIsLockedByMeInMode(), fb(), and SetHintBits().

Referenced by UpdateXmaxHintBits().

log_heap_prune_and_freeze()

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

extern

Definition at line 2583 of file pruneheap.c.

{
    xl_heap_prune xlrec;
    XLogRecPtr  recptr;
    uint8       info;
    uint8       regbuf_flags_heap;
 
    Page        heap_page = BufferGetPage(buffer);
 
    /* 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];
    bool        do_prune = nredirected > 0 || ndead > 0 || nunused > 0;
    bool        do_set_vm = vmflags & VISIBILITYMAP_VALID_BITS;
    bool        heap_fpi_allowed = true;
 
    Assert((vmflags & VISIBILITYMAP_VALID_BITS) == vmflags);
 
    xlrec.flags = 0;
    regbuf_flags_heap = REGBUF_STANDARD;
 
    /*
     * We can avoid an FPI of the heap page if the only modification we are
     * making to it is to set PD_ALL_VISIBLE and checksums/wal_log_hints are
     * disabled.
     *
     * However, if the page has never been WAL-logged (LSN is invalid), we
     * must force an FPI regardless.  This can happen when another backend
     * extends the heap, initializes the page, and then fails before WAL-
     * logging it.  Since heap extension is not WAL-logged, recovery might try
     * to replay our record and find that the page isn't initialized, which
     * would cause a PANIC.
     */
    if (!XLogRecPtrIsValid(PageGetLSN(heap_page)))
        regbuf_flags_heap |= REGBUF_FORCE_IMAGE;
    else if (!do_prune && nfrozen == 0 && (!do_set_vm || !XLogHintBitIsNeeded()))
    {
        regbuf_flags_heap |= REGBUF_NO_IMAGE;
        heap_fpi_allowed = false;
    }
 
    /*
     * 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_flags_heap);
 
    if (do_set_vm)
        XLogRegisterBuffer(1, vmbuffer, 0);
 
    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 (vmflags & VISIBILITYMAP_ALL_VISIBLE)
    {
        xlrec.flags |= XLHP_VM_ALL_VISIBLE;
        if (vmflags & VISIBILITYMAP_ALL_FROZEN)
            xlrec.flags |= XLHP_VM_ALL_FROZEN;
    }
    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);
 
    if (do_set_vm)
    {
        Assert(BufferIsDirty(vmbuffer));
        PageSetLSN(BufferGetPage(vmbuffer), recptr);
    }
 
    /*
     * If we explicitly skip an FPI, we must not stamp the heap page with this
     * record's LSN. Recovery skips records <= the stamped LSN, so this could
     * lead to skipping an earlier FPI needed to repair a torn page.
     */
    if (heap_fpi_allowed)
    {
        Assert(BufferIsDirty(buffer));
        PageSetLSN(heap_page, recptr);
    }
}

References Assert, BufferGetPage(), BufferIsDirty(), data, elog, ERROR, fb(), heap_log_freeze_plan(), MaxHeapTuplesPerPage, xlhp_prune_items::ntargets, PageGetLSN(), PageSetLSN(), PRUNE_ON_ACCESS, PRUNE_VACUUM_CLEANUP, PRUNE_VACUUM_SCAN, REGBUF_FORCE_IMAGE, REGBUF_NO_IMAGE, REGBUF_STANDARD, RelationIsAccessibleInLogicalDecoding, SizeOfHeapPrune, TransactionIdIsValid, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, VISIBILITYMAP_VALID_BITS, 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, XLHP_VM_ALL_FROZEN, XLHP_VM_ALL_VISIBLE, XLOG_HEAP2_PRUNE_ON_ACCESS, XLOG_HEAP2_PRUNE_VACUUM_CLEANUP, XLOG_HEAP2_PRUNE_VACUUM_SCAN, XLogBeginInsert(), XLogHintBitIsNeeded, XLogInsert(), XLogRecPtrIsValid, XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by heap_page_prune_and_freeze(), lazy_scan_new_or_empty(), and lazy_vacuum_heap_page().

ReleaseBulkInsertStatePin()

void ReleaseBulkInsertStatePin ( BulkInsertState  bistate )

extern

Definition at line 1967 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  )

extern

Definition at line 5550 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, fb(), HASH_FIND, hash_search(), ItemPointerCopy(), ItemPointerGetBlockNumber(), MAIN_FORKNUM, HeapTupleData::t_self, HeapTupleData::t_tableOid, tuplecid_data, and UpdateLogicalMappings().

Referenced by HeapTupleSatisfiesHistoricMVCC().

simple_heap_delete()

void simple_heap_delete ( Relation  relation, const ItemPointerData *  tid  )

extern

Definition at line 3219 of file heapam.c.

{
    TM_Result   result;
    TM_FailureData tmfd;
 
    result = heap_delete(relation, tid,
                         GetCurrentCommandId(true),
                         0,
                         InvalidSnapshot,
                         true /* wait for commit */ ,
                         &tmfd);
    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, result, 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  )

extern

Definition at line 2701 of file heapam.c.

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

References fb(), GetCurrentCommandId(), and heap_insert().

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

simple_heap_update()

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

extern

Definition at line 4639 of file heapam.c.

{
    TM_Result   result;
    TM_FailureData tmfd;
    LockTupleMode lockmode;
 
    result = heap_update(relation, otid, tup,
                         GetCurrentCommandId(true), 0,
                         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, fb(), GetCurrentCommandId(), heap_update(), InvalidSnapshot, result, TM_Deleted, TM_Ok, TM_SelfModified, and TM_Updated.

Referenced by CatalogTupleUpdate(), and CatalogTupleUpdateWithInfo().