heapam_handler.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/heapam.h"
#include "access/heaptoast.h"
#include "access/multixact.h"
#include "access/rewriteheap.h"
#include "access/syncscan.h"
#include "access/tableam.h"
#include "access/tsmapi.h"
#include "access/visibilitymap.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/index.h"
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "commands/progress.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/bufpage.h"
#include "storage/lmgr.h"
#include "storage/lock.h"
#include "storage/predicate.h"
#include "storage/procarray.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
#include "utils/rel.h"
#include "utils/tuplesort.h"

Include dependency graph for heapam_handler.c:

Go to the source code of this file.

Macros
#define	HEAP_OVERHEAD_BYTES_PER_TUPLE    (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))
#define	HEAP_USABLE_BYTES_PER_PAGE    (BLCKSZ - SizeOfPageHeaderData)

Functions
static void	reform_and_rewrite_tuple (HeapTuple tuple, Relation OldHeap, Relation NewHeap, Datum *values, bool *isnull, RewriteState rwstate)
static void	heap_insert_for_repack (HeapTuple tuple, Relation OldHeap, Relation NewHeap, Datum *values, bool *isnull, BulkInsertState bistate)
static HeapTuple	reform_tuple (HeapTuple tuple, Relation OldHeap, Relation NewHeap, Datum *values, bool *isnull)
static bool	SampleHeapTupleVisible (TableScanDesc scan, Buffer buffer, HeapTuple tuple, OffsetNumber tupoffset)
static BlockNumber	heapam_scan_get_blocks_done (HeapScanDesc hscan)
static bool	BitmapHeapScanNextBlock (TableScanDesc scan, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages)
static const TupleTableSlotOps *	heapam_slot_callbacks (Relation relation)
static bool	heapam_fetch_row_version (Relation relation, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot)
static bool	heapam_tuple_tid_valid (TableScanDesc scan, ItemPointer tid)
static bool	heapam_tuple_satisfies_snapshot (Relation rel, TupleTableSlot *slot, Snapshot snapshot)
static void	heapam_tuple_insert (Relation relation, TupleTableSlot *slot, CommandId cid, uint32 options, BulkInsertState bistate)
static void	heapam_tuple_insert_speculative (Relation relation, TupleTableSlot *slot, CommandId cid, uint32 options, BulkInsertState bistate, uint32 specToken)
static void	heapam_tuple_complete_speculative (Relation relation, TupleTableSlot *slot, uint32 specToken, bool succeeded)
static TM_Result	heapam_tuple_delete (Relation relation, ItemPointer tid, CommandId cid, uint32 options, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd)
static TM_Result	heapam_tuple_update (Relation relation, ItemPointer otid, TupleTableSlot *slot, CommandId cid, uint32 options, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
static TM_Result	heapam_tuple_lock (Relation relation, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
static void	heapam_relation_set_new_filelocator (Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
static void	heapam_relation_nontransactional_truncate (Relation rel)
static void	heapam_relation_copy_data (Relation rel, const RelFileLocator *newrlocator)
static void	heapam_relation_copy_for_cluster (Relation OldHeap, Relation NewHeap, Relation OldIndex, bool use_sort, TransactionId OldestXmin, Snapshot snapshot, TransactionId *xid_cutoff, MultiXactId *multi_cutoff, double *num_tuples, double *tups_vacuumed, double *tups_recently_dead)
static bool	heapam_scan_analyze_next_block (TableScanDesc scan, ReadStream *stream)
static bool	heapam_scan_analyze_next_tuple (TableScanDesc scan, double *liverows, double *deadrows, TupleTableSlot *slot)
static double	heapam_index_build_range_scan (Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool allow_sync, bool anyvisible, bool progress, BlockNumber start_blockno, BlockNumber numblocks, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
static void	heapam_index_validate_scan (Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, Snapshot snapshot, ValidateIndexState *state)
static bool	heapam_relation_needs_toast_table (Relation rel)
static Oid	heapam_relation_toast_am (Relation rel)
static void	heapam_estimate_rel_size (Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
static bool	heapam_scan_bitmap_next_tuple (TableScanDesc scan, TupleTableSlot *slot, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages)
static bool	heapam_scan_sample_next_block (TableScanDesc scan, SampleScanState *scanstate)
static bool	heapam_scan_sample_next_tuple (TableScanDesc scan, SampleScanState *scanstate, TupleTableSlot *slot)
const TableAmRoutine *	GetHeapamTableAmRoutine (void)
Datum	heap_tableam_handler (PG_FUNCTION_ARGS)

Variables
static const TableAmRoutine	heapam_methods

Macro Definition Documentation

HEAP_OVERHEAD_BYTES_PER_TUPLE

#define HEAP_OVERHEAD_BYTES_PER_TUPLE    (MAXALIGN(SizeofHeapTupleHeader) + sizeof(ItemIdData))

Definition at line 2065 of file heapam_handler.c.

{
    table_block_relation_estimate_size(rel, attr_widths, pages,
                                       tuples, allvisfrac,
                                       HEAP_OVERHEAD_BYTES_PER_TUPLE,
                                       HEAP_USABLE_BYTES_PER_PAGE);
}
 
 
/* ------------------------------------------------------------------------
 * Executor related callbacks for the heap AM
 * ------------------------------------------------------------------------
 */
 
static bool
heapam_scan_bitmap_next_tuple(TableScanDesc scan,
                              TupleTableSlot *slot,
                              bool *recheck,
                              uint64 *lossy_pages,
                              uint64 *exact_pages)
{
    BitmapHeapScanDesc bscan = (BitmapHeapScanDesc) scan;
    HeapScanDesc hscan = (HeapScanDesc) bscan;
    OffsetNumber targoffset;
    Page        page;
    ItemId      lp;
 
    /*
     * Out of range?  If so, nothing more to look at on this page
     */
    while (hscan->rs_cindex >= hscan->rs_ntuples)
    {
        /*
         * Returns false if the bitmap is exhausted and there are no further
         * blocks we need to scan.
         */
        if (!BitmapHeapScanNextBlock(scan, recheck, lossy_pages, exact_pages))
            return false;
    }
 
    targoffset = hscan->rs_vistuples[hscan->rs_cindex];
    page = BufferGetPage(hscan->rs_cbuf);
    lp = PageGetItemId(page, targoffset);
    Assert(ItemIdIsNormal(lp));
 
    hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
    hscan->rs_ctup.t_len = ItemIdGetLength(lp);
    hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
    ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);
 
    pgstat_count_heap_fetch(scan->rs_rd);
 
    /*
     * Set up the result slot to point to this tuple.  Note that the slot
     * acquires a pin on the buffer.
     */
    ExecStoreBufferHeapTuple(&hscan->rs_ctup,
                             slot,
                             hscan->rs_cbuf);
 
    hscan->rs_cindex++;
 
    return true;
}
 
static bool
heapam_scan_sample_next_block(TableScanDesc scan, SampleScanState *scanstate)
{
    HeapScanDesc hscan = (HeapScanDesc) scan;
    TsmRoutine *tsm = scanstate->tsmroutine;
    BlockNumber blockno;
 
    /* return false immediately if relation is empty */
    if (hscan->rs_nblocks == 0)
        return false;
 
    /* release previous scan buffer, if any */
    if (BufferIsValid(hscan->rs_cbuf))
    {
        ReleaseBuffer(hscan->rs_cbuf);
        hscan->rs_cbuf = InvalidBuffer;
    }
 
    if (tsm->NextSampleBlock)
        blockno = tsm->NextSampleBlock(scanstate, hscan->rs_nblocks);
    else
    {
        /* scanning table sequentially */
 
        if (hscan->rs_cblock == InvalidBlockNumber)
        {
            Assert(!hscan->rs_inited);
            blockno = hscan->rs_startblock;
        }
        else
        {
            Assert(hscan->rs_inited);
 
            blockno = hscan->rs_cblock + 1;
 
            if (blockno >= hscan->rs_nblocks)
            {
                /* wrap to beginning of rel, might not have started at 0 */
                blockno = 0;
            }
 
            /*
             * Report our new scan position for synchronization purposes.
             *
             * Note: we do this before checking for end of scan so that the
             * final state of the position hint is back at the start of the
             * rel.  That's not strictly necessary, but otherwise when you run
             * the same query multiple times the starting position would shift
             * a little bit backwards on every invocation, which is confusing.
             * We don't guarantee any specific ordering in general, though.
             */
            if (scan->rs_flags & SO_ALLOW_SYNC)
                ss_report_location(scan->rs_rd, blockno);
 
            if (blockno == hscan->rs_startblock)
            {
                blockno = InvalidBlockNumber;
            }
        }
    }
 
    hscan->rs_cblock = blockno;
 
    if (!BlockNumberIsValid(blockno))
    {
        hscan->rs_inited = false;
        return false;
    }
 
    Assert(hscan->rs_cblock < hscan->rs_nblocks);
 
    /*
     * Be sure to check for interrupts at least once per page.  Checks at
     * higher code levels won't be able to stop a sample scan that encounters
     * many pages' worth of consecutive dead tuples.
     */
    CHECK_FOR_INTERRUPTS();
 
    /* Read page using selected strategy */
    hscan->rs_cbuf = ReadBufferExtended(hscan->rs_base.rs_rd, MAIN_FORKNUM,
                                        blockno, RBM_NORMAL, hscan->rs_strategy);
 
    /* in pagemode, prune the page and determine visible tuple offsets */
    if (hscan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)
        heap_prepare_pagescan(scan);
 
    hscan->rs_inited = true;
    return true;
}
 
static bool
heapam_scan_sample_next_tuple(TableScanDesc scan, SampleScanState *scanstate,
                              TupleTableSlot *slot)
{
    HeapScanDesc hscan = (HeapScanDesc) scan;
    TsmRoutine *tsm = scanstate->tsmroutine;
    BlockNumber blockno = hscan->rs_cblock;
    bool        pagemode = (scan->rs_flags & SO_ALLOW_PAGEMODE) != 0;
 
    Page        page;
    bool        all_visible;
    OffsetNumber maxoffset;
 
    /*
     * When not using pagemode, we must lock the buffer during tuple
     * visibility checks.
     */
    if (!pagemode)
        LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
    page = BufferGetPage(hscan->rs_cbuf);
    all_visible = PageIsAllVisible(page) &&
        !scan->rs_snapshot->takenDuringRecovery;
    maxoffset = PageGetMaxOffsetNumber(page);
 
    for (;;)
    {
        OffsetNumber tupoffset;
 
        CHECK_FOR_INTERRUPTS();
 
        /* Ask the tablesample method which tuples to check on this page. */
        tupoffset = tsm->NextSampleTuple(scanstate,
                                         blockno,
                                         maxoffset);
 
        if (OffsetNumberIsValid(tupoffset))
        {
            ItemId      itemid;
            bool        visible;
            HeapTuple   tuple = &(hscan->rs_ctup);
 
            /* Skip invalid tuple pointers. */
            itemid = PageGetItemId(page, tupoffset);
            if (!ItemIdIsNormal(itemid))
                continue;
 
            tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
            tuple->t_len = ItemIdGetLength(itemid);
            ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
 
 
            if (all_visible)
                visible = true;
            else
                visible = SampleHeapTupleVisible(scan, hscan->rs_cbuf,
                                                 tuple, tupoffset);
 
            /* in pagemode, heap_prepare_pagescan did this for us */
            if (!pagemode)
                HeapCheckForSerializableConflictOut(visible, scan->rs_rd, tuple,
                                                    hscan->rs_cbuf, scan->rs_snapshot);
 
            /* Try next tuple from same page. */
            if (!visible)
                continue;
 
            /* Found visible tuple, return it. */
            if (!pagemode)
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            ExecStoreBufferHeapTuple(tuple, slot, hscan->rs_cbuf);
 
            /* Count successfully-fetched tuples as heap fetches */
            pgstat_count_heap_getnext(scan->rs_rd);
 
            return true;
        }
        else
        {
            /*
             * If we get here, it means we've exhausted the items on this page
             * and it's time to move to the next.
             */
            if (!pagemode)
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            ExecClearTuple(slot);
            return false;
        }
    }
 
    Assert(0);
}
 
 
/* ----------------------------------------------------------------------------
 *  Helper functions for the above.
 * ----------------------------------------------------------------------------
 */
 
/*
 * Reconstruct and rewrite the given tuple
 *
 * We cannot simply copy the tuple as-is, for several reasons:
 *
 * 1. We'd like to squeeze out the values of any dropped columns, both
 * to save space and to ensure we have no corner-case failures. (It's
 * possible for example that the new table hasn't got a TOAST table
 * and so is unable to store any large values of dropped cols.)
 *
 * 2. The tuple might not even be legal for the new table; this is
 * currently only known to happen as an after-effect of ALTER TABLE
 * SET WITHOUT OIDS.
 *
 * So, we must reconstruct the tuple from component Datums.
 */
static void
reform_and_rewrite_tuple(HeapTuple tuple,
                         Relation OldHeap, Relation NewHeap,
                         Datum *values, bool *isnull, RewriteState rwstate)
{
    HeapTuple   newtuple;
 
    newtuple = reform_tuple(tuple, OldHeap, NewHeap, values, isnull);
 
    /* The heap rewrite module does the rest */
    rewrite_heap_tuple(rwstate, tuple, newtuple);
 
    heap_freetuple(newtuple);
}
 
/*
 * Insert tuple when processing REPACK CONCURRENTLY.
 *
 * rewriteheap.c is not used in the CONCURRENTLY case because it'd be
 * difficult to do the same in the catch-up phase (as the logical
 * decoding does not provide us with sufficient visibility
 * information). Thus we must use heap_insert() both during the
 * catch-up and here.
 *
 * We pass the NO_LOGICAL flag to heap_insert() in order to skip logical
 * decoding: as soon as REPACK CONCURRENTLY swaps the relation files, it drops
 * this relation, so no logical replication subscription should need the data.
 *
 * BulkInsertState is used because many tuples are inserted in the typical
 * case.
 */
static void
heap_insert_for_repack(HeapTuple tuple, Relation OldHeap, Relation NewHeap,
                       Datum *values, bool *isnull, BulkInsertState bistate)
{
    HeapTuple   newtuple;
 
    newtuple = reform_tuple(tuple, OldHeap, NewHeap, values, isnull);
 
    heap_insert(NewHeap, newtuple, GetCurrentCommandId(true),
                HEAP_INSERT_NO_LOGICAL, bistate);
 
    heap_freetuple(newtuple);
}
 
/*
 * Subroutine for reform_and_rewrite_tuple and heap_insert_for_repack.
 *
 * Deform the given tuple, set values of dropped columns to NULL, and fill in
 * any values from attmissingval; then form a new tuple and return it.  If no
 * attributes need to be changed, a copy of the original tuple is returned.
 * Caller is responsible for freeing the returned tuple.
 *
 * XXX this coding assumes that both relations have the same tupledesc.
 */
static HeapTuple
reform_tuple(HeapTuple tuple, Relation OldHeap, Relation NewHeap,
             Datum *values, bool *isnull)
{
    TupleDesc   oldTupDesc = RelationGetDescr(OldHeap);
    TupleDesc   newTupDesc = RelationGetDescr(NewHeap);
    bool        needs_reform = false;
 
    /*
     * A short tuple might require values from attmissing val, so activate the
     * coding unconditionally in that case.  The value might legitimally be
     * NULL otherwise, so this is slightly wasteful, but it probably beats
     * having to test each attribute for presence of attmissingval each time.
     */
    if (HeapTupleHeaderGetNatts(tuple->t_data) < newTupDesc->natts)
        needs_reform = true;
 
    /*
     * If the column has been dropped but a value is still present, we can
     * optimize storage now by getting rid of it.
     */
    if (!needs_reform)
    {
        for (int i = 0; i < newTupDesc->natts; i++)
        {
            if (TupleDescCompactAttr(newTupDesc, i)->attisdropped &&
                !heap_attisnull(tuple, i + 1, newTupDesc))
            {
                needs_reform = true;
                break;
            }
        }
    }
 
    /* Skip work if no changes are needed */
    if (!needs_reform)
        return heap_copytuple(tuple);
 
    heap_deform_tuple(tuple, oldTupDesc, values, isnull);
 
    for (int i = 0; i < newTupDesc->natts; i++)
    {
        if (TupleDescCompactAttr(newTupDesc, i)->attisdropped)
            isnull[i] = true;
    }
 
    return heap_form_tuple(newTupDesc, values, isnull);
}
 
/*
 * Check visibility of the tuple.
 */
static bool
SampleHeapTupleVisible(TableScanDesc scan, Buffer buffer,
                       HeapTuple tuple,
                       OffsetNumber tupoffset)
{
    HeapScanDesc hscan = (HeapScanDesc) scan;
 
    if (scan->rs_flags & SO_ALLOW_PAGEMODE)
    {
        uint32      start = 0,
                    end = hscan->rs_ntuples;
 
        /*
         * In pageatatime mode, heap_prepare_pagescan() already did visibility
         * checks, so just look at the info it left in rs_vistuples[].
         *
         * We use a binary search over the known-sorted array.  Note: we could
         * save some effort if we insisted that NextSampleTuple select tuples
         * in increasing order, but it's not clear that there would be enough
         * gain to justify the restriction.
         */
        while (start < end)
        {
            uint32      mid = start + (end - start) / 2;
            OffsetNumber curoffset = hscan->rs_vistuples[mid];
 
            if (tupoffset == curoffset)
                return true;
            else if (tupoffset < curoffset)
                end = mid;
            else
                start = mid + 1;
        }
 
        return false;
    }
    else
    {
        /* Otherwise, we have to check the tuple individually. */
        return HeapTupleSatisfiesVisibility(tuple, scan->rs_snapshot,
                                            buffer);
    }
}
 
/*
 * Helper function get the next block of a bitmap heap scan. Returns true when
 * it got the next block and saved it in the scan descriptor and false when
 * the bitmap and or relation are exhausted.
 */
static bool
BitmapHeapScanNextBlock(TableScanDesc scan,
                        bool *recheck,
                        uint64 *lossy_pages, uint64 *exact_pages)
{
    BitmapHeapScanDesc bscan = (BitmapHeapScanDesc) scan;
    HeapScanDesc hscan = (HeapScanDesc) bscan;
    BlockNumber block;
    void       *per_buffer_data;
    Buffer      buffer;
    Snapshot    snapshot;
    int         ntup;
    TBMIterateResult *tbmres;
    OffsetNumber offsets[TBM_MAX_TUPLES_PER_PAGE];
    int         noffsets = -1;
 
    Assert(scan->rs_flags & SO_TYPE_BITMAPSCAN);
    Assert(hscan->rs_read_stream);
 
    hscan->rs_cindex = 0;
    hscan->rs_ntuples = 0;
 
    /* Release buffer containing previous block. */
    if (BufferIsValid(hscan->rs_cbuf))
    {
        ReleaseBuffer(hscan->rs_cbuf);
        hscan->rs_cbuf = InvalidBuffer;
    }
 
    hscan->rs_cbuf = read_stream_next_buffer(hscan->rs_read_stream,
                                             &per_buffer_data);
 
    if (BufferIsInvalid(hscan->rs_cbuf))
    {
        /* the bitmap is exhausted */
        return false;
    }
 
    Assert(per_buffer_data);
 
    tbmres = per_buffer_data;
 
    Assert(BlockNumberIsValid(tbmres->blockno));
    Assert(BufferGetBlockNumber(hscan->rs_cbuf) == tbmres->blockno);
 
    /* Exact pages need their tuple offsets extracted. */
    if (!tbmres->lossy)
        noffsets = tbm_extract_page_tuple(tbmres, offsets,
                                          TBM_MAX_TUPLES_PER_PAGE);
 
    *recheck = tbmres->recheck;
 
    block = hscan->rs_cblock = tbmres->blockno;
    buffer = hscan->rs_cbuf;
    snapshot = scan->rs_snapshot;
 
    ntup = 0;
 
    /*
     * Prune and repair fragmentation for the whole page, if possible.
     */
    heap_page_prune_opt(scan->rs_rd, buffer, &hscan->rs_vmbuffer,
                        scan->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);
 
    /*
     * We need two separate strategies for lossy and non-lossy cases.
     */
    if (!tbmres->lossy)
    {
        /*
         * Bitmap is non-lossy, so we just look through the offsets listed in
         * tbmres; but we have to follow any HOT chain starting at each such
         * offset.
         */
        int         curslot;
 
        /* We must have extracted the tuple offsets by now */
        Assert(noffsets > -1);
 
        for (curslot = 0; curslot < noffsets; curslot++)
        {
            OffsetNumber offnum = offsets[curslot];
            ItemPointerData tid;
            HeapTupleData heapTuple;
 
            ItemPointerSet(&tid, block, offnum);
            if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
                                       &heapTuple, NULL, true))
                hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
        }
    }
    else
    {
        /*
         * Bitmap is lossy, so we must examine each line pointer on the page.
         * But we can ignore HOT chains, since we'll check each tuple anyway.
         */
        Page        page = BufferGetPage(buffer);
        OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
        OffsetNumber offnum;
 
        for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
        {
            ItemId      lp;
            HeapTupleData loctup;
            bool        valid;
 
            lp = PageGetItemId(page, offnum);
            if (!ItemIdIsNormal(lp))
                continue;
            loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
            loctup.t_len = ItemIdGetLength(lp);
            loctup.t_tableOid = scan->rs_rd->rd_id;
            ItemPointerSet(&loctup.t_self, block, offnum);
            valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
            if (valid)
            {
                hscan->rs_vistuples[ntup++] = offnum;
                PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
                                 HeapTupleHeaderGetXmin(loctup.t_data));
            }
            HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
                                                buffer, snapshot);
        }
    }
 
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
    Assert(ntup <= MaxHeapTuplesPerPage);
    hscan->rs_ntuples = ntup;
 
    if (tbmres->lossy)
        (*lossy_pages)++;
    else
        (*exact_pages)++;
 
    /*
     * Return true to indicate that a valid block was found and the bitmap is
     * not exhausted. If there are no visible tuples on this page,
     * hscan->rs_ntuples will be 0 and heapam_scan_bitmap_next_tuple() will
     * return false returning control to this function to advance to the next
     * block in the bitmap.
     */
    return true;
}
 
/* ------------------------------------------------------------------------
 * Definition of the heap table access method.
 * ------------------------------------------------------------------------
 */
 
static const TableAmRoutine heapam_methods = {
    .type = T_TableAmRoutine,
 
    .slot_callbacks = heapam_slot_callbacks,
 
    .scan_begin = heap_beginscan,
    .scan_end = heap_endscan,
    .scan_rescan = heap_rescan,
    .scan_getnextslot = heap_getnextslot,
 
    .scan_set_tidrange = heap_set_tidrange,
    .scan_getnextslot_tidrange = heap_getnextslot_tidrange,
 
    .parallelscan_estimate = table_block_parallelscan_estimate,
    .parallelscan_initialize = table_block_parallelscan_initialize,
    .parallelscan_reinitialize = table_block_parallelscan_reinitialize,
 
    .index_fetch_begin = heapam_index_fetch_begin,
    .index_fetch_reset = heapam_index_fetch_reset,
    .index_fetch_end = heapam_index_fetch_end,
    .index_fetch_tuple = heapam_index_fetch_tuple,
 
    .tuple_insert = heapam_tuple_insert,
    .tuple_insert_speculative = heapam_tuple_insert_speculative,
    .tuple_complete_speculative = heapam_tuple_complete_speculative,
    .multi_insert = heap_multi_insert,
    .tuple_delete = heapam_tuple_delete,
    .tuple_update = heapam_tuple_update,
    .tuple_lock = heapam_tuple_lock,
 
    .tuple_fetch_row_version = heapam_fetch_row_version,
    .tuple_get_latest_tid = heap_get_latest_tid,
    .tuple_tid_valid = heapam_tuple_tid_valid,
    .tuple_satisfies_snapshot = heapam_tuple_satisfies_snapshot,
    .index_delete_tuples = heap_index_delete_tuples,
 
    .relation_set_new_filelocator = heapam_relation_set_new_filelocator,
    .relation_nontransactional_truncate = heapam_relation_nontransactional_truncate,
    .relation_copy_data = heapam_relation_copy_data,
    .relation_copy_for_cluster = heapam_relation_copy_for_cluster,
    .relation_vacuum = heap_vacuum_rel,
    .scan_analyze_next_block = heapam_scan_analyze_next_block,
    .scan_analyze_next_tuple = heapam_scan_analyze_next_tuple,
    .index_build_range_scan = heapam_index_build_range_scan,
    .index_validate_scan = heapam_index_validate_scan,
 
    .relation_size = table_block_relation_size,
    .relation_needs_toast_table = heapam_relation_needs_toast_table,
    .relation_toast_am = heapam_relation_toast_am,
    .relation_fetch_toast_slice = heap_fetch_toast_slice,
 
    .relation_estimate_size = heapam_estimate_rel_size,
 
    .scan_bitmap_next_tuple = heapam_scan_bitmap_next_tuple,
    .scan_sample_next_block = heapam_scan_sample_next_block,
    .scan_sample_next_tuple = heapam_scan_sample_next_tuple
};
 
 
const TableAmRoutine *
GetHeapamTableAmRoutine(void)
{
    return &heapam_methods;
}
 
Datum
heap_tableam_handler(PG_FUNCTION_ARGS)
{
    PG_RETURN_POINTER(&heapam_methods);
}

HEAP_USABLE_BYTES_PER_PAGE

#define HEAP_USABLE_BYTES_PER_PAGE    (BLCKSZ - SizeOfPageHeaderData)

Definition at line 2067 of file heapam_handler.c.

Function Documentation

BitmapHeapScanNextBlock()

static bool BitmapHeapScanNextBlock ( TableScanDesc  scan, bool *  recheck, uint64 *  lossy_pages, uint64 *  exact_pages  )

static

Definition at line 2502 of file heapam_handler.c.

{
    BitmapHeapScanDesc bscan = (BitmapHeapScanDesc) scan;
    HeapScanDesc hscan = (HeapScanDesc) bscan;
    BlockNumber block;
    void       *per_buffer_data;
    Buffer      buffer;
    Snapshot    snapshot;
    int         ntup;
    TBMIterateResult *tbmres;
    OffsetNumber offsets[TBM_MAX_TUPLES_PER_PAGE];
    int         noffsets = -1;
 
    Assert(scan->rs_flags & SO_TYPE_BITMAPSCAN);
    Assert(hscan->rs_read_stream);
 
    hscan->rs_cindex = 0;
    hscan->rs_ntuples = 0;
 
    /* Release buffer containing previous block. */
    if (BufferIsValid(hscan->rs_cbuf))
    {
        ReleaseBuffer(hscan->rs_cbuf);
        hscan->rs_cbuf = InvalidBuffer;
    }
 
    hscan->rs_cbuf = read_stream_next_buffer(hscan->rs_read_stream,
                                             &per_buffer_data);
 
    if (BufferIsInvalid(hscan->rs_cbuf))
    {
        /* the bitmap is exhausted */
        return false;
    }
 
    Assert(per_buffer_data);
 
    tbmres = per_buffer_data;
 
    Assert(BlockNumberIsValid(tbmres->blockno));
    Assert(BufferGetBlockNumber(hscan->rs_cbuf) == tbmres->blockno);
 
    /* Exact pages need their tuple offsets extracted. */
    if (!tbmres->lossy)
        noffsets = tbm_extract_page_tuple(tbmres, offsets,
                                          TBM_MAX_TUPLES_PER_PAGE);
 
    *recheck = tbmres->recheck;
 
    block = hscan->rs_cblock = tbmres->blockno;
    buffer = hscan->rs_cbuf;
    snapshot = scan->rs_snapshot;
 
    ntup = 0;
 
    /*
     * Prune and repair fragmentation for the whole page, if possible.
     */
    heap_page_prune_opt(scan->rs_rd, buffer, &hscan->rs_vmbuffer,
                        scan->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);
 
    /*
     * We need two separate strategies for lossy and non-lossy cases.
     */
    if (!tbmres->lossy)
    {
        /*
         * Bitmap is non-lossy, so we just look through the offsets listed in
         * tbmres; but we have to follow any HOT chain starting at each such
         * offset.
         */
        int         curslot;
 
        /* We must have extracted the tuple offsets by now */
        Assert(noffsets > -1);
 
        for (curslot = 0; curslot < noffsets; curslot++)
        {
            OffsetNumber offnum = offsets[curslot];
            ItemPointerData tid;
            HeapTupleData heapTuple;
 
            ItemPointerSet(&tid, block, offnum);
            if (heap_hot_search_buffer(&tid, scan->rs_rd, buffer, snapshot,
                                       &heapTuple, NULL, true))
                hscan->rs_vistuples[ntup++] = ItemPointerGetOffsetNumber(&tid);
        }
    }
    else
    {
        /*
         * Bitmap is lossy, so we must examine each line pointer on the page.
         * But we can ignore HOT chains, since we'll check each tuple anyway.
         */
        Page        page = BufferGetPage(buffer);
        OffsetNumber maxoff = PageGetMaxOffsetNumber(page);
        OffsetNumber offnum;
 
        for (offnum = FirstOffsetNumber; offnum <= maxoff; offnum = OffsetNumberNext(offnum))
        {
            ItemId      lp;
            HeapTupleData loctup;
            bool        valid;
 
            lp = PageGetItemId(page, offnum);
            if (!ItemIdIsNormal(lp))
                continue;
            loctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
            loctup.t_len = ItemIdGetLength(lp);
            loctup.t_tableOid = scan->rs_rd->rd_id;
            ItemPointerSet(&loctup.t_self, block, offnum);
            valid = HeapTupleSatisfiesVisibility(&loctup, snapshot, buffer);
            if (valid)
            {
                hscan->rs_vistuples[ntup++] = offnum;
                PredicateLockTID(scan->rs_rd, &loctup.t_self, snapshot,
                                 HeapTupleHeaderGetXmin(loctup.t_data));
            }
            HeapCheckForSerializableConflictOut(valid, scan->rs_rd, &loctup,
                                                buffer, snapshot);
        }
    }
 
    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
 
    Assert(ntup <= MaxHeapTuplesPerPage);
    hscan->rs_ntuples = ntup;
 
    if (tbmres->lossy)
        (*lossy_pages)++;
    else
        (*exact_pages)++;
 
    /*
     * Return true to indicate that a valid block was found and the bitmap is
     * not exhausted. If there are no visible tuples on this page,
     * hscan->rs_ntuples will be 0 and heapam_scan_bitmap_next_tuple() will
     * return false returning control to this function to advance to the next
     * block in the bitmap.
     */
    return true;
}

References Assert, BlockNumberIsValid(), BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsInvalid, BufferIsValid(), fb(), FirstOffsetNumber, heap_hot_search_buffer(), heap_page_prune_opt(), HeapCheckForSerializableConflictOut(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVisibility(), InvalidBuffer, ItemIdGetLength, ItemIdIsNormal, ItemPointerGetOffsetNumber(), ItemPointerSet(), LockBuffer(), MaxHeapTuplesPerPage, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PredicateLockTID(), RelationData::rd_id, read_stream_next_buffer(), ReleaseBuffer(), TableScanDescData::rs_flags, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, SO_HINT_REL_READ_ONLY, SO_TYPE_BITMAPSCAN, tbm_extract_page_tuple(), and TBM_MAX_TUPLES_PER_PAGE.

Referenced by heapam_scan_bitmap_next_tuple().

GetHeapamTableAmRoutine()

const TableAmRoutine * GetHeapamTableAmRoutine

(

void

)

Definition at line 2719 of file heapam_handler.c.

{
    return &heapam_methods;
}

References heapam_methods.

Referenced by formrdesc(), and heap_getnext().

heap_insert_for_repack()

static void heap_insert_for_repack ( HeapTuple  tuple, Relation  OldHeap, Relation  NewHeap, Datum *  values, bool *  isnull, BulkInsertState  bistate  )

static

Definition at line 2377 of file heapam_handler.c.

{
    HeapTuple   newtuple;
 
    newtuple = reform_tuple(tuple, OldHeap, NewHeap, values, isnull);
 
    heap_insert(NewHeap, newtuple, GetCurrentCommandId(true),
                HEAP_INSERT_NO_LOGICAL, bistate);
 
    heap_freetuple(newtuple);
}

References fb(), GetCurrentCommandId(), heap_freetuple(), heap_insert(), HEAP_INSERT_NO_LOGICAL, reform_tuple(), and values.

Referenced by heapam_relation_copy_for_cluster().

heap_tableam_handler()

Datum heap_tableam_handler

(

PG_FUNCTION_ARGS

)

Definition at line 2725 of file heapam_handler.c.

{
    PG_RETURN_POINTER(&heapam_methods);
}

References heapam_methods, and PG_RETURN_POINTER.

heapam_estimate_rel_size()

static void heapam_estimate_rel_size ( Relation  rel, int32 *  attr_widths, BlockNumber *  pages, double *  tuples, double *  allvisfrac  )

static

Definition at line 2071 of file heapam_handler.c.

{
    table_block_relation_estimate_size(rel, attr_widths, pages,
                                       tuples, allvisfrac,
                                       HEAP_OVERHEAD_BYTES_PER_TUPLE,
                                       HEAP_USABLE_BYTES_PER_PAGE);
}

References fb(), HEAP_OVERHEAD_BYTES_PER_TUPLE, HEAP_USABLE_BYTES_PER_PAGE, and table_block_relation_estimate_size().

heapam_fetch_row_version()

static bool heapam_fetch_row_version ( Relation  relation, ItemPointer  tid, Snapshot  snapshot, TupleTableSlot *  slot  )

static

Definition at line 89 of file heapam_handler.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    Buffer      buffer;
 
    Assert(TTS_IS_BUFFERTUPLE(slot));
 
    bslot->base.tupdata.t_self = *tid;
    if (heap_fetch(relation, snapshot, &bslot->base.tupdata, &buffer, false))
    {
        /* store in slot, transferring existing pin */
        ExecStorePinnedBufferHeapTuple(&bslot->base.tupdata, slot, buffer);
        slot->tts_tableOid = RelationGetRelid(relation);
 
        return true;
    }
 
    return false;
}

References Assert, ExecStorePinnedBufferHeapTuple(), fb(), heap_fetch(), RelationGetRelid, TTS_IS_BUFFERTUPLE, and TupleTableSlot::tts_tableOid.

heapam_index_build_range_scan()

static double heapam_index_build_range_scan ( Relation  heapRelation, Relation  indexRelation, IndexInfo *  indexInfo, bool  allow_sync, bool  anyvisible, bool  progress, BlockNumber  start_blockno, BlockNumber  numblocks, IndexBuildCallback  callback, void *  callback_state, TableScanDesc  scan  )

static

Definition at line 1137 of file heapam_handler.c.

{
    HeapScanDesc hscan;
    bool        is_system_catalog;
    bool        checking_uniqueness;
    HeapTuple   heapTuple;
    Datum       values[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    double      reltuples;
    ExprState  *predicate;
    TupleTableSlot *slot;
    EState     *estate;
    ExprContext *econtext;
    Snapshot    snapshot;
    bool        need_unregister_snapshot = false;
    TransactionId OldestXmin;
    BlockNumber previous_blkno = InvalidBlockNumber;
    BlockNumber root_blkno = InvalidBlockNumber;
    OffsetNumber root_offsets[MaxHeapTuplesPerPage];
 
    /*
     * sanity checks
     */
    Assert(OidIsValid(indexRelation->rd_rel->relam));
 
    /* Remember if it's a system catalog */
    is_system_catalog = IsSystemRelation(heapRelation);
 
    /* See whether we're verifying uniqueness/exclusion properties */
    checking_uniqueness = (indexInfo->ii_Unique ||
                           indexInfo->ii_ExclusionOps != NULL);
 
    /*
     * "Any visible" mode is not compatible with uniqueness checks; make sure
     * only one of those is requested.
     */
    Assert(!(anyvisible && checking_uniqueness));
 
    /*
     * Need an EState for evaluation of index expressions and partial-index
     * predicates.  Also a slot to hold the current tuple.
     */
    estate = CreateExecutorState();
    econtext = GetPerTupleExprContext(estate);
    slot = table_slot_create(heapRelation, NULL);
 
    /* Arrange for econtext's scan tuple to be the tuple under test */
    econtext->ecxt_scantuple = slot;
 
    /* Set up execution state for predicate, if any. */
    predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
 
    /*
     * Prepare for scan of the base relation.  In a normal index build, we use
     * SnapshotAny because we must retrieve all tuples and do our own time
     * qual checks (because we have to index RECENTLY_DEAD tuples). In a
     * concurrent build, or during bootstrap, we take a regular MVCC snapshot
     * and index whatever's live according to that.
     */
    OldestXmin = InvalidTransactionId;
 
    /* okay to ignore lazy VACUUMs here */
    if (!IsBootstrapProcessingMode() && !indexInfo->ii_Concurrent)
        OldestXmin = GetOldestNonRemovableTransactionId(heapRelation);
 
    if (!scan)
    {
        /*
         * Serial index build.
         *
         * Must begin our own heap scan in this case.  We may also need to
         * register a snapshot whose lifetime is under our direct control.
         */
        if (!TransactionIdIsValid(OldestXmin))
        {
            snapshot = RegisterSnapshot(GetTransactionSnapshot());
            need_unregister_snapshot = true;
        }
        else
            snapshot = SnapshotAny;
 
        scan = table_beginscan_strat(heapRelation,  /* relation */
                                     snapshot,  /* snapshot */
                                     0, /* number of keys */
                                     NULL,  /* scan key */
                                     true,  /* buffer access strategy OK */
                                     allow_sync);   /* syncscan OK? */
    }
    else
    {
        /*
         * Parallel index build.
         *
         * Parallel case never registers/unregisters own snapshot.  Snapshot
         * is taken from parallel heap scan, and is SnapshotAny or an MVCC
         * snapshot, based on same criteria as serial case.
         */
        Assert(!IsBootstrapProcessingMode());
        Assert(allow_sync);
        snapshot = scan->rs_snapshot;
    }
 
    hscan = (HeapScanDesc) scan;
 
    /*
     * Must have called GetOldestNonRemovableTransactionId() if using
     * SnapshotAny.  Shouldn't have for an MVCC snapshot. (It's especially
     * worth checking this for parallel builds, since ambuild routines that
     * support parallel builds must work these details out for themselves.)
     */
    Assert(snapshot == SnapshotAny || IsMVCCSnapshot(snapshot));
    Assert(snapshot == SnapshotAny ? TransactionIdIsValid(OldestXmin) :
           !TransactionIdIsValid(OldestXmin));
    Assert(snapshot == SnapshotAny || !anyvisible);
 
    /* Publish number of blocks to scan */
    if (progress)
    {
        BlockNumber nblocks;
 
        if (hscan->rs_base.rs_parallel != NULL)
        {
            ParallelBlockTableScanDesc pbscan;
 
            pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
            nblocks = pbscan->phs_nblocks;
        }
        else
            nblocks = hscan->rs_nblocks;
 
        pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_TOTAL,
                                     nblocks);
    }
 
    /* set our scan endpoints */
    if (!allow_sync)
        heap_setscanlimits(scan, start_blockno, numblocks);
    else
    {
        /* syncscan can only be requested on whole relation */
        Assert(start_blockno == 0);
        Assert(numblocks == InvalidBlockNumber);
    }
 
    reltuples = 0;
 
    /*
     * Scan all tuples in the base relation.
     */
    while ((heapTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        bool        tupleIsAlive;
 
        CHECK_FOR_INTERRUPTS();
 
        /* Report scan progress, if asked to. */
        if (progress)
        {
            BlockNumber blocks_done = heapam_scan_get_blocks_done(hscan);
 
            if (blocks_done != previous_blkno)
            {
                pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
                                             blocks_done);
                previous_blkno = blocks_done;
            }
        }
 
        /*
         * When dealing with a HOT-chain of updated tuples, we want to index
         * the values of the live tuple (if any), but index it under the TID
         * of the chain's root tuple.  This approach is necessary to preserve
         * the HOT-chain structure in the heap. So we need to be able to find
         * the root item offset for every tuple that's in a HOT-chain.  When
         * first reaching a new page of the relation, call
         * heap_get_root_tuples() to build a map of root item offsets on the
         * page.
         *
         * It might look unsafe to use this information across buffer
         * lock/unlock.  However, we hold ShareLock on the table so no
         * ordinary insert/update/delete should occur; and we hold pin on the
         * buffer continuously while visiting the page, so no pruning
         * operation can occur either.
         *
         * In cases with only ShareUpdateExclusiveLock on the table, it's
         * possible for some HOT tuples to appear that we didn't know about
         * when we first read the page.  To handle that case, we re-obtain the
         * list of root offsets when a HOT tuple points to a root item that we
         * don't know about.
         *
         * Also, although our opinions about tuple liveness could change while
         * we scan the page (due to concurrent transaction commits/aborts),
         * the chain root locations won't, so this info doesn't need to be
         * rebuilt after waiting for another transaction.
         *
         * Note the implied assumption that there is no more than one live
         * tuple per HOT-chain --- else we could create more than one index
         * entry pointing to the same root tuple.
         */
        if (hscan->rs_cblock != root_blkno)
        {
            Page        page = BufferGetPage(hscan->rs_cbuf);
 
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
            heap_get_root_tuples(page, root_offsets);
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            root_blkno = hscan->rs_cblock;
        }
 
        if (snapshot == SnapshotAny)
        {
            /* do our own time qual check */
            bool        indexIt;
            TransactionId xwait;
 
    recheck:
 
            /*
             * We could possibly get away with not locking the buffer here,
             * since caller should hold ShareLock on the relation, but let's
             * be conservative about it.  (This remark is still correct even
             * with HOT-pruning: our pin on the buffer prevents pruning.)
             */
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
            /*
             * The criteria for counting a tuple as live in this block need to
             * match what analyze.c's heapam_scan_analyze_next_tuple() does,
             * otherwise CREATE INDEX and ANALYZE may produce wildly different
             * reltuples values, e.g. when there are many recently-dead
             * tuples.
             */
            switch (HeapTupleSatisfiesVacuum(heapTuple, OldestXmin,
                                             hscan->rs_cbuf))
            {
                case HEAPTUPLE_DEAD:
                    /* Definitely dead, we can ignore it */
                    indexIt = false;
                    tupleIsAlive = false;
                    break;
                case HEAPTUPLE_LIVE:
                    /* Normal case, index and unique-check it */
                    indexIt = true;
                    tupleIsAlive = true;
                    /* Count it as live, too */
                    reltuples += 1;
                    break;
                case HEAPTUPLE_RECENTLY_DEAD:
 
                    /*
                     * If tuple is recently deleted then we must index it
                     * anyway to preserve MVCC semantics.  (Pre-existing
                     * transactions could try to use the index after we finish
                     * building it, and may need to see such tuples.)
                     *
                     * However, if it was HOT-updated then we must only index
                     * the live tuple at the end of the HOT-chain.  Since this
                     * breaks semantics for pre-existing snapshots, mark the
                     * index as unusable for them.
                     *
                     * We don't count recently-dead tuples in reltuples, even
                     * if we index them; see heapam_scan_analyze_next_tuple().
                     */
                    if (HeapTupleIsHotUpdated(heapTuple))
                    {
                        indexIt = false;
                        /* mark the index as unsafe for old snapshots */
                        indexInfo->ii_BrokenHotChain = true;
                    }
                    else
                        indexIt = true;
                    /* In any case, exclude the tuple from unique-checking */
                    tupleIsAlive = false;
                    break;
                case HEAPTUPLE_INSERT_IN_PROGRESS:
 
                    /*
                     * In "anyvisible" mode, this tuple is visible and we
                     * don't need any further checks.
                     */
                    if (anyvisible)
                    {
                        indexIt = true;
                        tupleIsAlive = true;
                        reltuples += 1;
                        break;
                    }
 
                    /*
                     * Since caller should hold ShareLock or better, normally
                     * the only way to see this is if it was inserted earlier
                     * in our own transaction.  However, it can happen in
                     * system catalogs, since we tend to release write lock
                     * before commit there.  Give a warning if neither case
                     * applies.
                     */
                    xwait = HeapTupleHeaderGetXmin(heapTuple->t_data);
                    if (!TransactionIdIsCurrentTransactionId(xwait))
                    {
                        if (!is_system_catalog)
                            elog(WARNING, "concurrent insert in progress within table \"%s\"",
                                 RelationGetRelationName(heapRelation));
 
                        /*
                         * If we are performing uniqueness checks, indexing
                         * such a tuple could lead to a bogus uniqueness
                         * failure.  In that case we wait for the inserting
                         * transaction to finish and check again.
                         */
                        if (checking_uniqueness)
                        {
                            /*
                             * Must drop the lock on the buffer before we wait
                             */
                            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
                            XactLockTableWait(xwait, heapRelation,
                                              &heapTuple->t_self,
                                              XLTW_InsertIndexUnique);
                            CHECK_FOR_INTERRUPTS();
                            goto recheck;
                        }
                    }
                    else
                    {
                        /*
                         * For consistency with
                         * heapam_scan_analyze_next_tuple(), count
                         * HEAPTUPLE_INSERT_IN_PROGRESS tuples as live only
                         * when inserted by our own transaction.
                         */
                        reltuples += 1;
                    }
 
                    /*
                     * We must index such tuples, since if the index build
                     * commits then they're good.
                     */
                    indexIt = true;
                    tupleIsAlive = true;
                    break;
                case HEAPTUPLE_DELETE_IN_PROGRESS:
 
                    /*
                     * As with INSERT_IN_PROGRESS case, this is unexpected
                     * unless it's our own deletion or a system catalog; but
                     * in anyvisible mode, this tuple is visible.
                     */
                    if (anyvisible)
                    {
                        indexIt = true;
                        tupleIsAlive = false;
                        reltuples += 1;
                        break;
                    }
 
                    xwait = HeapTupleHeaderGetUpdateXid(heapTuple->t_data);
                    if (!TransactionIdIsCurrentTransactionId(xwait))
                    {
                        if (!is_system_catalog)
                            elog(WARNING, "concurrent delete in progress within table \"%s\"",
                                 RelationGetRelationName(heapRelation));
 
                        /*
                         * If we are performing uniqueness checks, assuming
                         * the tuple is dead could lead to missing a
                         * uniqueness violation.  In that case we wait for the
                         * deleting transaction to finish and check again.
                         *
                         * Also, if it's a HOT-updated tuple, we should not
                         * index it but rather the live tuple at the end of
                         * the HOT-chain.  However, the deleting transaction
                         * could abort, possibly leaving this tuple as live
                         * after all, in which case it has to be indexed. The
                         * only way to know what to do is to wait for the
                         * deleting transaction to finish and check again.
                         */
                        if (checking_uniqueness ||
                            HeapTupleIsHotUpdated(heapTuple))
                        {
                            /*
                             * Must drop the lock on the buffer before we wait
                             */
                            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
                            XactLockTableWait(xwait, heapRelation,
                                              &heapTuple->t_self,
                                              XLTW_InsertIndexUnique);
                            CHECK_FOR_INTERRUPTS();
                            goto recheck;
                        }
 
                        /*
                         * Otherwise index it but don't check for uniqueness,
                         * the same as a RECENTLY_DEAD tuple.
                         */
                        indexIt = true;
 
                        /*
                         * Count HEAPTUPLE_DELETE_IN_PROGRESS tuples as live,
                         * if they were not deleted by the current
                         * transaction.  That's what
                         * heapam_scan_analyze_next_tuple() does, and we want
                         * the behavior to be consistent.
                         */
                        reltuples += 1;
                    }
                    else if (HeapTupleIsHotUpdated(heapTuple))
                    {
                        /*
                         * It's a HOT-updated tuple deleted by our own xact.
                         * We can assume the deletion will commit (else the
                         * index contents don't matter), so treat the same as
                         * RECENTLY_DEAD HOT-updated tuples.
                         */
                        indexIt = false;
                        /* mark the index as unsafe for old snapshots */
                        indexInfo->ii_BrokenHotChain = true;
                    }
                    else
                    {
                        /*
                         * It's a regular tuple deleted by our own xact. Index
                         * it, but don't check for uniqueness nor count in
                         * reltuples, the same as a RECENTLY_DEAD tuple.
                         */
                        indexIt = true;
                    }
                    /* In any case, exclude the tuple from unique-checking */
                    tupleIsAlive = false;
                    break;
                default:
                    elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                    indexIt = tupleIsAlive = false; /* keep compiler quiet */
                    break;
            }
 
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            if (!indexIt)
                continue;
        }
        else
        {
            /* heap_getnext did the time qual check */
            tupleIsAlive = true;
            reltuples += 1;
        }
 
        MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
        /* Set up for predicate or expression evaluation */
        ExecStoreBufferHeapTuple(heapTuple, slot, hscan->rs_cbuf);
 
        /*
         * In a partial index, discard tuples that don't satisfy the
         * predicate.
         */
        if (predicate != NULL)
        {
            if (!ExecQual(predicate, econtext))
                continue;
        }
 
        /*
         * For the current heap tuple, extract all the attributes we use in
         * this index, and note which are null.  This also performs evaluation
         * of any expressions needed.
         */
        FormIndexDatum(indexInfo,
                       slot,
                       estate,
                       values,
                       isnull);
 
        /*
         * You'd think we should go ahead and build the index tuple here, but
         * some index AMs want to do further processing on the data first.  So
         * pass the values[] and isnull[] arrays, instead.
         */
 
        if (HeapTupleIsHeapOnly(heapTuple))
        {
            /*
             * For a heap-only tuple, pretend its TID is that of the root. See
             * src/backend/access/heap/README.HOT for discussion.
             */
            ItemPointerData tid;
            OffsetNumber offnum;
 
            offnum = ItemPointerGetOffsetNumber(&heapTuple->t_self);
 
            /*
             * If a HOT tuple points to a root that we don't know about,
             * obtain root items afresh.  If that still fails, report it as
             * corruption.
             */
            if (root_offsets[offnum - 1] == InvalidOffsetNumber)
            {
                Page        page = BufferGetPage(hscan->rs_cbuf);
 
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
                heap_get_root_tuples(page, root_offsets);
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
            }
 
            if (!OffsetNumberIsValid(root_offsets[offnum - 1]))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
                                         ItemPointerGetBlockNumber(&heapTuple->t_self),
                                         offnum,
                                         RelationGetRelationName(heapRelation))));
 
            ItemPointerSet(&tid, ItemPointerGetBlockNumber(&heapTuple->t_self),
                           root_offsets[offnum - 1]);
 
            /* Call the AM's callback routine to process the tuple */
            callback(indexRelation, &tid, values, isnull, tupleIsAlive,
                     callback_state);
        }
        else
        {
            /* Call the AM's callback routine to process the tuple */
            callback(indexRelation, &heapTuple->t_self, values, isnull,
                     tupleIsAlive, callback_state);
        }
    }
 
    /* Report scan progress one last time. */
    if (progress)
    {
        BlockNumber blks_done;
 
        if (hscan->rs_base.rs_parallel != NULL)
        {
            ParallelBlockTableScanDesc pbscan;
 
            pbscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
            blks_done = pbscan->phs_nblocks;
        }
        else
            blks_done = hscan->rs_nblocks;
 
        pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
                                     blks_done);
    }
 
    table_endscan(scan);
 
    /* we can now forget our snapshot, if set and registered by us */
    if (need_unregister_snapshot)
        UnregisterSnapshot(snapshot);
 
    ExecDropSingleTupleTableSlot(slot);
 
    FreeExecutorState(estate);
 
    /* These may have been pointing to the now-gone estate */
    indexInfo->ii_ExpressionsState = NIL;
    indexInfo->ii_PredicateState = NULL;
 
    return reltuples;
}

References Assert, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), callback(), CHECK_FOR_INTERRUPTS, CreateExecutorState(), ExprContext::ecxt_per_tuple_memory, ExprContext::ecxt_scantuple, elog, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, ExecDropSingleTupleTableSlot(), ExecPrepareQual(), ExecQual(), ExecStoreBufferHeapTuple(), fb(), FormIndexDatum(), ForwardScanDirection, FreeExecutorState(), GetOldestNonRemovableTransactionId(), GetPerTupleExprContext, GetTransactionSnapshot(), heap_get_root_tuples(), heap_getnext(), heap_setscanlimits(), heapam_scan_get_blocks_done(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleIsHeapOnly(), HeapTupleIsHotUpdated(), HeapTupleSatisfiesVacuum(), IndexInfo::ii_BrokenHotChain, IndexInfo::ii_Concurrent, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExpressionsState, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_Unique, INDEX_MAX_KEYS, InvalidBlockNumber, InvalidOffsetNumber, InvalidTransactionId, IsBootstrapProcessingMode, IsMVCCSnapshot, IsSystemRelation(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerSet(), LockBuffer(), MaxHeapTuplesPerPage, MemoryContextReset(), NIL, OffsetNumberIsValid, OidIsValid, pgstat_progress_update_param(), progress, PROGRESS_SCAN_BLOCKS_DONE, PROGRESS_SCAN_BLOCKS_TOTAL, RelationData::rd_rel, RegisterSnapshot(), RelationGetRelationName, TableScanDescData::rs_snapshot, SnapshotAny, table_beginscan_strat(), table_endscan(), table_slot_create(), TransactionIdIsCurrentTransactionId(), TransactionIdIsValid, UnregisterSnapshot(), values, WARNING, XactLockTableWait(), and XLTW_InsertIndexUnique.

heapam_index_validate_scan()

static void heapam_index_validate_scan ( Relation  heapRelation, Relation  indexRelation, IndexInfo *  indexInfo, Snapshot  snapshot, ValidateIndexState *  state  )

static

Definition at line 1712 of file heapam_handler.c.

{
    TableScanDesc scan;
    HeapScanDesc hscan;
    HeapTuple   heapTuple;
    Datum       values[INDEX_MAX_KEYS];
    bool        isnull[INDEX_MAX_KEYS];
    ExprState  *predicate;
    TupleTableSlot *slot;
    EState     *estate;
    ExprContext *econtext;
    BlockNumber root_blkno = InvalidBlockNumber;
    OffsetNumber root_offsets[MaxHeapTuplesPerPage];
    bool        in_index[MaxHeapTuplesPerPage];
    BlockNumber previous_blkno = InvalidBlockNumber;
 
    /* state variables for the merge */
    ItemPointer indexcursor = NULL;
    ItemPointerData decoded;
    bool        tuplesort_empty = false;
 
    /*
     * sanity checks
     */
    Assert(OidIsValid(indexRelation->rd_rel->relam));
 
    /*
     * Need an EState for evaluation of index expressions and partial-index
     * predicates.  Also a slot to hold the current tuple.
     */
    estate = CreateExecutorState();
    econtext = GetPerTupleExprContext(estate);
    slot = MakeSingleTupleTableSlot(RelationGetDescr(heapRelation),
                                    &TTSOpsHeapTuple);
 
    /* Arrange for econtext's scan tuple to be the tuple under test */
    econtext->ecxt_scantuple = slot;
 
    /* Set up execution state for predicate, if any. */
    predicate = ExecPrepareQual(indexInfo->ii_Predicate, estate);
 
    /*
     * Prepare for scan of the base relation.  We need just those tuples
     * satisfying the passed-in reference snapshot.  We must disable syncscan
     * here, because it's critical that we read from block zero forward to
     * match the sorted TIDs.
     */
    scan = table_beginscan_strat(heapRelation,  /* relation */
                                 snapshot,  /* snapshot */
                                 0, /* number of keys */
                                 NULL,  /* scan key */
                                 true,  /* buffer access strategy OK */
                                 false);    /* syncscan not OK */
    hscan = (HeapScanDesc) scan;
 
    pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_TOTAL,
                                 hscan->rs_nblocks);
 
    /*
     * Scan all tuples matching the snapshot.
     */
    while ((heapTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
    {
        ItemPointer heapcursor = &heapTuple->t_self;
        ItemPointerData rootTuple;
        OffsetNumber root_offnum;
 
        CHECK_FOR_INTERRUPTS();
 
        state->htups += 1;
 
        if ((previous_blkno == InvalidBlockNumber) ||
            (hscan->rs_cblock != previous_blkno))
        {
            pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE,
                                         hscan->rs_cblock);
            previous_blkno = hscan->rs_cblock;
        }
 
        /*
         * As commented in table_index_build_scan, we should index heap-only
         * tuples under the TIDs of their root tuples; so when we advance onto
         * a new heap page, build a map of root item offsets on the page.
         *
         * This complicates merging against the tuplesort output: we will
         * visit the live tuples in order by their offsets, but the root
         * offsets that we need to compare against the index contents might be
         * ordered differently.  So we might have to "look back" within the
         * tuplesort output, but only within the current page.  We handle that
         * by keeping a bool array in_index[] showing all the
         * already-passed-over tuplesort output TIDs of the current page. We
         * clear that array here, when advancing onto a new heap page.
         */
        if (hscan->rs_cblock != root_blkno)
        {
            Page        page = BufferGetPage(hscan->rs_cbuf);
 
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
            heap_get_root_tuples(page, root_offsets);
            LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            memset(in_index, 0, sizeof(in_index));
 
            root_blkno = hscan->rs_cblock;
        }
 
        /* Convert actual tuple TID to root TID */
        rootTuple = *heapcursor;
        root_offnum = ItemPointerGetOffsetNumber(heapcursor);
 
        if (HeapTupleIsHeapOnly(heapTuple))
        {
            root_offnum = root_offsets[root_offnum - 1];
            if (!OffsetNumberIsValid(root_offnum))
                ereport(ERROR,
                        (errcode(ERRCODE_DATA_CORRUPTED),
                         errmsg_internal("failed to find parent tuple for heap-only tuple at (%u,%u) in table \"%s\"",
                                         ItemPointerGetBlockNumber(heapcursor),
                                         ItemPointerGetOffsetNumber(heapcursor),
                                         RelationGetRelationName(heapRelation))));
            ItemPointerSetOffsetNumber(&rootTuple, root_offnum);
        }
 
        /*
         * "merge" by skipping through the index tuples until we find or pass
         * the current root tuple.
         */
        while (!tuplesort_empty &&
               (!indexcursor ||
                ItemPointerCompare(indexcursor, &rootTuple) < 0))
        {
            Datum       ts_val;
            bool        ts_isnull;
 
            if (indexcursor)
            {
                /*
                 * Remember index items seen earlier on the current heap page
                 */
                if (ItemPointerGetBlockNumber(indexcursor) == root_blkno)
                    in_index[ItemPointerGetOffsetNumber(indexcursor) - 1] = true;
            }
 
            tuplesort_empty = !tuplesort_getdatum(state->tuplesort, true,
                                                  false, &ts_val, &ts_isnull,
                                                  NULL);
            Assert(tuplesort_empty || !ts_isnull);
            if (!tuplesort_empty)
            {
                itemptr_decode(&decoded, DatumGetInt64(ts_val));
                indexcursor = &decoded;
            }
            else
            {
                /* Be tidy */
                indexcursor = NULL;
            }
        }
 
        /*
         * If the tuplesort has overshot *and* we didn't see a match earlier,
         * then this tuple is missing from the index, so insert it.
         */
        if ((tuplesort_empty ||
             ItemPointerCompare(indexcursor, &rootTuple) > 0) &&
            !in_index[root_offnum - 1])
        {
            MemoryContextReset(econtext->ecxt_per_tuple_memory);
 
            /* Set up for predicate or expression evaluation */
            ExecStoreHeapTuple(heapTuple, slot, false);
 
            /*
             * In a partial index, discard tuples that don't satisfy the
             * predicate.
             */
            if (predicate != NULL)
            {
                if (!ExecQual(predicate, econtext))
                    continue;
            }
 
            /*
             * For the current heap tuple, extract all the attributes we use
             * in this index, and note which are null.  This also performs
             * evaluation of any expressions needed.
             */
            FormIndexDatum(indexInfo,
                           slot,
                           estate,
                           values,
                           isnull);
 
            /*
             * You'd think we should go ahead and build the index tuple here,
             * but some index AMs want to do further processing on the data
             * first. So pass the values[] and isnull[] arrays, instead.
             */
 
            /*
             * If the tuple is already committed dead, you might think we
             * could suppress uniqueness checking, but this is no longer true
             * in the presence of HOT, because the insert is actually a proxy
             * for a uniqueness check on the whole HOT-chain.  That is, the
             * tuple we have here could be dead because it was already
             * HOT-updated, and if so the updating transaction will not have
             * thought it should insert index entries.  The index AM will
             * check the whole HOT-chain and correctly detect a conflict if
             * there is one.
             */
 
            index_insert(indexRelation,
                         values,
                         isnull,
                         &rootTuple,
                         heapRelation,
                         indexInfo->ii_Unique ?
                         UNIQUE_CHECK_YES : UNIQUE_CHECK_NO,
                         false,
                         indexInfo);
 
            state->tups_inserted += 1;
        }
    }
 
    table_endscan(scan);
 
    ExecDropSingleTupleTableSlot(slot);
 
    FreeExecutorState(estate);
 
    /* These may have been pointing to the now-gone estate */
    indexInfo->ii_ExpressionsState = NIL;
    indexInfo->ii_PredicateState = NULL;
}

References Assert, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), CHECK_FOR_INTERRUPTS, CreateExecutorState(), DatumGetInt64(), ExprContext::ecxt_per_tuple_memory, ExprContext::ecxt_scantuple, ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg_internal(), ERROR, ExecDropSingleTupleTableSlot(), ExecPrepareQual(), ExecQual(), ExecStoreHeapTuple(), fb(), FormIndexDatum(), ForwardScanDirection, FreeExecutorState(), GetPerTupleExprContext, heap_get_root_tuples(), heap_getnext(), HeapTupleIsHeapOnly(), IndexInfo::ii_ExpressionsState, IndexInfo::ii_Predicate, IndexInfo::ii_PredicateState, IndexInfo::ii_Unique, index_insert(), INDEX_MAX_KEYS, InvalidBlockNumber, ItemPointerCompare(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerSetOffsetNumber(), itemptr_decode(), LockBuffer(), MakeSingleTupleTableSlot(), MaxHeapTuplesPerPage, MemoryContextReset(), NIL, OffsetNumberIsValid, OidIsValid, pgstat_progress_update_param(), PROGRESS_SCAN_BLOCKS_DONE, PROGRESS_SCAN_BLOCKS_TOTAL, RelationData::rd_rel, RelationGetDescr, RelationGetRelationName, table_beginscan_strat(), table_endscan(), TTSOpsHeapTuple, tuplesort_getdatum(), UNIQUE_CHECK_NO, UNIQUE_CHECK_YES, and values.

heapam_relation_copy_data()

static void heapam_relation_copy_data ( Relation  rel, const RelFileLocator *  newrlocator  )

static

Definition at line 535 of file heapam_handler.c.

{
    SMgrRelation dstrel;
 
    /*
     * Since we copy the file directly without looking at the shared buffers,
     * we'd better first flush out any pages of the source relation that are
     * in shared buffers.  We assume no new changes will be made while we are
     * holding exclusive lock on the rel.
     */
    FlushRelationBuffers(rel);
 
    /*
     * Create and copy all forks of the relation, and schedule unlinking of
     * old physical files.
     *
     * NOTE: any conflict in relfilenumber value will be caught in
     * RelationCreateStorage().
     */
    dstrel = RelationCreateStorage(*newrlocator, rel->rd_rel->relpersistence, true);
 
    /* copy main fork */
    RelationCopyStorage(RelationGetSmgr(rel), dstrel, MAIN_FORKNUM,
                        rel->rd_rel->relpersistence);
 
    /* copy those extra forks that exist */
    for (ForkNumber forkNum = MAIN_FORKNUM + 1;
         forkNum <= MAX_FORKNUM; forkNum++)
    {
        if (smgrexists(RelationGetSmgr(rel), forkNum))
        {
            smgrcreate(dstrel, forkNum, false);
 
            /*
             * WAL log creation if the relation is persistent, or this is the
             * init fork of an unlogged relation.
             */
            if (RelationIsPermanent(rel) ||
                (rel->rd_rel->relpersistence == RELPERSISTENCE_UNLOGGED &&
                 forkNum == INIT_FORKNUM))
                log_smgrcreate(newrlocator, forkNum);
            RelationCopyStorage(RelationGetSmgr(rel), dstrel, forkNum,
                                rel->rd_rel->relpersistence);
        }
    }
 
 
    /* drop old relation, and close new one */
    RelationDropStorage(rel);
    smgrclose(dstrel);
}

References fb(), FlushRelationBuffers(), INIT_FORKNUM, log_smgrcreate(), MAIN_FORKNUM, MAX_FORKNUM, RelationData::rd_rel, RelationCopyStorage(), RelationCreateStorage(), RelationDropStorage(), RelationGetSmgr(), RelationIsPermanent, smgrclose(), smgrcreate(), and smgrexists().

heapam_relation_copy_for_cluster()

static void heapam_relation_copy_for_cluster ( Relation  OldHeap, Relation  NewHeap, Relation  OldIndex, bool  use_sort, TransactionId  OldestXmin, Snapshot  snapshot, TransactionId *  xid_cutoff, MultiXactId *  multi_cutoff, double *  num_tuples, double *  tups_vacuumed, double *  tups_recently_dead  )

static

Definition at line 588 of file heapam_handler.c.

{
    RewriteState rwstate;
    BulkInsertState bistate;
    IndexScanDesc indexScan;
    TableScanDesc tableScan;
    HeapScanDesc heapScan;
    bool        is_system_catalog;
    Tuplesortstate *tuplesort;
    TupleDesc   oldTupDesc = RelationGetDescr(OldHeap);
    TupleDesc   newTupDesc = RelationGetDescr(NewHeap);
    TupleTableSlot *slot;
    int         natts;
    Datum      *values;
    bool       *isnull;
    BufferHeapTupleTableSlot *hslot;
    BlockNumber prev_cblock = InvalidBlockNumber;
    bool        concurrent = snapshot != NULL;
 
    /* Remember if it's a system catalog */
    is_system_catalog = IsSystemRelation(OldHeap);
 
    /*
     * Valid smgr_targblock implies something already wrote to the relation.
     * This may be harmless, but this function hasn't planned for it.
     */
    Assert(RelationGetTargetBlock(NewHeap) == InvalidBlockNumber);
 
    /* Preallocate values/isnull arrays */
    natts = newTupDesc->natts;
    values = palloc_array(Datum, natts);
    isnull = palloc_array(bool, natts);
 
    /*
     * In non-concurrent mode, initialize the rewrite operation.  This is not
     * needed in concurrent mode.
     */
    if (!concurrent)
        rwstate = begin_heap_rewrite(OldHeap, NewHeap, OldestXmin,
                                     *xid_cutoff, *multi_cutoff);
    else
        rwstate = NULL;
 
    /* In concurrent mode, prepare for bulk-insert operation. */
    if (concurrent)
        bistate = GetBulkInsertState();
    else
        bistate = NULL;
 
    /* Set up sorting if wanted */
    if (use_sort)
        tuplesort = tuplesort_begin_cluster(oldTupDesc, OldIndex,
                                            maintenance_work_mem,
                                            NULL, TUPLESORT_NONE);
    else
        tuplesort = NULL;
 
    /*
     * Prepare to scan the OldHeap.  To ensure we see recently-dead tuples
     * that still need to be copied, we scan with SnapshotAny and use
     * HeapTupleSatisfiesVacuum for the visibility test.
     *
     * In the CONCURRENTLY case, we do regular MVCC visibility tests, using
     * the snapshot passed by the caller.
     */
    if (OldIndex != NULL && !use_sort)
    {
        const int   ci_index[] = {
            PROGRESS_REPACK_PHASE,
            PROGRESS_REPACK_INDEX_RELID
        };
        int64       ci_val[2];
 
        /* Set phase and OIDOldIndex to columns */
        ci_val[0] = PROGRESS_REPACK_PHASE_INDEX_SCAN_HEAP;
        ci_val[1] = RelationGetRelid(OldIndex);
        pgstat_progress_update_multi_param(2, ci_index, ci_val);
 
        tableScan = NULL;
        heapScan = NULL;
        indexScan = index_beginscan(OldHeap, OldIndex,
                                    snapshot ? snapshot : SnapshotAny,
                                    NULL, 0, 0,
                                    SO_NONE);
        index_rescan(indexScan, NULL, 0, NULL, 0);
    }
    else
    {
        /* In scan-and-sort mode and also VACUUM FULL, set phase */
        pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                     PROGRESS_REPACK_PHASE_SEQ_SCAN_HEAP);
 
        tableScan = table_beginscan(OldHeap,
                                    snapshot ? snapshot : SnapshotAny,
                                    0, (ScanKey) NULL,
                                    SO_NONE);
        heapScan = (HeapScanDesc) tableScan;
        indexScan = NULL;
 
        /* Set total heap blocks */
        pgstat_progress_update_param(PROGRESS_REPACK_TOTAL_HEAP_BLKS,
                                     heapScan->rs_nblocks);
    }
 
    slot = table_slot_create(OldHeap, NULL);
    hslot = (BufferHeapTupleTableSlot *) slot;
 
    /*
     * Scan through the OldHeap, either in OldIndex order or sequentially;
     * copy each tuple into the NewHeap, or transiently to the tuplesort
     * module.  Note that we don't bother sorting dead tuples (they won't get
     * to the new table anyway).
     */
    for (;;)
    {
        HeapTuple   tuple;
        Buffer      buf;
        bool        isdead;
 
        CHECK_FOR_INTERRUPTS();
 
        if (indexScan != NULL)
        {
            if (!index_getnext_slot(indexScan, ForwardScanDirection, slot))
                break;
 
            /* Since we used no scan keys, should never need to recheck */
            if (indexScan->xs_recheck)
                elog(ERROR, "CLUSTER does not support lossy index conditions");
        }
        else
        {
            if (!table_scan_getnextslot(tableScan, ForwardScanDirection, slot))
            {
                /*
                 * If the last pages of the scan were empty, we would go to
                 * the next phase while heap_blks_scanned != heap_blks_total.
                 * Instead, to ensure that heap_blks_scanned is equivalent to
                 * heap_blks_total after the table scan phase, this parameter
                 * is manually updated to the correct value when the table
                 * scan finishes.
                 */
                pgstat_progress_update_param(PROGRESS_REPACK_HEAP_BLKS_SCANNED,
                                             heapScan->rs_nblocks);
                break;
            }
 
            /*
             * In scan-and-sort mode and also VACUUM FULL, set heap blocks
             * scanned
             *
             * Note that heapScan may start at an offset and wrap around, i.e.
             * rs_startblock may be >0, and rs_cblock may end with a number
             * below rs_startblock. To prevent showing this wraparound to the
             * user, we offset rs_cblock by rs_startblock (modulo rs_nblocks).
             */
            if (prev_cblock != heapScan->rs_cblock)
            {
                pgstat_progress_update_param(PROGRESS_REPACK_HEAP_BLKS_SCANNED,
                                             (heapScan->rs_cblock +
                                              heapScan->rs_nblocks -
                                              heapScan->rs_startblock
                                              ) % heapScan->rs_nblocks + 1);
                prev_cblock = heapScan->rs_cblock;
            }
        }
 
        tuple = ExecFetchSlotHeapTuple(slot, false, NULL);
        buf = hslot->buffer;
 
        /*
         * In concurrent mode, our table or index scan has used regular MVCC
         * visibility test against a snapshot passed by caller; therefore we
         * don't need another visibility test.  In non-concurrent mode
         * however, we must test the visibility of each tuple we read.
         */
        if (!concurrent)
        {
            /*
             * To be able to guarantee that we can set the hint bit, acquire
             * an exclusive lock on the old buffer. We need the hint bits, set
             * in heapam_relation_copy_for_cluster() ->
             * HeapTupleSatisfiesVacuum(), to be set, as otherwise
             * reform_and_rewrite_tuple() -> rewrite_heap_tuple() will get
             * confused. Specifically, rewrite_heap_tuple() checks for
             * HEAP_XMAX_INVALID in the old tuple to determine whether to
             * check the old-to-new mapping hash table.
             *
             * It'd be better if we somehow could avoid setting hint bits on
             * the old page. One reason to use VACUUM FULL are very bloated
             * tables - rewriting most of the old table during VACUUM FULL
             * doesn't exactly help...
             */
            LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 
            switch (HeapTupleSatisfiesVacuum(tuple, OldestXmin, buf))
            {
                case HEAPTUPLE_DEAD:
                    /* Definitely dead */
                    isdead = true;
                    break;
                case HEAPTUPLE_RECENTLY_DEAD:
                    *tups_recently_dead += 1;
                    pg_fallthrough;
                case HEAPTUPLE_LIVE:
                    /* Live or recently dead, must copy it */
                    isdead = false;
                    break;
                case HEAPTUPLE_INSERT_IN_PROGRESS:
 
                    /*
                     * As long as we hold exclusive lock on the relation,
                     * normally the only way to see this is if it was inserted
                     * earlier in our own transaction.  However, it can happen
                     * in system catalogs, since we tend to release write lock
                     * before commit there. Give a warning if neither case
                     * applies; but in any case we had better copy it.
                     */
                    if (!is_system_catalog &&
                        !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tuple->t_data)))
                        elog(WARNING, "concurrent insert in progress within table \"%s\"",
                             RelationGetRelationName(OldHeap));
                    /* treat as live */
                    isdead = false;
                    break;
                case HEAPTUPLE_DELETE_IN_PROGRESS:
 
                    /*
                     * Similar situation to INSERT_IN_PROGRESS case.
                     */
                    if (!is_system_catalog &&
                        !TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tuple->t_data)))
                        elog(WARNING, "concurrent delete in progress within table \"%s\"",
                             RelationGetRelationName(OldHeap));
                    /* treat as recently dead */
                    *tups_recently_dead += 1;
                    isdead = false;
                    break;
                default:
                    elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                    isdead = false; /* keep compiler quiet */
                    break;
            }
 
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
 
            if (isdead)
            {
                *tups_vacuumed += 1;
                /* heap rewrite module still needs to see it... */
                if (rewrite_heap_dead_tuple(rwstate, tuple))
                {
                    /* A previous recently-dead tuple is now known dead */
                    *tups_vacuumed += 1;
                    *tups_recently_dead -= 1;
                }
 
                continue;
            }
        }
 
        *num_tuples += 1;
        if (tuplesort != NULL)
        {
            tuplesort_putheaptuple(tuplesort, tuple);
 
            /*
             * In scan-and-sort mode, report increase in number of tuples
             * scanned
             */
            pgstat_progress_update_param(PROGRESS_REPACK_HEAP_TUPLES_SCANNED,
                                         *num_tuples);
        }
        else
        {
            const int   ct_index[] = {
                PROGRESS_REPACK_HEAP_TUPLES_SCANNED,
                PROGRESS_REPACK_HEAP_TUPLES_INSERTED
            };
            int64       ct_val[2];
 
            if (!concurrent)
                reform_and_rewrite_tuple(tuple, OldHeap, NewHeap,
                                         values, isnull, rwstate);
            else
                heap_insert_for_repack(tuple, OldHeap, NewHeap,
                                       values, isnull, bistate);
 
            /*
             * In indexscan mode and also VACUUM FULL, report increase in
             * number of tuples scanned and written
             */
            ct_val[0] = *num_tuples;
            ct_val[1] = *num_tuples;
            pgstat_progress_update_multi_param(2, ct_index, ct_val);
        }
    }
 
    if (indexScan != NULL)
        index_endscan(indexScan);
    if (tableScan != NULL)
        table_endscan(tableScan);
    if (slot)
        ExecDropSingleTupleTableSlot(slot);
 
    /*
     * In scan-and-sort mode, complete the sort, then read out all live tuples
     * from the tuplestore and write them to the new relation.
     */
    if (tuplesort != NULL)
    {
        double      n_tuples = 0;
 
        /* Report that we are now sorting tuples */
        pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                     PROGRESS_REPACK_PHASE_SORT_TUPLES);
 
        tuplesort_performsort(tuplesort);
 
        /* Report that we are now writing new heap */
        pgstat_progress_update_param(PROGRESS_REPACK_PHASE,
                                     PROGRESS_REPACK_PHASE_WRITE_NEW_HEAP);
 
        for (;;)
        {
            HeapTuple   tuple;
 
            CHECK_FOR_INTERRUPTS();
 
            tuple = tuplesort_getheaptuple(tuplesort, true);
            if (tuple == NULL)
                break;
 
            n_tuples += 1;
            if (!concurrent)
                reform_and_rewrite_tuple(tuple,
                                         OldHeap, NewHeap,
                                         values, isnull,
                                         rwstate);
            else
                heap_insert_for_repack(tuple, OldHeap, NewHeap,
                                       values, isnull, bistate);
 
            /* Report n_tuples */
            pgstat_progress_update_param(PROGRESS_REPACK_HEAP_TUPLES_INSERTED,
                                         n_tuples);
        }
 
        tuplesort_end(tuplesort);
    }
 
    /* Write out any remaining tuples, and fsync if needed */
    if (rwstate)
        end_heap_rewrite(rwstate);
    if (bistate)
        FreeBulkInsertState(bistate);
 
    /* Clean up */
    pfree(values);
    pfree(isnull);
}

References Assert, begin_heap_rewrite(), buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, CHECK_FOR_INTERRUPTS, elog, end_heap_rewrite(), ERROR, ExecDropSingleTupleTableSlot(), ExecFetchSlotHeapTuple(), fb(), ForwardScanDirection, FreeBulkInsertState(), GetBulkInsertState(), heap_insert_for_repack(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVacuum(), index_beginscan(), index_endscan(), index_getnext_slot(), index_rescan(), InvalidBlockNumber, IsSystemRelation(), LockBuffer(), maintenance_work_mem, palloc_array, pfree(), pg_fallthrough, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_REPACK_HEAP_BLKS_SCANNED, PROGRESS_REPACK_HEAP_TUPLES_INSERTED, PROGRESS_REPACK_HEAP_TUPLES_SCANNED, PROGRESS_REPACK_INDEX_RELID, PROGRESS_REPACK_PHASE, PROGRESS_REPACK_PHASE_INDEX_SCAN_HEAP, PROGRESS_REPACK_PHASE_SEQ_SCAN_HEAP, PROGRESS_REPACK_PHASE_SORT_TUPLES, PROGRESS_REPACK_PHASE_WRITE_NEW_HEAP, PROGRESS_REPACK_TOTAL_HEAP_BLKS, reform_and_rewrite_tuple(), RelationGetDescr, RelationGetRelationName, RelationGetRelid, RelationGetTargetBlock, rewrite_heap_dead_tuple(), SnapshotAny, SO_NONE, HeapTupleData::t_data, table_beginscan(), table_endscan(), table_scan_getnextslot(), table_slot_create(), TransactionIdIsCurrentTransactionId(), tuplesort_begin_cluster(), tuplesort_end(), tuplesort_getheaptuple(), TUPLESORT_NONE, tuplesort_performsort(), tuplesort_putheaptuple(), values, and WARNING.

heapam_relation_needs_toast_table()

static bool heapam_relation_needs_toast_table ( Relation  rel )

static

Definition at line 2004 of file heapam_handler.c.

{
    int32       data_length = 0;
    bool        maxlength_unknown = false;
    bool        has_toastable_attrs = false;
    TupleDesc   tupdesc = rel->rd_att;
    int32       tuple_length;
    int         i;
 
    for (i = 0; i < tupdesc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
 
        if (att->attisdropped)
            continue;
        if (att->attgenerated == ATTRIBUTE_GENERATED_VIRTUAL)
            continue;
        data_length = att_align_nominal(data_length, att->attalign);
        if (att->attlen > 0)
        {
            /* Fixed-length types are never toastable */
            data_length += att->attlen;
        }
        else
        {
            int32       maxlen = type_maximum_size(att->atttypid,
                                                   att->atttypmod);
 
            if (maxlen < 0)
                maxlength_unknown = true;
            else
                data_length += maxlen;
            if (att->attstorage != TYPSTORAGE_PLAIN)
                has_toastable_attrs = true;
        }
    }
    if (!has_toastable_attrs)
        return false;           /* nothing to toast? */
    if (maxlength_unknown)
        return true;            /* any unlimited-length attrs? */
    tuple_length = MAXALIGN(SizeofHeapTupleHeader +
                            BITMAPLEN(tupdesc->natts)) +
        MAXALIGN(data_length);
    return (tuple_length > TOAST_TUPLE_THRESHOLD);
}

References att_align_nominal, BITMAPLEN(), fb(), i, MAXALIGN, TupleDescData::natts, RelationData::rd_att, SizeofHeapTupleHeader, TOAST_TUPLE_THRESHOLD, TupleDescAttr(), and type_maximum_size().

heapam_relation_nontransactional_truncate()

static void heapam_relation_nontransactional_truncate ( Relation  rel )

static

Definition at line 529 of file heapam_handler.c.

{
    RelationTruncate(rel, 0);
}

References RelationTruncate().

heapam_relation_set_new_filelocator()

static void heapam_relation_set_new_filelocator ( Relation  rel, const RelFileLocator *  newrlocator, char  persistence, TransactionId *  freezeXid, MultiXactId *  minmulti  )

static

Definition at line 486 of file heapam_handler.c.

{
    SMgrRelation srel;
 
    /*
     * Initialize to the minimum XID that could put tuples in the table. We
     * know that no xacts older than RecentXmin are still running, so that
     * will do.
     */
    *freezeXid = RecentXmin;
 
    /*
     * Similarly, initialize the minimum Multixact to the first value that
     * could possibly be stored in tuples in the table.  Running transactions
     * could reuse values from their local cache, so we are careful to
     * consider all currently running multis.
     *
     * XXX this could be refined further, but is it worth the hassle?
     */
    *minmulti = GetOldestMultiXactId();
 
    srel = RelationCreateStorage(*newrlocator, persistence, true);
 
    /*
     * If required, set up an init fork for an unlogged table so that it can
     * be correctly reinitialized on restart.
     */
    if (persistence == RELPERSISTENCE_UNLOGGED)
    {
        Assert(rel->rd_rel->relkind == RELKIND_RELATION ||
               rel->rd_rel->relkind == RELKIND_TOASTVALUE);
        smgrcreate(srel, INIT_FORKNUM, false);
        log_smgrcreate(newrlocator, INIT_FORKNUM);
    }
 
    smgrclose(srel);
}

References Assert, fb(), GetOldestMultiXactId(), INIT_FORKNUM, log_smgrcreate(), RelationData::rd_rel, RecentXmin, RelationCreateStorage(), smgrclose(), and smgrcreate().

heapam_relation_toast_am()

static Oid heapam_relation_toast_am ( Relation  rel )

static

Definition at line 2054 of file heapam_handler.c.

{
    return rel->rd_rel->relam;
}

References RelationData::rd_rel.

heapam_scan_analyze_next_block()

static bool heapam_scan_analyze_next_block ( TableScanDesc  scan, ReadStream *  stream  )

static

Definition at line 968 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
 
    /*
     * We must maintain a pin on the target page's buffer to ensure that
     * concurrent activity - e.g. HOT pruning - doesn't delete tuples out from
     * under us.  It comes from the stream already pinned.   We also choose to
     * hold sharelock on the buffer throughout --- we could release and
     * re-acquire sharelock for each tuple, but since we aren't doing much
     * work per tuple, the extra lock traffic is probably better avoided.
     */
    hscan->rs_cbuf = read_stream_next_buffer(stream, NULL);
    if (!BufferIsValid(hscan->rs_cbuf))
        return false;
 
    LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
    hscan->rs_cblock = BufferGetBlockNumber(hscan->rs_cbuf);
    hscan->rs_cindex = FirstOffsetNumber;
    return true;
}

References BUFFER_LOCK_SHARE, BufferGetBlockNumber(), BufferIsValid(), fb(), FirstOffsetNumber, LockBuffer(), and read_stream_next_buffer().

heapam_scan_analyze_next_tuple()

static bool heapam_scan_analyze_next_tuple ( TableScanDesc  scan, double *  liverows, double *  deadrows, TupleTableSlot *  slot  )

static

Definition at line 992 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
    Page        targpage;
    OffsetNumber maxoffset;
    BufferHeapTupleTableSlot *hslot;
 
    Assert(TTS_IS_BUFFERTUPLE(slot));
 
    hslot = (BufferHeapTupleTableSlot *) slot;
    targpage = BufferGetPage(hscan->rs_cbuf);
    maxoffset = PageGetMaxOffsetNumber(targpage);
 
    /* Inner loop over all tuples on the selected page */
    for (; hscan->rs_cindex <= maxoffset; hscan->rs_cindex++)
    {
        ItemId      itemid;
        HeapTuple   targtuple = &hslot->base.tupdata;
        bool        sample_it = false;
        TransactionId dead_after;
 
        itemid = PageGetItemId(targpage, hscan->rs_cindex);
 
        /*
         * We ignore unused and redirect line pointers.  DEAD line pointers
         * should be counted as dead, because we need vacuum to run to get rid
         * of them.  Note that this rule agrees with the way that
         * heap_page_prune_and_freeze() counts things.
         */
        if (!ItemIdIsNormal(itemid))
        {
            if (ItemIdIsDead(itemid))
                *deadrows += 1;
            continue;
        }
 
        ItemPointerSet(&targtuple->t_self, hscan->rs_cblock, hscan->rs_cindex);
 
        targtuple->t_tableOid = RelationGetRelid(scan->rs_rd);
        targtuple->t_data = (HeapTupleHeader) PageGetItem(targpage, itemid);
        targtuple->t_len = ItemIdGetLength(itemid);
 
        switch (HeapTupleSatisfiesVacuumHorizon(targtuple,
                                                hscan->rs_cbuf,
                                                &dead_after))
        {
            case HEAPTUPLE_LIVE:
                sample_it = true;
                *liverows += 1;
                break;
 
            case HEAPTUPLE_DEAD:
            case HEAPTUPLE_RECENTLY_DEAD:
                /* Count dead and recently-dead rows */
                *deadrows += 1;
                break;
 
            case HEAPTUPLE_INSERT_IN_PROGRESS:
 
                /*
                 * Insert-in-progress rows are not counted.  We assume that
                 * when the inserting transaction commits or aborts, it will
                 * send a stats message to increment the proper count.  This
                 * works right only if that transaction ends after we finish
                 * analyzing the table; if things happen in the other order,
                 * its stats update will be overwritten by ours.  However, the
                 * error will be large only if the other transaction runs long
                 * enough to insert many tuples, so assuming it will finish
                 * after us is the safer option.
                 *
                 * A special case is that the inserting transaction might be
                 * our own.  In this case we should count and sample the row,
                 * to accommodate users who load a table and analyze it in one
                 * transaction.  (pgstat_report_analyze has to adjust the
                 * numbers we report to the cumulative stats system to make
                 * this come out right.)
                 */
                if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple->t_data)))
                {
                    sample_it = true;
                    *liverows += 1;
                }
                break;
 
            case HEAPTUPLE_DELETE_IN_PROGRESS:
 
                /*
                 * We count and sample delete-in-progress rows the same as
                 * live ones, so that the stats counters come out right if the
                 * deleting transaction commits after us, per the same
                 * reasoning given above.
                 *
                 * If the delete was done by our own transaction, however, we
                 * must count the row as dead to make pgstat_report_analyze's
                 * stats adjustments come out right.  (Note: this works out
                 * properly when the row was both inserted and deleted in our
                 * xact.)
                 *
                 * The net effect of these choices is that we act as though an
                 * IN_PROGRESS transaction hasn't happened yet, except if it
                 * is our own transaction, which we assume has happened.
                 *
                 * This approach ensures that we behave sanely if we see both
                 * the pre-image and post-image rows for a row being updated
                 * by a concurrent transaction: we will sample the pre-image
                 * but not the post-image.  We also get sane results if the
                 * concurrent transaction never commits.
                 */
                if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(targtuple->t_data)))
                    *deadrows += 1;
                else
                {
                    sample_it = true;
                    *liverows += 1;
                }
                break;
 
            default:
                elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
                break;
        }
 
        if (sample_it)
        {
            ExecStoreBufferHeapTuple(targtuple, slot, hscan->rs_cbuf);
            hscan->rs_cindex++;
 
            /* note that we leave the buffer locked here! */
            return true;
        }
    }
 
    /* Now release the lock and pin on the page */
    UnlockReleaseBuffer(hscan->rs_cbuf);
    hscan->rs_cbuf = InvalidBuffer;
 
    /* also prevent old slot contents from having pin on page */
    ExecClearTuple(slot);
 
    return false;
}

References Assert, BufferGetPage(), elog, ERROR, ExecClearTuple(), ExecStoreBufferHeapTuple(), fb(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleSatisfiesVacuumHorizon(), InvalidBuffer, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemPointerSet(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationGetRelid, TableScanDescData::rs_rd, TransactionIdIsCurrentTransactionId(), TTS_IS_BUFFERTUPLE, and UnlockReleaseBuffer().

heapam_scan_bitmap_next_tuple()

static bool heapam_scan_bitmap_next_tuple ( TableScanDesc  scan, TupleTableSlot *  slot, bool *  recheck, uint64 *  lossy_pages, uint64 *  exact_pages  )

static

Definition at line 2088 of file heapam_handler.c.

{
    BitmapHeapScanDesc bscan = (BitmapHeapScanDesc) scan;
    HeapScanDesc hscan = (HeapScanDesc) bscan;
    OffsetNumber targoffset;
    Page        page;
    ItemId      lp;
 
    /*
     * Out of range?  If so, nothing more to look at on this page
     */
    while (hscan->rs_cindex >= hscan->rs_ntuples)
    {
        /*
         * Returns false if the bitmap is exhausted and there are no further
         * blocks we need to scan.
         */
        if (!BitmapHeapScanNextBlock(scan, recheck, lossy_pages, exact_pages))
            return false;
    }
 
    targoffset = hscan->rs_vistuples[hscan->rs_cindex];
    page = BufferGetPage(hscan->rs_cbuf);
    lp = PageGetItemId(page, targoffset);
    Assert(ItemIdIsNormal(lp));
 
    hscan->rs_ctup.t_data = (HeapTupleHeader) PageGetItem(page, lp);
    hscan->rs_ctup.t_len = ItemIdGetLength(lp);
    hscan->rs_ctup.t_tableOid = scan->rs_rd->rd_id;
    ItemPointerSet(&hscan->rs_ctup.t_self, hscan->rs_cblock, targoffset);
 
    pgstat_count_heap_fetch(scan->rs_rd);
 
    /*
     * Set up the result slot to point to this tuple.  Note that the slot
     * acquires a pin on the buffer.
     */
    ExecStoreBufferHeapTuple(&hscan->rs_ctup,
                             slot,
                             hscan->rs_cbuf);
 
    hscan->rs_cindex++;
 
    return true;
}

References Assert, BitmapHeapScanNextBlock(), BufferGetPage(), ExecStoreBufferHeapTuple(), fb(), ItemIdGetLength, ItemIdIsNormal, ItemPointerSet(), PageGetItem(), PageGetItemId(), pgstat_count_heap_fetch, RelationData::rd_id, and TableScanDescData::rs_rd.

heapam_scan_get_blocks_done()

static BlockNumber heapam_scan_get_blocks_done ( HeapScanDesc  hscan )

static

Definition at line 1959 of file heapam_handler.c.

{
    ParallelBlockTableScanDesc bpscan = NULL;
    BlockNumber startblock;
    BlockNumber blocks_done;
 
    if (hscan->rs_base.rs_parallel != NULL)
    {
        bpscan = (ParallelBlockTableScanDesc) hscan->rs_base.rs_parallel;
        startblock = bpscan->phs_startblock;
    }
    else
        startblock = hscan->rs_startblock;
 
    /*
     * Might have wrapped around the end of the relation, if startblock was
     * not zero.
     */
    if (hscan->rs_cblock > startblock)
        blocks_done = hscan->rs_cblock - startblock;
    else
    {
        BlockNumber nblocks;
 
        nblocks = bpscan != NULL ? bpscan->phs_nblocks : hscan->rs_nblocks;
        blocks_done = nblocks - startblock +
            hscan->rs_cblock;
    }
 
    return blocks_done;
}

References fb().

Referenced by heapam_index_build_range_scan().

heapam_scan_sample_next_block()

static bool heapam_scan_sample_next_block ( TableScanDesc  scan, SampleScanState *  scanstate  )

static

Definition at line 2139 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
    TsmRoutine *tsm = scanstate->tsmroutine;
    BlockNumber blockno;
 
    /* return false immediately if relation is empty */
    if (hscan->rs_nblocks == 0)
        return false;
 
    /* release previous scan buffer, if any */
    if (BufferIsValid(hscan->rs_cbuf))
    {
        ReleaseBuffer(hscan->rs_cbuf);
        hscan->rs_cbuf = InvalidBuffer;
    }
 
    if (tsm->NextSampleBlock)
        blockno = tsm->NextSampleBlock(scanstate, hscan->rs_nblocks);
    else
    {
        /* scanning table sequentially */
 
        if (hscan->rs_cblock == InvalidBlockNumber)
        {
            Assert(!hscan->rs_inited);
            blockno = hscan->rs_startblock;
        }
        else
        {
            Assert(hscan->rs_inited);
 
            blockno = hscan->rs_cblock + 1;
 
            if (blockno >= hscan->rs_nblocks)
            {
                /* wrap to beginning of rel, might not have started at 0 */
                blockno = 0;
            }
 
            /*
             * Report our new scan position for synchronization purposes.
             *
             * Note: we do this before checking for end of scan so that the
             * final state of the position hint is back at the start of the
             * rel.  That's not strictly necessary, but otherwise when you run
             * the same query multiple times the starting position would shift
             * a little bit backwards on every invocation, which is confusing.
             * We don't guarantee any specific ordering in general, though.
             */
            if (scan->rs_flags & SO_ALLOW_SYNC)
                ss_report_location(scan->rs_rd, blockno);
 
            if (blockno == hscan->rs_startblock)
            {
                blockno = InvalidBlockNumber;
            }
        }
    }
 
    hscan->rs_cblock = blockno;
 
    if (!BlockNumberIsValid(blockno))
    {
        hscan->rs_inited = false;
        return false;
    }
 
    Assert(hscan->rs_cblock < hscan->rs_nblocks);
 
    /*
     * Be sure to check for interrupts at least once per page.  Checks at
     * higher code levels won't be able to stop a sample scan that encounters
     * many pages' worth of consecutive dead tuples.
     */
    CHECK_FOR_INTERRUPTS();
 
    /* Read page using selected strategy */
    hscan->rs_cbuf = ReadBufferExtended(hscan->rs_base.rs_rd, MAIN_FORKNUM,
                                        blockno, RBM_NORMAL, hscan->rs_strategy);
 
    /* in pagemode, prune the page and determine visible tuple offsets */
    if (hscan->rs_base.rs_flags & SO_ALLOW_PAGEMODE)
        heap_prepare_pagescan(scan);
 
    hscan->rs_inited = true;
    return true;
}

References Assert, BlockNumberIsValid(), BufferIsValid(), CHECK_FOR_INTERRUPTS, fb(), heap_prepare_pagescan(), InvalidBlockNumber, InvalidBuffer, MAIN_FORKNUM, RBM_NORMAL, ReadBufferExtended(), ReleaseBuffer(), TableScanDescData::rs_flags, TableScanDescData::rs_rd, SO_ALLOW_PAGEMODE, SO_ALLOW_SYNC, and ss_report_location().

heapam_scan_sample_next_tuple()

static bool heapam_scan_sample_next_tuple ( TableScanDesc  scan, SampleScanState *  scanstate, TupleTableSlot *  slot  )

static

Definition at line 2229 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
    TsmRoutine *tsm = scanstate->tsmroutine;
    BlockNumber blockno = hscan->rs_cblock;
    bool        pagemode = (scan->rs_flags & SO_ALLOW_PAGEMODE) != 0;
 
    Page        page;
    bool        all_visible;
    OffsetNumber maxoffset;
 
    /*
     * When not using pagemode, we must lock the buffer during tuple
     * visibility checks.
     */
    if (!pagemode)
        LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_SHARE);
 
    page = BufferGetPage(hscan->rs_cbuf);
    all_visible = PageIsAllVisible(page) &&
        !scan->rs_snapshot->takenDuringRecovery;
    maxoffset = PageGetMaxOffsetNumber(page);
 
    for (;;)
    {
        OffsetNumber tupoffset;
 
        CHECK_FOR_INTERRUPTS();
 
        /* Ask the tablesample method which tuples to check on this page. */
        tupoffset = tsm->NextSampleTuple(scanstate,
                                         blockno,
                                         maxoffset);
 
        if (OffsetNumberIsValid(tupoffset))
        {
            ItemId      itemid;
            bool        visible;
            HeapTuple   tuple = &(hscan->rs_ctup);
 
            /* Skip invalid tuple pointers. */
            itemid = PageGetItemId(page, tupoffset);
            if (!ItemIdIsNormal(itemid))
                continue;
 
            tuple->t_data = (HeapTupleHeader) PageGetItem(page, itemid);
            tuple->t_len = ItemIdGetLength(itemid);
            ItemPointerSet(&(tuple->t_self), blockno, tupoffset);
 
 
            if (all_visible)
                visible = true;
            else
                visible = SampleHeapTupleVisible(scan, hscan->rs_cbuf,
                                                 tuple, tupoffset);
 
            /* in pagemode, heap_prepare_pagescan did this for us */
            if (!pagemode)
                HeapCheckForSerializableConflictOut(visible, scan->rs_rd, tuple,
                                                    hscan->rs_cbuf, scan->rs_snapshot);
 
            /* Try next tuple from same page. */
            if (!visible)
                continue;
 
            /* Found visible tuple, return it. */
            if (!pagemode)
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            ExecStoreBufferHeapTuple(tuple, slot, hscan->rs_cbuf);
 
            /* Count successfully-fetched tuples as heap fetches */
            pgstat_count_heap_getnext(scan->rs_rd);
 
            return true;
        }
        else
        {
            /*
             * If we get here, it means we've exhausted the items on this page
             * and it's time to move to the next.
             */
            if (!pagemode)
                LockBuffer(hscan->rs_cbuf, BUFFER_LOCK_UNLOCK);
 
            ExecClearTuple(slot);
            return false;
        }
    }
 
    Assert(0);
}

References Assert, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), CHECK_FOR_INTERRUPTS, ExecClearTuple(), ExecStoreBufferHeapTuple(), fb(), HeapCheckForSerializableConflictOut(), ItemIdGetLength, ItemIdIsNormal, ItemPointerSet(), LockBuffer(), OffsetNumberIsValid, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIsAllVisible(), pgstat_count_heap_getnext, TableScanDescData::rs_flags, TableScanDescData::rs_rd, TableScanDescData::rs_snapshot, SampleHeapTupleVisible(), SO_ALLOW_PAGEMODE, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and SnapshotData::takenDuringRecovery.

heapam_slot_callbacks()

static const TupleTableSlotOps * heapam_slot_callbacks ( Relation  relation )

static

Definition at line 77 of file heapam_handler.c.

{
    return &TTSOpsBufferHeapTuple;
}

References TTSOpsBufferHeapTuple.

heapam_tuple_complete_speculative()

static void heapam_tuple_complete_speculative ( Relation  relation, TupleTableSlot *  slot, uint32  specToken, bool  succeeded  )

static

Definition at line 192 of file heapam_handler.c.

{
    /* adjust the tuple's state accordingly */
    if (succeeded)
        heap_finish_speculative(relation, &slot->tts_tid);
    else
        heap_abort_speculative(relation, &slot->tts_tid);
}

References fb(), heap_abort_speculative(), heap_finish_speculative(), and TupleTableSlot::tts_tid.

heapam_tuple_delete()

static TM_Result heapam_tuple_delete ( Relation  relation, ItemPointer  tid, CommandId  cid, uint32  options, Snapshot  snapshot, Snapshot  crosscheck, bool  wait, TM_FailureData *  tmfd  )

static

Definition at line 203 of file heapam_handler.c.

{
    /*
     * Currently Deleting of index tuples are handled at vacuum, in case if
     * the storage itself is cleaning the dead tuples by itself, it is the
     * time to call the index tuple deletion also.
     */
    return heap_delete(relation, tid, cid, options, crosscheck, wait,
                       tmfd);
}

References fb(), and heap_delete().

heapam_tuple_insert()

static void heapam_tuple_insert ( Relation  relation, TupleTableSlot *  slot, CommandId  cid, uint32  options, BulkInsertState  bistate  )

static

Definition at line 150 of file heapam_handler.c.

{
    bool        shouldFree = true;
    HeapTuple   tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);
 
    /* Update the tuple with table oid */
    slot->tts_tableOid = RelationGetRelid(relation);
    tuple->t_tableOid = slot->tts_tableOid;
 
    /* Perform the insertion, and copy the resulting ItemPointer */
    heap_insert(relation, tuple, cid, options, bistate);
    ItemPointerCopy(&tuple->t_self, &slot->tts_tid);
 
    if (shouldFree)
        pfree(tuple);
}

References ExecFetchSlotHeapTuple(), fb(), heap_insert(), ItemPointerCopy(), pfree(), RelationGetRelid, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleTableSlot::tts_tableOid, and TupleTableSlot::tts_tid.

heapam_tuple_insert_speculative()

static void heapam_tuple_insert_speculative ( Relation  relation, TupleTableSlot *  slot, CommandId  cid, uint32  options, BulkInsertState  bistate, uint32  specToken  )

static

Definition at line 169 of file heapam_handler.c.

{
    bool        shouldFree = true;
    HeapTuple   tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);
 
    /* Update the tuple with table oid */
    slot->tts_tableOid = RelationGetRelid(relation);
    tuple->t_tableOid = slot->tts_tableOid;
 
    HeapTupleHeaderSetSpeculativeToken(tuple->t_data, specToken);
    options |= HEAP_INSERT_SPECULATIVE;
 
    /* Perform the insertion, and copy the resulting ItemPointer */
    heap_insert(relation, tuple, cid, options, bistate);
    ItemPointerCopy(&tuple->t_self, &slot->tts_tid);
 
    if (shouldFree)
        pfree(tuple);
}

References ExecFetchSlotHeapTuple(), fb(), heap_insert(), HEAP_INSERT_SPECULATIVE, HeapTupleHeaderSetSpeculativeToken(), ItemPointerCopy(), pfree(), RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, TupleTableSlot::tts_tableOid, and TupleTableSlot::tts_tid.

heapam_tuple_lock()

static TM_Result heapam_tuple_lock ( Relation  relation, ItemPointer  tid, Snapshot  snapshot, TupleTableSlot *  slot, CommandId  cid, LockTupleMode  mode, LockWaitPolicy  wait_policy, uint8  flags, TM_FailureData *  tmfd  )

static

Definition at line 265 of file heapam_handler.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    TM_Result   result;
    Buffer      buffer;
    HeapTuple   tuple = &bslot->base.tupdata;
    bool        follow_updates;
 
    follow_updates = (flags & TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS) != 0;
    tmfd->traversed = false;
 
    Assert(TTS_IS_BUFFERTUPLE(slot));
 
tuple_lock_retry:
    tuple->t_self = *tid;
    result = heap_lock_tuple(relation, tuple, cid, mode, wait_policy,
                             follow_updates, &buffer, tmfd);
 
    if (result == TM_Updated &&
        (flags & TUPLE_LOCK_FLAG_FIND_LAST_VERSION))
    {
        /* Should not encounter speculative tuple on recheck */
        Assert(!HeapTupleHeaderIsSpeculative(tuple->t_data));
 
        ReleaseBuffer(buffer);
 
        if (!ItemPointerEquals(&tmfd->ctid, &tuple->t_self))
        {
            SnapshotData SnapshotDirty;
            TransactionId priorXmax;
 
            /* it was updated, so look at the updated version */
            *tid = tmfd->ctid;
            /* updated row should have xmin matching this xmax */
            priorXmax = tmfd->xmax;
 
            /* signal that a tuple later in the chain is getting locked */
            tmfd->traversed = true;
 
            /*
             * fetch target tuple
             *
             * Loop here to deal with updated or busy tuples
             */
            InitDirtySnapshot(SnapshotDirty);
            for (;;)
            {
                if (ItemPointerIndicatesMovedPartitions(tid))
                    ereport(ERROR,
                            (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                             errmsg("tuple to be locked was already moved to another partition due to concurrent update")));
 
                tuple->t_self = *tid;
                if (heap_fetch(relation, &SnapshotDirty, tuple, &buffer, true))
                {
                    /*
                     * If xmin isn't what we're expecting, the slot must have
                     * been recycled and reused for an unrelated tuple.  This
                     * implies that the latest version of the row was deleted,
                     * so we need do nothing.  (Should be safe to examine xmin
                     * without getting buffer's content lock.  We assume
                     * reading a TransactionId to be atomic, and Xmin never
                     * changes in an existing tuple, except to invalid or
                     * frozen, and neither of those can match priorXmax.)
                     */
                    if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
                                             priorXmax))
                    {
                        ReleaseBuffer(buffer);
                        return TM_Deleted;
                    }
 
                    /* otherwise xmin should not be dirty... */
                    if (TransactionIdIsValid(SnapshotDirty.xmin))
                        ereport(ERROR,
                                (errcode(ERRCODE_DATA_CORRUPTED),
                                 errmsg_internal("t_xmin %u is uncommitted in tuple (%u,%u) to be updated in table \"%s\"",
                                                 SnapshotDirty.xmin,
                                                 ItemPointerGetBlockNumber(&tuple->t_self),
                                                 ItemPointerGetOffsetNumber(&tuple->t_self),
                                                 RelationGetRelationName(relation))));
 
                    /*
                     * If tuple is being updated by other transaction then we
                     * have to wait for its commit/abort, or die trying.
                     */
                    if (TransactionIdIsValid(SnapshotDirty.xmax))
                    {
                        ReleaseBuffer(buffer);
                        switch (wait_policy)
                        {
                            case LockWaitBlock:
                                XactLockTableWait(SnapshotDirty.xmax,
                                                  relation, &tuple->t_self,
                                                  XLTW_FetchUpdated);
                                break;
                            case LockWaitSkip:
                                if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, false))
                                    /* skip instead of waiting */
                                    return TM_WouldBlock;
                                break;
                            case LockWaitError:
                                if (!ConditionalXactLockTableWait(SnapshotDirty.xmax, log_lock_failures))
                                    ereport(ERROR,
                                            (errcode(ERRCODE_LOCK_NOT_AVAILABLE),
                                             errmsg("could not obtain lock on row in relation \"%s\"",
                                                    RelationGetRelationName(relation))));
                                break;
                        }
                        continue;   /* loop back to repeat heap_fetch */
                    }
 
                    /*
                     * If tuple was inserted by our own transaction, we have
                     * to check cmin against cid: cmin >= current CID means
                     * our command cannot see the tuple, so we should ignore
                     * it. Otherwise heap_lock_tuple() will throw an error,
                     * and so would any later attempt to update or delete the
                     * tuple.  (We need not check cmax because
                     * HeapTupleSatisfiesDirty will consider a tuple deleted
                     * by our transaction dead, regardless of cmax.)  We just
                     * checked that priorXmax == xmin, so we can test that
                     * variable instead of doing HeapTupleHeaderGetXmin again.
                     */
                    if (TransactionIdIsCurrentTransactionId(priorXmax) &&
                        HeapTupleHeaderGetCmin(tuple->t_data) >= cid)
                    {
                        tmfd->xmax = priorXmax;
 
                        /*
                         * Cmin is the problematic value, so store that. See
                         * above.
                         */
                        tmfd->cmax = HeapTupleHeaderGetCmin(tuple->t_data);
                        ReleaseBuffer(buffer);
                        return TM_SelfModified;
                    }
 
                    /*
                     * This is a live tuple, so try to lock it again.
                     */
                    ReleaseBuffer(buffer);
                    goto tuple_lock_retry;
                }
 
                /*
                 * If the referenced slot was actually empty, the latest
                 * version of the row must have been deleted, so we need do
                 * nothing.
                 */
                if (tuple->t_data == NULL)
                {
                    Assert(!BufferIsValid(buffer));
                    return TM_Deleted;
                }
 
                /*
                 * As above, if xmin isn't what we're expecting, do nothing.
                 */
                if (!TransactionIdEquals(HeapTupleHeaderGetXmin(tuple->t_data),
                                         priorXmax))
                {
                    ReleaseBuffer(buffer);
                    return TM_Deleted;
                }
 
                /*
                 * If we get here, the tuple was found but failed
                 * SnapshotDirty. Assuming the xmin is either a committed xact
                 * or our own xact (as it certainly should be if we're trying
                 * to modify the tuple), this must mean that the row was
                 * updated or deleted by either a committed xact or our own
                 * xact.  If it was deleted, we can ignore it; if it was
                 * updated then chain up to the next version and repeat the
                 * whole process.
                 *
                 * As above, it should be safe to examine xmax and t_ctid
                 * without the buffer content lock, because they can't be
                 * changing.  We'd better hold a buffer pin though.
                 */
                if (ItemPointerEquals(&tuple->t_self, &tuple->t_data->t_ctid))
                {
                    /* deleted, so forget about it */
                    ReleaseBuffer(buffer);
                    return TM_Deleted;
                }
 
                /* updated, so look at the updated row */
                *tid = tuple->t_data->t_ctid;
                /* updated row should have xmin matching this xmax */
                priorXmax = HeapTupleHeaderGetUpdateXid(tuple->t_data);
                ReleaseBuffer(buffer);
                /* loop back to fetch next in chain */
            }
        }
        else
        {
            /* tuple was deleted, so give up */
            return TM_Deleted;
        }
    }
 
    slot->tts_tableOid = RelationGetRelid(relation);
    tuple->t_tableOid = slot->tts_tableOid;
 
    /* store in slot, transferring existing pin */
    ExecStorePinnedBufferHeapTuple(tuple, slot, buffer);
 
    return result;
}

References Assert, BufferIsValid(), TM_FailureData::cmax, ConditionalXactLockTableWait(), TM_FailureData::ctid, ereport, errcode(), ERRCODE_DATA_CORRUPTED, ERRCODE_T_R_SERIALIZATION_FAILURE, errmsg, errmsg_internal(), ERROR, ExecStorePinnedBufferHeapTuple(), fb(), heap_fetch(), heap_lock_tuple(), HeapTupleHeaderGetCmin(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderGetXmin(), HeapTupleHeaderIsSpeculative(), InitDirtySnapshot, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIndicatesMovedPartitions(), LockWaitBlock, LockWaitError, LockWaitSkip, log_lock_failures, mode, RelationGetRelationName, RelationGetRelid, ReleaseBuffer(), result, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_Deleted, TM_SelfModified, TM_Updated, TM_WouldBlock, TransactionIdEquals, TransactionIdIsCurrentTransactionId(), TransactionIdIsValid, TM_FailureData::traversed, TTS_IS_BUFFERTUPLE, TupleTableSlot::tts_tableOid, TUPLE_LOCK_FLAG_FIND_LAST_VERSION, TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS, XactLockTableWait(), XLTW_FetchUpdated, and TM_FailureData::xmax.

heapam_tuple_satisfies_snapshot()

static bool heapam_tuple_satisfies_snapshot ( Relation  rel, TupleTableSlot *  slot, Snapshot  snapshot  )

static

Definition at line 122 of file heapam_handler.c.

{
    BufferHeapTupleTableSlot *bslot = (BufferHeapTupleTableSlot *) slot;
    bool        res;
 
    Assert(TTS_IS_BUFFERTUPLE(slot));
    Assert(BufferIsValid(bslot->buffer));
 
    /*
     * We need buffer pin and lock to call HeapTupleSatisfiesVisibility.
     * Caller should be holding pin, but not lock.
     */
    LockBuffer(bslot->buffer, BUFFER_LOCK_SHARE);
    res = HeapTupleSatisfiesVisibility(bslot->base.tuple, snapshot,
                                       bslot->buffer);
    LockBuffer(bslot->buffer, BUFFER_LOCK_UNLOCK);
 
    return res;
}

References Assert, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferIsValid(), fb(), HeapTupleSatisfiesVisibility(), LockBuffer(), and TTS_IS_BUFFERTUPLE.

heapam_tuple_tid_valid()

static bool heapam_tuple_tid_valid ( TableScanDesc  scan, ItemPointer  tid  )

static

Definition at line 113 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
 
    return ItemPointerIsValid(tid) &&
        ItemPointerGetBlockNumber(tid) < hscan->rs_nblocks;
}

References fb(), ItemPointerGetBlockNumber(), and ItemPointerIsValid().

heapam_tuple_update()

static TM_Result heapam_tuple_update ( Relation  relation, ItemPointer  otid, TupleTableSlot *  slot, CommandId  cid, uint32  options, Snapshot  snapshot, Snapshot  crosscheck, bool  wait, TM_FailureData *  tmfd, LockTupleMode *  lockmode, TU_UpdateIndexes *  update_indexes  )

static

Definition at line 218 of file heapam_handler.c.

{
    bool        shouldFree = true;
    HeapTuple   tuple = ExecFetchSlotHeapTuple(slot, true, &shouldFree);
    TM_Result   result;
 
    /* Update the tuple with table oid */
    slot->tts_tableOid = RelationGetRelid(relation);
    tuple->t_tableOid = slot->tts_tableOid;
 
    result = heap_update(relation, otid, tuple, cid, options,
                         crosscheck, wait,
                         tmfd, lockmode, update_indexes);
    ItemPointerCopy(&tuple->t_self, &slot->tts_tid);
 
    /*
     * Decide whether new index entries are needed for the tuple
     *
     * Note: heap_update returns the tid (location) of the new tuple in the
     * t_self field.
     *
     * If the update is not HOT, we must update all indexes. If the update is
     * HOT, it could be that we updated summarized columns, so we either
     * update only summarized indexes, or none at all.
     */
    if (result != TM_Ok)
    {
        Assert(*update_indexes == TU_None);
        *update_indexes = TU_None;
    }
    else if (!HeapTupleIsHeapOnly(tuple))
        Assert(*update_indexes == TU_All);
    else
        Assert((*update_indexes == TU_Summarizing) ||
               (*update_indexes == TU_None));
 
    if (shouldFree)
        pfree(tuple);
 
    return result;
}

References Assert, ExecFetchSlotHeapTuple(), fb(), heap_update(), HeapTupleIsHeapOnly(), ItemPointerCopy(), pfree(), RelationGetRelid, result, HeapTupleData::t_self, HeapTupleData::t_tableOid, TM_Ok, TupleTableSlot::tts_tableOid, TupleTableSlot::tts_tid, TU_All, TU_None, and TU_Summarizing.

reform_and_rewrite_tuple()

static void reform_and_rewrite_tuple ( HeapTuple  tuple, Relation  OldHeap, Relation  NewHeap, Datum *  values, bool *  isnull, RewriteState  rwstate  )

static

Definition at line 2346 of file heapam_handler.c.

{
    HeapTuple   newtuple;
 
    newtuple = reform_tuple(tuple, OldHeap, NewHeap, values, isnull);
 
    /* The heap rewrite module does the rest */
    rewrite_heap_tuple(rwstate, tuple, newtuple);
 
    heap_freetuple(newtuple);
}

References fb(), heap_freetuple(), reform_tuple(), rewrite_heap_tuple(), and values.

Referenced by heapam_relation_copy_for_cluster().

reform_tuple()

static HeapTuple reform_tuple ( HeapTuple  tuple, Relation  OldHeap, Relation  NewHeap, Datum *  values, bool *  isnull  )

static

Definition at line 2401 of file heapam_handler.c.

{
    TupleDesc   oldTupDesc = RelationGetDescr(OldHeap);
    TupleDesc   newTupDesc = RelationGetDescr(NewHeap);
    bool        needs_reform = false;
 
    /*
     * A short tuple might require values from attmissing val, so activate the
     * coding unconditionally in that case.  The value might legitimally be
     * NULL otherwise, so this is slightly wasteful, but it probably beats
     * having to test each attribute for presence of attmissingval each time.
     */
    if (HeapTupleHeaderGetNatts(tuple->t_data) < newTupDesc->natts)
        needs_reform = true;
 
    /*
     * If the column has been dropped but a value is still present, we can
     * optimize storage now by getting rid of it.
     */
    if (!needs_reform)
    {
        for (int i = 0; i < newTupDesc->natts; i++)
        {
            if (TupleDescCompactAttr(newTupDesc, i)->attisdropped &&
                !heap_attisnull(tuple, i + 1, newTupDesc))
            {
                needs_reform = true;
                break;
            }
        }
    }
 
    /* Skip work if no changes are needed */
    if (!needs_reform)
        return heap_copytuple(tuple);
 
    heap_deform_tuple(tuple, oldTupDesc, values, isnull);
 
    for (int i = 0; i < newTupDesc->natts; i++)
    {
        if (TupleDescCompactAttr(newTupDesc, i)->attisdropped)
            isnull[i] = true;
    }
 
    return heap_form_tuple(newTupDesc, values, isnull);
}

References fb(), heap_attisnull(), heap_copytuple(), heap_deform_tuple(), heap_form_tuple(), HeapTupleHeaderGetNatts, i, RelationGetDescr, HeapTupleData::t_data, TupleDescCompactAttr(), and values.

Referenced by heap_insert_for_repack(), and reform_and_rewrite_tuple().

SampleHeapTupleVisible()

static bool SampleHeapTupleVisible ( TableScanDesc  scan, Buffer  buffer, HeapTuple  tuple, OffsetNumber  tupoffset  )

static

Definition at line 2453 of file heapam_handler.c.

{
    HeapScanDesc hscan = (HeapScanDesc) scan;
 
    if (scan->rs_flags & SO_ALLOW_PAGEMODE)
    {
        uint32      start = 0,
                    end = hscan->rs_ntuples;
 
        /*
         * In pageatatime mode, heap_prepare_pagescan() already did visibility
         * checks, so just look at the info it left in rs_vistuples[].
         *
         * We use a binary search over the known-sorted array.  Note: we could
         * save some effort if we insisted that NextSampleTuple select tuples
         * in increasing order, but it's not clear that there would be enough
         * gain to justify the restriction.
         */
        while (start < end)
        {
            uint32      mid = start + (end - start) / 2;
            OffsetNumber curoffset = hscan->rs_vistuples[mid];
 
            if (tupoffset == curoffset)
                return true;
            else if (tupoffset < curoffset)
                end = mid;
            else
                start = mid + 1;
        }
 
        return false;
    }
    else
    {
        /* Otherwise, we have to check the tuple individually. */
        return HeapTupleSatisfiesVisibility(tuple, scan->rs_snapshot,
                                            buffer);
    }
}

References fb(), HeapTupleSatisfiesVisibility(), TableScanDescData::rs_flags, TableScanDescData::rs_snapshot, SO_ALLOW_PAGEMODE, and start.

Referenced by heapam_scan_sample_next_tuple().

Variable Documentation

heapam_methods

const TableAmRoutine heapam_methods

static

Definition at line 2659 of file heapam_handler.c.

                                             {
    .type = T_TableAmRoutine,
 
    .slot_callbacks = heapam_slot_callbacks,
 
    .scan_begin = heap_beginscan,
    .scan_end = heap_endscan,
    .scan_rescan = heap_rescan,
    .scan_getnextslot = heap_getnextslot,
 
    .scan_set_tidrange = heap_set_tidrange,
    .scan_getnextslot_tidrange = heap_getnextslot_tidrange,
 
    .parallelscan_estimate = table_block_parallelscan_estimate,
    .parallelscan_initialize = table_block_parallelscan_initialize,
    .parallelscan_reinitialize = table_block_parallelscan_reinitialize,
 
    .index_fetch_begin = heapam_index_fetch_begin,
    .index_fetch_reset = heapam_index_fetch_reset,
    .index_fetch_end = heapam_index_fetch_end,
    .index_fetch_tuple = heapam_index_fetch_tuple,
 
    .tuple_insert = heapam_tuple_insert,
    .tuple_insert_speculative = heapam_tuple_insert_speculative,
    .tuple_complete_speculative = heapam_tuple_complete_speculative,
    .multi_insert = heap_multi_insert,
    .tuple_delete = heapam_tuple_delete,
    .tuple_update = heapam_tuple_update,
    .tuple_lock = heapam_tuple_lock,
 
    .tuple_fetch_row_version = heapam_fetch_row_version,
    .tuple_get_latest_tid = heap_get_latest_tid,
    .tuple_tid_valid = heapam_tuple_tid_valid,
    .tuple_satisfies_snapshot = heapam_tuple_satisfies_snapshot,
    .index_delete_tuples = heap_index_delete_tuples,
 
    .relation_set_new_filelocator = heapam_relation_set_new_filelocator,
    .relation_nontransactional_truncate = heapam_relation_nontransactional_truncate,
    .relation_copy_data = heapam_relation_copy_data,
    .relation_copy_for_cluster = heapam_relation_copy_for_cluster,
    .relation_vacuum = heap_vacuum_rel,
    .scan_analyze_next_block = heapam_scan_analyze_next_block,
    .scan_analyze_next_tuple = heapam_scan_analyze_next_tuple,
    .index_build_range_scan = heapam_index_build_range_scan,
    .index_validate_scan = heapam_index_validate_scan,
 
    .relation_size = table_block_relation_size,
    .relation_needs_toast_table = heapam_relation_needs_toast_table,
    .relation_toast_am = heapam_relation_toast_am,
    .relation_fetch_toast_slice = heap_fetch_toast_slice,
 
    .relation_estimate_size = heapam_estimate_rel_size,
 
    .scan_bitmap_next_tuple = heapam_scan_bitmap_next_tuple,
    .scan_sample_next_block = heapam_scan_sample_next_block,
    .scan_sample_next_tuple = heapam_scan_sample_next_tuple
};

Referenced by GetHeapamTableAmRoutine(), and heap_tableam_handler().