tableam.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/syncscan.h"
#include "access/tableam.h"
#include "access/xact.h"
#include "optimizer/optimizer.h"
#include "optimizer/plancat.h"
#include "port/pg_bitutils.h"
#include "storage/bufmgr.h"
#include "storage/shmem.h"
#include "storage/smgr.h"

Include dependency graph for tableam.c:

Go to the source code of this file.

Macros
#define	PARALLEL_SEQSCAN_NCHUNKS   2048
#define	PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS   64
#define	PARALLEL_SEQSCAN_MAX_CHUNK_SIZE   8192

Functions
const TupleTableSlotOps *	table_slot_callbacks (Relation relation)
TupleTableSlot *	table_slot_create (Relation relation, List **reglist)
TableScanDesc	table_beginscan_catalog (Relation relation, int nkeys, ScanKeyData *key)
Size	table_parallelscan_estimate (Relation rel, Snapshot snapshot)
void	table_parallelscan_initialize (Relation rel, ParallelTableScanDesc pscan, Snapshot snapshot)
TableScanDesc	table_beginscan_parallel (Relation relation, ParallelTableScanDesc pscan)
TableScanDesc	table_beginscan_parallel_tidrange (Relation relation, ParallelTableScanDesc pscan)
bool	table_index_fetch_tuple_check (Relation rel, ItemPointer tid, Snapshot snapshot, bool *all_dead)
void	table_tuple_get_latest_tid (TableScanDesc scan, ItemPointer tid)
void	simple_table_tuple_insert (Relation rel, TupleTableSlot *slot)
void	simple_table_tuple_delete (Relation rel, ItemPointer tid, Snapshot snapshot)
void	simple_table_tuple_update (Relation rel, ItemPointer otid, TupleTableSlot *slot, Snapshot snapshot, TU_UpdateIndexes *update_indexes)
Size	table_block_parallelscan_estimate (Relation rel)
Size	table_block_parallelscan_initialize (Relation rel, ParallelTableScanDesc pscan)
void	table_block_parallelscan_reinitialize (Relation rel, ParallelTableScanDesc pscan)
void	table_block_parallelscan_startblock_init (Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan, BlockNumber startblock, BlockNumber numblocks)
BlockNumber	table_block_parallelscan_nextpage (Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan)
uint64	table_block_relation_size (Relation rel, ForkNumber forkNumber)
void	table_block_relation_estimate_size (Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac, Size overhead_bytes_per_tuple, Size usable_bytes_per_page)

Variables
char *	default_table_access_method = DEFAULT_TABLE_ACCESS_METHOD
bool	synchronize_seqscans = true

Macro Definition Documentation

PARALLEL_SEQSCAN_MAX_CHUNK_SIZE

#define PARALLEL_SEQSCAN_MAX_CHUNK_SIZE   8192

Definition at line 46 of file tableam.c.

PARALLEL_SEQSCAN_NCHUNKS

#define PARALLEL_SEQSCAN_NCHUNKS   2048

Definition at line 42 of file tableam.c.

PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS

#define PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS   64

Definition at line 44 of file tableam.c.

Function Documentation

simple_table_tuple_delete()

void simple_table_tuple_delete	(	Relation	rel,
		ItemPointer	tid,
		Snapshot	snapshot
	)

Definition at line 314 of file tableam.c.

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

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

Referenced by ExecSimpleRelationDelete().

simple_table_tuple_insert()

void simple_table_tuple_insert	(	Relation	rel,
		TupleTableSlot *	slot
	)

Definition at line 300 of file tableam.c.

{
    table_tuple_insert(rel, slot, GetCurrentCommandId(true), 0, NULL);
}

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

Referenced by ExecSimpleRelationInsert().

simple_table_tuple_update()

void simple_table_tuple_update	(	Relation	rel,
		ItemPointer	otid,
		TupleTableSlot *	slot,
		Snapshot	snapshot,
		TU_UpdateIndexes *	update_indexes
	)

Definition at line 359 of file tableam.c.

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

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

Referenced by ExecSimpleRelationUpdate().

table_beginscan_catalog()

TableScanDesc table_beginscan_catalog	(	Relation	relation,
		int	nkeys,
		ScanKeyData *	key
	)

Definition at line 113 of file tableam.c.

{
    uint32      flags = SO_TYPE_SEQSCAN |
        SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE | SO_TEMP_SNAPSHOT;
    Oid         relid = RelationGetRelid(relation);
    Snapshot    snapshot = RegisterSnapshot(GetCatalogSnapshot(relid));
 
    return table_beginscan_common(relation, snapshot, nkeys, key,
                                  NULL, flags);
}

References fb(), GetCatalogSnapshot(), RegisterSnapshot(), RelationGetRelid, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, SO_TEMP_SNAPSHOT, SO_TYPE_SEQSCAN, and table_beginscan_common().

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

table_beginscan_parallel()

TableScanDesc table_beginscan_parallel	(	Relation	relation,
		ParallelTableScanDesc	pscan
	)

Definition at line 166 of file tableam.c.

{
    Snapshot    snapshot;
    uint32      flags = SO_TYPE_SEQSCAN |
        SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE;
 
    Assert(RelFileLocatorEquals(relation->rd_locator, pscan->phs_locator));
 
    if (!pscan->phs_snapshot_any)
    {
        /* Snapshot was serialized -- restore it */
        snapshot = RestoreSnapshot((char *) pscan + pscan->phs_snapshot_off);
        RegisterSnapshot(snapshot);
        flags |= SO_TEMP_SNAPSHOT;
    }
    else
    {
        /* SnapshotAny passed by caller (not serialized) */
        snapshot = SnapshotAny;
    }
 
    return table_beginscan_common(relation, snapshot, 0, NULL,
                                  pscan, flags);
}

References Assert, fb(), RelationData::rd_locator, RegisterSnapshot(), RelFileLocatorEquals, RestoreSnapshot(), SnapshotAny, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, SO_TEMP_SNAPSHOT, SO_TYPE_SEQSCAN, and table_beginscan_common().

Referenced by _brin_parallel_scan_and_build(), _bt_parallel_scan_and_sort(), _gin_parallel_scan_and_build(), ExecSeqScanInitializeDSM(), and ExecSeqScanInitializeWorker().

table_beginscan_parallel_tidrange()

TableScanDesc table_beginscan_parallel_tidrange	(	Relation	relation,
		ParallelTableScanDesc	pscan
	)

Definition at line 192 of file tableam.c.

{
    Snapshot    snapshot;
    uint32      flags = SO_TYPE_TIDRANGESCAN | SO_ALLOW_PAGEMODE;
    TableScanDesc sscan;
 
    Assert(RelFileLocatorEquals(relation->rd_locator, pscan->phs_locator));
 
    /* disable syncscan in parallel tid range scan. */
    pscan->phs_syncscan = false;
 
    if (!pscan->phs_snapshot_any)
    {
        /* Snapshot was serialized -- restore it */
        snapshot = RestoreSnapshot((char *) pscan + pscan->phs_snapshot_off);
        RegisterSnapshot(snapshot);
        flags |= SO_TEMP_SNAPSHOT;
    }
    else
    {
        /* SnapshotAny passed by caller (not serialized) */
        snapshot = SnapshotAny;
    }
 
    sscan = table_beginscan_common(relation, snapshot, 0, NULL,
                                   pscan, flags);
    return sscan;
}

References Assert, fb(), RelationData::rd_locator, RegisterSnapshot(), RelFileLocatorEquals, RestoreSnapshot(), SnapshotAny, SO_ALLOW_PAGEMODE, SO_TEMP_SNAPSHOT, SO_TYPE_TIDRANGESCAN, and table_beginscan_common().

Referenced by ExecTidRangeScanInitializeDSM(), and ExecTidRangeScanInitializeWorker().

table_block_parallelscan_estimate()

Size table_block_parallelscan_estimate

(

Relation

rel

)

Definition at line 406 of file tableam.c.

{
    return sizeof(ParallelBlockTableScanDescData);
}

table_block_parallelscan_initialize()

Size table_block_parallelscan_initialize	(	Relation	rel,
		ParallelTableScanDesc	pscan
	)

Definition at line 412 of file tableam.c.

{
    ParallelBlockTableScanDesc bpscan = (ParallelBlockTableScanDesc) pscan;
 
    bpscan->base.phs_locator = rel->rd_locator;
    bpscan->phs_nblocks = RelationGetNumberOfBlocks(rel);
    /* compare phs_syncscan initialization to similar logic in initscan */
    bpscan->base.phs_syncscan = synchronize_seqscans &&
        !RelationUsesLocalBuffers(rel) &&
        bpscan->phs_nblocks > NBuffers / 4;
    SpinLockInit(&bpscan->phs_mutex);
    bpscan->phs_startblock = InvalidBlockNumber;
    bpscan->phs_numblock = InvalidBlockNumber;
    pg_atomic_init_u64(&bpscan->phs_nallocated, 0);
 
    return sizeof(ParallelBlockTableScanDescData);
}

References ParallelBlockTableScanDescData::base, fb(), InvalidBlockNumber, NBuffers, pg_atomic_init_u64(), ParallelTableScanDescData::phs_locator, RelationData::rd_locator, RelationGetNumberOfBlocks, RelationUsesLocalBuffers, SpinLockInit, and synchronize_seqscans.

table_block_parallelscan_nextpage()

BlockNumber table_block_parallelscan_nextpage	(	Relation	rel,
		ParallelBlockTableScanWorker	pbscanwork,
		ParallelBlockTableScanDesc	pbscan
	)

Definition at line 546 of file tableam.c.

{
    BlockNumber scan_nblocks;
    BlockNumber page;
    uint64      nallocated;
 
    /*
     * The logic below allocates block numbers out to parallel workers in a
     * way that each worker will receive a set of consecutive block numbers to
     * scan.  Earlier versions of this would allocate the next highest block
     * number to the next worker to call this function.  This would generally
     * result in workers never receiving consecutive block numbers.  Some
     * operating systems would not detect the sequential I/O pattern due to
     * each backend being a different process which could result in poor
     * performance due to inefficient or no readahead.  To work around this
     * issue, we now allocate a range of block numbers for each worker and
     * when they come back for another block, we give them the next one in
     * that range until the range is complete.  When the worker completes the
     * range of blocks we then allocate another range for it and return the
     * first block number from that range.
     *
     * Here we name these ranges of blocks "chunks".  The initial size of
     * these chunks is determined in table_block_parallelscan_startblock_init
     * based on the number of blocks to scan.  Towards the end of the scan, we
     * start making reductions in the size of the chunks in order to attempt
     * to divide the remaining work over all the workers as evenly as
     * possible.
     *
     * Here pbscanwork is local worker memory.  phsw_chunk_remaining tracks
     * the number of blocks remaining in the chunk.  When that reaches 0 then
     * we must allocate a new chunk for the worker.
     *
     * phs_nallocated tracks how many blocks have been allocated to workers
     * already.  When phs_nallocated >= rs_nblocks, all blocks have been
     * allocated.
     *
     * Because we use an atomic fetch-and-add to fetch the current value, the
     * phs_nallocated counter will exceed rs_nblocks, because workers will
     * still increment the value, when they try to allocate the next block but
     * all blocks have been allocated already. The counter must be 64 bits
     * wide because of that, to avoid wrapping around when scan_nblocks is
     * close to 2^32.
     *
     * The actual block to return is calculated by adding the counter to the
     * starting block number, modulo phs_nblocks.
     */
 
    /* First, figure out how many blocks we're planning on scanning */
    if (pbscan->phs_numblock == InvalidBlockNumber)
        scan_nblocks = pbscan->phs_nblocks;
    else
        scan_nblocks = pbscan->phs_numblock;
 
    /*
     * Now check if we have any remaining blocks in a previous chunk for this
     * worker.  We must consume all of the blocks from that before we allocate
     * a new chunk to the worker.
     */
    if (pbscanwork->phsw_chunk_remaining > 0)
    {
        /*
         * Give them the next block in the range and update the remaining
         * number of blocks.
         */
        nallocated = ++pbscanwork->phsw_nallocated;
        pbscanwork->phsw_chunk_remaining--;
    }
    else
    {
        /*
         * When we've only got PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS chunks
         * remaining in the scan, we half the chunk size.  Since we reduce the
         * chunk size here, we'll hit this again after doing
         * PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS at the new size.  After a few
         * iterations of this, we'll end up doing the last few blocks with the
         * chunk size set to 1.
         */
        if (pbscanwork->phsw_chunk_size > 1 &&
            pbscanwork->phsw_nallocated > scan_nblocks -
            (pbscanwork->phsw_chunk_size * PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS))
            pbscanwork->phsw_chunk_size >>= 1;
 
        nallocated = pbscanwork->phsw_nallocated =
            pg_atomic_fetch_add_u64(&pbscan->phs_nallocated,
                                    pbscanwork->phsw_chunk_size);
 
        /*
         * Set the remaining number of blocks in this chunk so that subsequent
         * calls from this worker continue on with this chunk until it's done.
         */
        pbscanwork->phsw_chunk_remaining = pbscanwork->phsw_chunk_size - 1;
    }
 
    /* Check if we've run out of blocks to scan */
    if (nallocated >= scan_nblocks)
        page = InvalidBlockNumber;  /* all blocks have been allocated */
    else
        page = (nallocated + pbscan->phs_startblock) % pbscan->phs_nblocks;
 
    /*
     * Report scan location.  Normally, we report the current page number.
     * When we reach the end of the scan, though, we report the starting page,
     * not the ending page, just so the starting positions for later scans
     * doesn't slew backwards.  We only report the position at the end of the
     * scan once, though: subsequent callers will report nothing.
     */
    if (pbscan->base.phs_syncscan)
    {
        if (page != InvalidBlockNumber)
            ss_report_location(rel, page);
        else if (nallocated == pbscan->phs_nblocks)
            ss_report_location(rel, pbscan->phs_startblock);
    }
 
    return page;
}

References fb(), InvalidBlockNumber, PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS, pg_atomic_fetch_add_u64(), and ss_report_location().

Referenced by heap_scan_stream_read_next_parallel().

table_block_parallelscan_reinitialize()

void table_block_parallelscan_reinitialize	(	Relation	rel,
		ParallelTableScanDesc	pscan
	)

Definition at line 431 of file tableam.c.

{
    ParallelBlockTableScanDesc bpscan = (ParallelBlockTableScanDesc) pscan;
 
    pg_atomic_write_u64(&bpscan->phs_nallocated, 0);
}

References fb(), and pg_atomic_write_u64().

table_block_parallelscan_startblock_init()

void table_block_parallelscan_startblock_init	(	Relation	rel,
		ParallelBlockTableScanWorker	pbscanwork,
		ParallelBlockTableScanDesc	pbscan,
		BlockNumber	startblock,
		BlockNumber	numblocks
	)

Definition at line 451 of file tableam.c.

{
    StaticAssertDecl(MaxBlockNumber <= 0xFFFFFFFE,
                     "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
 
    BlockNumber sync_startpage = InvalidBlockNumber;
    BlockNumber scan_nblocks;
 
    /* Reset the state we use for controlling allocation size. */
    memset(pbscanwork, 0, sizeof(*pbscanwork));
 
retry:
    /* Grab the spinlock. */
    SpinLockAcquire(&pbscan->phs_mutex);
 
    /*
     * When the caller specified a limit on the number of blocks to scan, set
     * that in the ParallelBlockTableScanDesc, if it's not been done by
     * another worker already.
     */
    if (numblocks != InvalidBlockNumber &&
        pbscan->phs_numblock == InvalidBlockNumber)
    {
        pbscan->phs_numblock = numblocks;
    }
 
    /*
     * If the scan's phs_startblock has not yet been initialized, we must do
     * so now.  If a startblock was specified, start there, otherwise if this
     * is not a synchronized scan, we just start at block 0, but if it is a
     * synchronized scan, we must get the starting position from the
     * synchronized scan machinery.  We can't hold the spinlock while doing
     * that, though, so release the spinlock, get the information we need, and
     * retry.  If nobody else has initialized the scan in the meantime, we'll
     * fill in the value we fetched on the second time through.
     */
    if (pbscan->phs_startblock == InvalidBlockNumber)
    {
        if (startblock != InvalidBlockNumber)
            pbscan->phs_startblock = startblock;
        else if (!pbscan->base.phs_syncscan)
            pbscan->phs_startblock = 0;
        else if (sync_startpage != InvalidBlockNumber)
            pbscan->phs_startblock = sync_startpage;
        else
        {
            SpinLockRelease(&pbscan->phs_mutex);
            sync_startpage = ss_get_location(rel, pbscan->phs_nblocks);
            goto retry;
        }
    }
    SpinLockRelease(&pbscan->phs_mutex);
 
    /*
     * Figure out how many blocks we're going to scan; either all of them, or
     * just phs_numblock's worth, if a limit has been imposed.
     */
    if (pbscan->phs_numblock == InvalidBlockNumber)
        scan_nblocks = pbscan->phs_nblocks;
    else
        scan_nblocks = pbscan->phs_numblock;
 
    /*
     * We determine the chunk size based on scan_nblocks.  First we split
     * scan_nblocks into PARALLEL_SEQSCAN_NCHUNKS chunks then we calculate the
     * next highest power of 2 number of the result.  This means we split the
     * blocks we're scanning into somewhere between PARALLEL_SEQSCAN_NCHUNKS
     * and PARALLEL_SEQSCAN_NCHUNKS / 2 chunks.
     */
    pbscanwork->phsw_chunk_size = pg_nextpower2_32(Max(scan_nblocks /
                                                       PARALLEL_SEQSCAN_NCHUNKS, 1));
 
    /*
     * Ensure we don't go over the maximum chunk size with larger tables. This
     * means we may get much more than PARALLEL_SEQSCAN_NCHUNKS for larger
     * tables.  Too large a chunk size has been shown to be detrimental to
     * sequential scan performance.
     */
    pbscanwork->phsw_chunk_size = Min(pbscanwork->phsw_chunk_size,
                                      PARALLEL_SEQSCAN_MAX_CHUNK_SIZE);
}

References fb(), InvalidBlockNumber, Max, MaxBlockNumber, Min, PARALLEL_SEQSCAN_MAX_CHUNK_SIZE, PARALLEL_SEQSCAN_NCHUNKS, pg_nextpower2_32(), SpinLockAcquire, SpinLockRelease, ss_get_location(), and StaticAssertDecl.

Referenced by heap_scan_stream_read_next_parallel().

table_block_relation_estimate_size()

void table_block_relation_estimate_size	(	Relation	rel,
		int32 *	attr_widths,
		BlockNumber *	pages,
		double *	tuples,
		double *	allvisfrac,
		Size	overhead_bytes_per_tuple,
		Size	usable_bytes_per_page
	)

Definition at line 716 of file tableam.c.

{
    BlockNumber curpages;
    BlockNumber relpages;
    double      reltuples;
    BlockNumber relallvisible;
    double      density;
 
    /* it should have storage, so we can call the smgr */
    curpages = RelationGetNumberOfBlocks(rel);
 
    /* coerce values in pg_class to more desirable types */
    relpages = (BlockNumber) rel->rd_rel->relpages;
    reltuples = (double) rel->rd_rel->reltuples;
    relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
 
    /*
     * HACK: if the relation has never yet been vacuumed, use a minimum size
     * estimate of 10 pages.  The idea here is to avoid assuming a
     * newly-created table is really small, even if it currently is, because
     * that may not be true once some data gets loaded into it.  Once a vacuum
     * or analyze cycle has been done on it, it's more reasonable to believe
     * the size is somewhat stable.
     *
     * (Note that this is only an issue if the plan gets cached and used again
     * after the table has been filled.  What we're trying to avoid is using a
     * nestloop-type plan on a table that has grown substantially since the
     * plan was made.  Normally, autovacuum/autoanalyze will occur once enough
     * inserts have happened and cause cached-plan invalidation; but that
     * doesn't happen instantaneously, and it won't happen at all for cases
     * such as temporary tables.)
     *
     * We test "never vacuumed" by seeing whether reltuples < 0.
     *
     * If the table has inheritance children, we don't apply this heuristic.
     * Totally empty parent tables are quite common, so we should be willing
     * to believe that they are empty.
     */
    if (curpages < 10 &&
        reltuples < 0 &&
        !rel->rd_rel->relhassubclass)
        curpages = 10;
 
    /* report estimated # pages */
    *pages = curpages;
    /* quick exit if rel is clearly empty */
    if (curpages == 0)
    {
        *tuples = 0;
        *allvisfrac = 0;
        return;
    }
 
    /* estimate number of tuples from previous tuple density */
    if (reltuples >= 0 && relpages > 0)
        density = reltuples / (double) relpages;
    else
    {
        /*
         * When we have no data because the relation was never yet vacuumed,
         * estimate tuple width from attribute datatypes.  We assume here that
         * the pages are completely full, which is OK for tables but is
         * probably an overestimate for indexes.  Fortunately
         * get_relation_info() can clamp the overestimate to the parent
         * table's size.
         *
         * Note: this code intentionally disregards alignment considerations,
         * because (a) that would be gilding the lily considering how crude
         * the estimate is, (b) it creates platform dependencies in the
         * default plans which are kind of a headache for regression testing,
         * and (c) different table AMs might use different padding schemes.
         */
        int32       tuple_width;
        int         fillfactor;
 
        /*
         * Without reltuples/relpages, we also need to consider fillfactor.
         * The other branch considers it implicitly by calculating density
         * from actual relpages/reltuples statistics.
         */
        fillfactor = RelationGetFillFactor(rel, HEAP_DEFAULT_FILLFACTOR);
 
        tuple_width = get_rel_data_width(rel, attr_widths);
        tuple_width += overhead_bytes_per_tuple;
        /* note: integer division is intentional here */
        density = (usable_bytes_per_page * fillfactor / 100) / tuple_width;
        /* There's at least one row on the page, even with low fillfactor. */
        density = clamp_row_est(density);
    }
    *tuples = rint(density * (double) curpages);
 
    /*
     * We use relallvisible as-is, rather than scaling it up like we do for
     * the pages and tuples counts, on the theory that any pages added since
     * the last VACUUM are most likely not marked all-visible.  But costsize.c
     * wants it converted to a fraction.
     */
    if (relallvisible == 0 || curpages <= 0)
        *allvisfrac = 0;
    else if ((double) relallvisible >= curpages)
        *allvisfrac = 1;
    else
        *allvisfrac = (double) relallvisible / curpages;
}

References clamp_row_est(), fb(), fillfactor, get_rel_data_width(), HEAP_DEFAULT_FILLFACTOR, RelationData::rd_rel, RelationGetFillFactor, and RelationGetNumberOfBlocks.

Referenced by heapam_estimate_rel_size().

table_block_relation_size()

uint64 table_block_relation_size	(	Relation	rel,
		ForkNumber	forkNumber
	)

Definition at line 679 of file tableam.c.

{
    uint64      nblocks = 0;
 
    /* InvalidForkNumber indicates returning the size for all forks */
    if (forkNumber == InvalidForkNumber)
    {
        for (int i = 0; i < MAX_FORKNUM; i++)
            nblocks += smgrnblocks(RelationGetSmgr(rel), i);
    }
    else
        nblocks = smgrnblocks(RelationGetSmgr(rel), forkNumber);
 
    return nblocks * BLCKSZ;
}

References fb(), i, InvalidForkNumber, MAX_FORKNUM, RelationGetSmgr(), and smgrnblocks().

table_index_fetch_tuple_check()

bool table_index_fetch_tuple_check	(	Relation	rel,
		ItemPointer	tid,
		Snapshot	snapshot,
		bool *	all_dead
	)

Definition at line 240 of file tableam.c.

{
    IndexFetchTableData *scan;
    TupleTableSlot *slot;
    bool        call_again = false;
    bool        found;
 
    slot = table_slot_create(rel, NULL);
    scan = table_index_fetch_begin(rel);
    found = table_index_fetch_tuple(scan, tid, snapshot, slot, &call_again,
                                    all_dead);
    table_index_fetch_end(scan);
    ExecDropSingleTupleTableSlot(slot);
 
    return found;
}

References ExecDropSingleTupleTableSlot(), fb(), table_index_fetch_begin(), table_index_fetch_end(), table_index_fetch_tuple(), and table_slot_create().

Referenced by _bt_check_unique().

table_parallelscan_estimate()

Size table_parallelscan_estimate	(	Relation	rel,
		Snapshot	snapshot
	)

Definition at line 131 of file tableam.c.

{
    Size        sz = 0;
 
    if (IsMVCCSnapshot(snapshot))
        sz = add_size(sz, EstimateSnapshotSpace(snapshot));
    else
        Assert(snapshot == SnapshotAny);
 
    sz = add_size(sz, rel->rd_tableam->parallelscan_estimate(rel));
 
    return sz;
}

References add_size(), Assert, EstimateSnapshotSpace(), fb(), IsMVCCSnapshot, TableAmRoutine::parallelscan_estimate, RelationData::rd_tableam, and SnapshotAny.

Referenced by _brin_parallel_estimate_shared(), _bt_parallel_estimate_shared(), _gin_parallel_estimate_shared(), ExecSeqScanEstimate(), and ExecTidRangeScanEstimate().

table_parallelscan_initialize()

void table_parallelscan_initialize	(	Relation	rel,
		ParallelTableScanDesc	pscan,
		Snapshot	snapshot
	)

Definition at line 146 of file tableam.c.

{
    Size        snapshot_off = rel->rd_tableam->parallelscan_initialize(rel, pscan);
 
    pscan->phs_snapshot_off = snapshot_off;
 
    if (IsMVCCSnapshot(snapshot))
    {
        SerializeSnapshot(snapshot, (char *) pscan + pscan->phs_snapshot_off);
        pscan->phs_snapshot_any = false;
    }
    else
    {
        Assert(snapshot == SnapshotAny);
        pscan->phs_snapshot_any = true;
    }
}

References Assert, fb(), IsMVCCSnapshot, TableAmRoutine::parallelscan_initialize, RelationData::rd_tableam, SerializeSnapshot(), and SnapshotAny.

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), ExecSeqScanInitializeDSM(), and ExecTidRangeScanInitializeDSM().

table_slot_callbacks()

const TupleTableSlotOps * table_slot_callbacks

(

Relation

relation

)

Definition at line 59 of file tableam.c.

{
    const TupleTableSlotOps *tts_cb;
 
    if (relation->rd_tableam)
        tts_cb = relation->rd_tableam->slot_callbacks(relation);
    else if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    {
        /*
         * Historically FDWs expect to store heap tuples in slots. Continue
         * handing them one, to make it less painful to adapt FDWs to new
         * versions. The cost of a heap slot over a virtual slot is pretty
         * small.
         */
        tts_cb = &TTSOpsHeapTuple;
    }
    else
    {
        /*
         * These need to be supported, as some parts of the code (like COPY)
         * need to create slots for such relations too. It seems better to
         * centralize the knowledge that a heap slot is the right thing in
         * that case here.
         */
        Assert(relation->rd_rel->relkind == RELKIND_VIEW ||
               relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
        tts_cb = &TTSOpsVirtual;
    }
 
    return tts_cb;
}

References Assert, fb(), RelationData::rd_rel, RelationData::rd_tableam, TableAmRoutine::slot_callbacks, TTSOpsHeapTuple, and TTSOpsVirtual.

Referenced by ATRewriteTable(), ExecGetAllNullSlot(), ExecGetReturningSlot(), ExecGetTriggerNewSlot(), ExecGetTriggerOldSlot(), ExecInitBitmapHeapScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitTidRangeScan(), ExecInitTidScan(), and table_slot_create().

table_slot_create()

TupleTableSlot * table_slot_create	(	Relation	relation,
		List **	reglist
	)

Definition at line 92 of file tableam.c.

{
    const TupleTableSlotOps *tts_cb;
    TupleTableSlot *slot;
 
    tts_cb = table_slot_callbacks(relation);
    slot = MakeSingleTupleTableSlot(RelationGetDescr(relation), tts_cb);
 
    if (reglist)
        *reglist = lappend(*reglist, slot);
 
    return slot;
}

References fb(), lappend(), MakeSingleTupleTableSlot(), RelationGetDescr, and table_slot_callbacks().

Referenced by acquire_sample_rows(), apply_handle_tuple_routing(), apply_handle_update_internal(), build_index_value_desc(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), CopyFrom(), CopyMultiInsertInfoNextFreeSlot(), CopyRelationTo(), createSplitPartitionContext(), EvalPlanQualSlot(), ExecCrossPartitionUpdate(), ExecInitInsertProjection(), ExecInitMerge(), ExecInitMergeTupleSlots(), ExecInitModifyTable(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecInitUpdateProjection(), FindConflictTuple(), FindReplTupleInLocalRel(), get_actual_variable_range(), heap_entry_is_visible(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), MergePartitionsMoveRows(), RelationFindDeletedTupleInfoByIndex(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), SplitPartitionMoveRows(), systable_beginscan(), systable_beginscan_ordered(), table_index_fetch_tuple_check(), unique_key_recheck(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

table_tuple_get_latest_tid()

void table_tuple_get_latest_tid	(	TableScanDesc	scan,
		ItemPointer	tid
	)

Definition at line 267 of file tableam.c.

{
    Relation    rel = scan->rs_rd;
    const TableAmRoutine *tableam = rel->rd_tableam;
 
    /*
     * Since this can be called with user-supplied TID, don't trust the input
     * too much.
     */
    if (!tableam->tuple_tid_valid(scan, tid))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("tid (%u, %u) is not valid for relation \"%s\"",
                        ItemPointerGetBlockNumberNoCheck(tid),
                        ItemPointerGetOffsetNumberNoCheck(tid),
                        RelationGetRelationName(rel))));
 
    tableam->tuple_get_latest_tid(scan, tid);
}

References ereport, errcode(), errmsg(), ERROR, fb(), ItemPointerGetBlockNumberNoCheck(), ItemPointerGetOffsetNumberNoCheck(), RelationData::rd_tableam, RelationGetRelationName, TableScanDescData::rs_rd, TableAmRoutine::tuple_get_latest_tid, and TableAmRoutine::tuple_tid_valid.

Referenced by currtid_internal(), and TidNext().

Variable Documentation

default_table_access_method

char* default_table_access_method = DEFAULT_TABLE_ACCESS_METHOD

Definition at line 49 of file tableam.c.

Referenced by ATPrepSetAccessMethod(), and DefineRelation().

synchronize_seqscans

bool synchronize_seqscans = true

Definition at line 50 of file tableam.c.

Referenced by initscan(), and table_block_parallelscan_initialize().