tableam.h File Reference

#include "access/relscan.h"
#include "access/sdir.h"
#include "access/xact.h"
#include "commands/vacuum.h"
#include "executor/tuptable.h"
#include "storage/read_stream.h"
#include "utils/rel.h"
#include "utils/snapshot.h"

Include dependency graph for tableam.h:

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

Go to the source code of this file.

Data Structures
struct	TM_FailureData
struct	TM_IndexDelete
struct	TM_IndexStatus
struct	TM_IndexDeleteOp
struct	TableAmRoutine

Macros
#define	DEFAULT_TABLE_ACCESS_METHOD   "heap"
#define	TABLE_INSERT_SKIP_FSM   0x0002
#define	TABLE_INSERT_FROZEN   0x0004
#define	TABLE_INSERT_NO_LOGICAL   0x0008
#define	TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS   (1 << 0)
#define	TUPLE_LOCK_FLAG_FIND_LAST_VERSION   (1 << 1)

Typedefs
typedef struct BulkInsertStateData	BulkInsertStateData
typedef struct IndexInfo	IndexInfo
typedef struct SampleScanState	SampleScanState
typedef struct ValidateIndexState	ValidateIndexState
typedef enum ScanOptions	ScanOptions
typedef enum TM_Result	TM_Result
typedef enum TU_UpdateIndexes	TU_UpdateIndexes
typedef struct TM_FailureData	TM_FailureData
typedef struct TM_IndexDelete	TM_IndexDelete
typedef struct TM_IndexStatus	TM_IndexStatus
typedef struct TM_IndexDeleteOp	TM_IndexDeleteOp
typedef void(*	IndexBuildCallback) (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
typedef struct TableAmRoutine	TableAmRoutine

Enumerations
enum	ScanOptions {   SO_TYPE_SEQSCAN = 1 << 0 , SO_TYPE_BITMAPSCAN = 1 << 1 , SO_TYPE_SAMPLESCAN = 1 << 2 , SO_TYPE_TIDSCAN = 1 << 3 ,   SO_TYPE_TIDRANGESCAN = 1 << 4 , SO_TYPE_ANALYZE = 1 << 5 , SO_ALLOW_STRAT = 1 << 6 , SO_ALLOW_SYNC = 1 << 7 ,   SO_ALLOW_PAGEMODE = 1 << 8 , SO_TEMP_SNAPSHOT = 1 << 9 }
enum	TM_Result {   TM_Ok , TM_Invisible , TM_SelfModified , TM_Updated ,   TM_Deleted , TM_BeingModified , TM_WouldBlock }
enum	TU_UpdateIndexes { TU_None , TU_All , TU_Summarizing }

Functions
const TupleTableSlotOps *	table_slot_callbacks (Relation relation)
TupleTableSlot *	table_slot_create (Relation relation, List **reglist)
static TableScanDesc	table_beginscan (Relation rel, Snapshot snapshot, int nkeys, ScanKeyData *key)
TableScanDesc	table_beginscan_catalog (Relation relation, int nkeys, ScanKeyData *key)
static TableScanDesc	table_beginscan_strat (Relation rel, Snapshot snapshot, int nkeys, ScanKeyData *key, bool allow_strat, bool allow_sync)
static TableScanDesc	table_beginscan_bm (Relation rel, Snapshot snapshot, int nkeys, ScanKeyData *key)
static TableScanDesc	table_beginscan_sampling (Relation rel, Snapshot snapshot, int nkeys, ScanKeyData *key, bool allow_strat, bool allow_sync, bool allow_pagemode)
static TableScanDesc	table_beginscan_tid (Relation rel, Snapshot snapshot)
static TableScanDesc	table_beginscan_analyze (Relation rel)
static void	table_endscan (TableScanDesc scan)
static void	table_rescan (TableScanDesc scan, ScanKeyData *key)
static void	table_rescan_set_params (TableScanDesc scan, ScanKeyData *key, bool allow_strat, bool allow_sync, bool allow_pagemode)
static bool	table_scan_getnextslot (TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
static TableScanDesc	table_beginscan_tidrange (Relation rel, Snapshot snapshot, ItemPointer mintid, ItemPointer maxtid)
static void	table_rescan_tidrange (TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
static bool	table_scan_getnextslot_tidrange (TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
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)
static void	table_parallelscan_reinitialize (Relation rel, ParallelTableScanDesc pscan)
static IndexFetchTableData *	table_index_fetch_begin (Relation rel)
static void	table_index_fetch_reset (struct IndexFetchTableData *scan)
static void	table_index_fetch_end (struct IndexFetchTableData *scan)
static bool	table_index_fetch_tuple (struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead)
bool	table_index_fetch_tuple_check (Relation rel, ItemPointer tid, Snapshot snapshot, bool *all_dead)
static bool	table_tuple_fetch_row_version (Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot)
static bool	table_tuple_tid_valid (TableScanDesc scan, ItemPointer tid)
void	table_tuple_get_latest_tid (TableScanDesc scan, ItemPointer tid)
static bool	table_tuple_satisfies_snapshot (Relation rel, TupleTableSlot *slot, Snapshot snapshot)
static TransactionId	table_index_delete_tuples (Relation rel, TM_IndexDeleteOp *delstate)
static void	table_tuple_insert (Relation rel, TupleTableSlot *slot, CommandId cid, int options, BulkInsertStateData *bistate)
static void	table_tuple_insert_speculative (Relation rel, TupleTableSlot *slot, CommandId cid, int options, BulkInsertStateData *bistate, uint32 specToken)
static void	table_tuple_complete_speculative (Relation rel, TupleTableSlot *slot, uint32 specToken, bool succeeded)
static void	table_multi_insert (Relation rel, TupleTableSlot **slots, int nslots, CommandId cid, int options, BulkInsertStateData *bistate)
static TM_Result	table_tuple_delete (Relation rel, ItemPointer tid, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
static TM_Result	table_tuple_update (Relation rel, ItemPointer otid, TupleTableSlot *slot, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
static TM_Result	table_tuple_lock (Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
static void	table_finish_bulk_insert (Relation rel, int options)
static void	table_relation_set_new_filelocator (Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
static void	table_relation_nontransactional_truncate (Relation rel)
static void	table_relation_copy_data (Relation rel, const RelFileLocator *newrlocator)
static void	table_relation_copy_for_cluster (Relation OldTable, Relation NewTable, Relation OldIndex, bool use_sort, TransactionId OldestXmin, TransactionId *xid_cutoff, MultiXactId *multi_cutoff, double *num_tuples, double *tups_vacuumed, double *tups_recently_dead)
static void	table_relation_vacuum (Relation rel, const VacuumParams params, BufferAccessStrategy bstrategy)
static bool	table_scan_analyze_next_block (TableScanDesc scan, ReadStream *stream)
static bool	table_scan_analyze_next_tuple (TableScanDesc scan, TransactionId OldestXmin, double *liverows, double *deadrows, TupleTableSlot *slot)
static double	table_index_build_scan (Relation table_rel, Relation index_rel, IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
static double	table_index_build_range_scan (Relation table_rel, Relation index_rel, IndexInfo *index_info, bool allow_sync, bool anyvisible, bool progress, BlockNumber start_blockno, BlockNumber numblocks, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
static void	table_index_validate_scan (Relation table_rel, Relation index_rel, IndexInfo *index_info, Snapshot snapshot, ValidateIndexState *state)
static uint64	table_relation_size (Relation rel, ForkNumber forkNumber)
static bool	table_relation_needs_toast_table (Relation rel)
static Oid	table_relation_toast_am (Relation rel)
static void	table_relation_fetch_toast_slice (Relation toastrel, Oid valueid, int32 attrsize, int32 sliceoffset, int32 slicelength, struct varlena *result)
static void	table_relation_estimate_size (Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
static bool	table_scan_bitmap_next_tuple (TableScanDesc scan, TupleTableSlot *slot, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages)
static bool	table_scan_sample_next_block (TableScanDesc scan, SampleScanState *scanstate)
static bool	table_scan_sample_next_tuple (TableScanDesc scan, SampleScanState *scanstate, TupleTableSlot *slot)
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)
BlockNumber	table_block_parallelscan_nextpage (Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan)
void	table_block_parallelscan_startblock_init (Relation rel, ParallelBlockTableScanWorker pbscanwork, ParallelBlockTableScanDesc pbscan, BlockNumber startblock, BlockNumber numblocks)
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)
const TableAmRoutine *	GetTableAmRoutine (Oid amhandler)
const TableAmRoutine *	GetHeapamTableAmRoutine (void)

Variables
PGDLLIMPORT char *	default_table_access_method
PGDLLIMPORT bool	synchronize_seqscans

Macro Definition Documentation

DEFAULT_TABLE_ACCESS_METHOD

#define DEFAULT_TABLE_ACCESS_METHOD   "heap"

Definition at line 30 of file tableam.h.

TABLE_INSERT_FROZEN

#define TABLE_INSERT_FROZEN   0x0004

Definition at line 260 of file tableam.h.

TABLE_INSERT_NO_LOGICAL

#define TABLE_INSERT_NO_LOGICAL   0x0008

Definition at line 261 of file tableam.h.

TABLE_INSERT_SKIP_FSM

#define TABLE_INSERT_SKIP_FSM   0x0002

Definition at line 259 of file tableam.h.

TUPLE_LOCK_FLAG_FIND_LAST_VERSION

#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION   (1 << 1)

Definition at line 267 of file tableam.h.

TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS

#define TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS   (1 << 0)

Definition at line 265 of file tableam.h.

Typedef Documentation

BulkInsertStateData

typedef struct BulkInsertStateData BulkInsertStateData

Definition at line 38 of file tableam.h.

IndexBuildCallback

typedef void(* IndexBuildCallback) (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)

Definition at line 271 of file tableam.h.

IndexInfo

typedef struct IndexInfo IndexInfo

Definition at line 39 of file tableam.h.

SampleScanState

typedef struct SampleScanState SampleScanState

Definition at line 40 of file tableam.h.

ScanOptions

typedef enum ScanOptions ScanOptions

TableAmRoutine

typedef struct TableAmRoutine TableAmRoutine

TM_FailureData

typedef struct TM_FailureData TM_FailureData

TM_IndexDelete

typedef struct TM_IndexDelete TM_IndexDelete

TM_IndexDeleteOp

typedef struct TM_IndexDeleteOp TM_IndexDeleteOp

TM_IndexStatus

typedef struct TM_IndexStatus TM_IndexStatus

TM_Result

typedef enum TM_Result TM_Result

TU_UpdateIndexes

typedef enum TU_UpdateIndexes TU_UpdateIndexes

ValidateIndexState

typedef struct ValidateIndexState ValidateIndexState

Definition at line 41 of file tableam.h.

Enumeration Type Documentation

ScanOptions

enum ScanOptions

Enumerator
SO_TYPE_SEQSCAN
SO_TYPE_BITMAPSCAN
SO_TYPE_SAMPLESCAN
SO_TYPE_TIDSCAN
SO_TYPE_TIDRANGESCAN
SO_TYPE_ANALYZE
SO_ALLOW_STRAT
SO_ALLOW_SYNC
SO_ALLOW_PAGEMODE
SO_TEMP_SNAPSHOT

Definition at line 46 of file tableam.h.

{
    /* one of SO_TYPE_* may be specified */
    SO_TYPE_SEQSCAN = 1 << 0,
    SO_TYPE_BITMAPSCAN = 1 << 1,
    SO_TYPE_SAMPLESCAN = 1 << 2,
    SO_TYPE_TIDSCAN = 1 << 3,
    SO_TYPE_TIDRANGESCAN = 1 << 4,
    SO_TYPE_ANALYZE = 1 << 5,
 
    /* several of SO_ALLOW_* may be specified */
    /* allow or disallow use of access strategy */
    SO_ALLOW_STRAT = 1 << 6,
    /* report location to syncscan logic? */
    SO_ALLOW_SYNC = 1 << 7,
    /* verify visibility page-at-a-time? */
    SO_ALLOW_PAGEMODE = 1 << 8,
 
    /* unregister snapshot at scan end? */
    SO_TEMP_SNAPSHOT = 1 << 9,
}           ScanOptions;

TM_Result

enum TM_Result

Enumerator
TM_Ok
TM_Invisible
TM_SelfModified
TM_Updated
TM_Deleted
TM_BeingModified
TM_WouldBlock

Definition at line 72 of file tableam.h.

{
    /*
     * Signals that the action succeeded (i.e. update/delete performed, lock
     * was acquired)
     */
    TM_Ok,
 
    /* The affected tuple wasn't visible to the relevant snapshot */
    TM_Invisible,
 
    /* The affected tuple was already modified by the calling backend */
    TM_SelfModified,
 
    /*
     * The affected tuple was updated by another transaction. This includes
     * the case where tuple was moved to another partition.
     */
    TM_Updated,
 
    /* The affected tuple was deleted by another transaction */
    TM_Deleted,
 
    /*
     * The affected tuple is currently being modified by another session. This
     * will only be returned if table_(update/delete/lock_tuple) are
     * instructed not to wait.
     */
    TM_BeingModified,
 
    /* lock couldn't be acquired, action skipped. Only used by lock_tuple */
    TM_WouldBlock,
} TM_Result;

TU_UpdateIndexes

enum TU_UpdateIndexes

Enumerator
TU_None
TU_All
TU_Summarizing

Definition at line 110 of file tableam.h.

{
    /* No indexed columns were updated (incl. TID addressing of tuple) */
    TU_None,
 
    /* A non-summarizing indexed column was updated, or the TID has changed */
    TU_All,
 
    /* Only summarized columns were updated, TID is unchanged */
    TU_Summarizing,
} TU_UpdateIndexes;

Function Documentation

GetHeapamTableAmRoutine()

const TableAmRoutine * GetHeapamTableAmRoutine ( void  )

extern

Definition at line 2690 of file heapam_handler.c.

{
    return &heapam_methods;
}

References heapam_methods.

Referenced by formrdesc(), and heap_getnext().

GetTableAmRoutine()

const TableAmRoutine * GetTableAmRoutine ( Oid  amhandler )

extern

Definition at line 27 of file tableamapi.c.

{
    Datum       datum;
    const TableAmRoutine *routine;
 
    datum = OidFunctionCall0(amhandler);
    routine = (const TableAmRoutine *) DatumGetPointer(datum);
 
    if (routine == NULL || !IsA(routine, TableAmRoutine))
        elog(ERROR, "table access method handler %u did not return a TableAmRoutine struct",
             amhandler);
 
    /*
     * Assert that all required callbacks are present. That makes it a bit
     * easier to keep AMs up to date, e.g. when forward porting them to a new
     * major version.
     */
    Assert(routine->scan_begin != NULL);
    Assert(routine->scan_end != NULL);
    Assert(routine->scan_rescan != NULL);
    Assert(routine->scan_getnextslot != NULL);
 
    Assert(routine->parallelscan_estimate != NULL);
    Assert(routine->parallelscan_initialize != NULL);
    Assert(routine->parallelscan_reinitialize != NULL);
 
    Assert(routine->index_fetch_begin != NULL);
    Assert(routine->index_fetch_reset != NULL);
    Assert(routine->index_fetch_end != NULL);
    Assert(routine->index_fetch_tuple != NULL);
 
    Assert(routine->tuple_fetch_row_version != NULL);
    Assert(routine->tuple_tid_valid != NULL);
    Assert(routine->tuple_get_latest_tid != NULL);
    Assert(routine->tuple_satisfies_snapshot != NULL);
    Assert(routine->index_delete_tuples != NULL);
 
    Assert(routine->tuple_insert != NULL);
 
    /*
     * Could be made optional, but would require throwing error during
     * parse-analysis.
     */
    Assert(routine->tuple_insert_speculative != NULL);
    Assert(routine->tuple_complete_speculative != NULL);
 
    Assert(routine->multi_insert != NULL);
    Assert(routine->tuple_delete != NULL);
    Assert(routine->tuple_update != NULL);
    Assert(routine->tuple_lock != NULL);
 
    Assert(routine->relation_set_new_filelocator != NULL);
    Assert(routine->relation_nontransactional_truncate != NULL);
    Assert(routine->relation_copy_data != NULL);
    Assert(routine->relation_copy_for_cluster != NULL);
    Assert(routine->relation_vacuum != NULL);
    Assert(routine->scan_analyze_next_block != NULL);
    Assert(routine->scan_analyze_next_tuple != NULL);
    Assert(routine->index_build_range_scan != NULL);
    Assert(routine->index_validate_scan != NULL);
 
    Assert(routine->relation_size != NULL);
    Assert(routine->relation_needs_toast_table != NULL);
 
    Assert(routine->relation_estimate_size != NULL);
 
    Assert(routine->scan_sample_next_block != NULL);
    Assert(routine->scan_sample_next_tuple != NULL);
 
    return routine;
}

References Assert, DatumGetPointer(), elog, ERROR, fb(), TableAmRoutine::index_build_range_scan, TableAmRoutine::index_delete_tuples, TableAmRoutine::index_fetch_begin, TableAmRoutine::index_fetch_end, TableAmRoutine::index_fetch_reset, TableAmRoutine::index_fetch_tuple, TableAmRoutine::index_validate_scan, IsA, TableAmRoutine::multi_insert, OidFunctionCall0, TableAmRoutine::parallelscan_estimate, TableAmRoutine::parallelscan_initialize, TableAmRoutine::parallelscan_reinitialize, TableAmRoutine::relation_copy_data, TableAmRoutine::relation_copy_for_cluster, TableAmRoutine::relation_estimate_size, TableAmRoutine::relation_needs_toast_table, TableAmRoutine::relation_nontransactional_truncate, TableAmRoutine::relation_set_new_filelocator, TableAmRoutine::relation_size, TableAmRoutine::relation_vacuum, TableAmRoutine::scan_analyze_next_block, TableAmRoutine::scan_analyze_next_tuple, TableAmRoutine::scan_begin, TableAmRoutine::scan_end, TableAmRoutine::scan_getnextslot, TableAmRoutine::scan_rescan, TableAmRoutine::scan_sample_next_block, TableAmRoutine::scan_sample_next_tuple, TableAmRoutine::tuple_complete_speculative, TableAmRoutine::tuple_delete, TableAmRoutine::tuple_fetch_row_version, TableAmRoutine::tuple_get_latest_tid, TableAmRoutine::tuple_insert, TableAmRoutine::tuple_insert_speculative, TableAmRoutine::tuple_lock, TableAmRoutine::tuple_satisfies_snapshot, TableAmRoutine::tuple_tid_valid, and TableAmRoutine::tuple_update.

Referenced by InitTableAmRoutine().

simple_table_tuple_delete()

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

extern

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

extern

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

extern

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

static TableScanDesc table_beginscan ( Relation  rel, Snapshot  snapshot, int  nkeys, ScanKeyData *  key  )

inlinestatic

Definition at line 876 of file tableam.h.

{
    uint32      flags = SO_TYPE_SEQSCAN |
        SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE;
 
    return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key, NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, and SO_TYPE_SEQSCAN.

Referenced by ATRewriteTable(), check_default_partition_contents(), CopyRelationTo(), heapam_relation_copy_for_cluster(), MergePartitionsMoveRows(), pgrowlocks(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), SeqNext(), SplitPartitionMoveRows(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

table_beginscan_analyze()

static TableScanDesc table_beginscan_analyze ( Relation  rel )

inlinestatic

Definition at line 974 of file tableam.h.

{
    uint32      flags = SO_TYPE_ANALYZE;
 
    return rel->rd_tableam->scan_begin(rel, NULL, 0, NULL, NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, and SO_TYPE_ANALYZE.

Referenced by acquire_sample_rows().

table_beginscan_bm()

static TableScanDesc table_beginscan_bm ( Relation  rel, Snapshot  snapshot, int  nkeys, ScanKeyData *  key  )

inlinestatic

Definition at line 921 of file tableam.h.

{
    uint32      flags = SO_TYPE_BITMAPSCAN | SO_ALLOW_PAGEMODE;
 
    return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key,
                                       NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, and SO_TYPE_BITMAPSCAN.

Referenced by BitmapTableScanSetup().

table_beginscan_catalog()

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

extern

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 relation->rd_tableam->scan_begin(relation, snapshot, nkeys, key,
                                            NULL, flags);
}

References fb(), GetCatalogSnapshot(), RelationData::rd_tableam, RegisterSnapshot(), RelationGetRelid, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, SO_TEMP_SNAPSHOT, and SO_TYPE_SEQSCAN.

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  )

extern

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 relation->rd_tableam->scan_begin(relation, snapshot, 0, NULL,
                                            pscan, flags);
}

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

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  )

extern

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 = relation->rd_tableam->scan_begin(relation, snapshot, 0, NULL,
                                             pscan, flags);
    return sscan;
}

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

Referenced by ExecTidRangeScanInitializeDSM(), and ExecTidRangeScanInitializeWorker().

table_beginscan_sampling()

static TableScanDesc table_beginscan_sampling ( Relation  rel, Snapshot  snapshot, int  nkeys, ScanKeyData *  key, bool  allow_strat, bool  allow_sync, bool  allow_pagemode  )

inlinestatic

Definition at line 938 of file tableam.h.

{
    uint32      flags = SO_TYPE_SAMPLESCAN;
 
    if (allow_strat)
        flags |= SO_ALLOW_STRAT;
    if (allow_sync)
        flags |= SO_ALLOW_SYNC;
    if (allow_pagemode)
        flags |= SO_ALLOW_PAGEMODE;
 
    return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key, NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, and SO_TYPE_SAMPLESCAN.

Referenced by tablesample_init().

table_beginscan_strat()

static TableScanDesc table_beginscan_strat ( Relation  rel, Snapshot  snapshot, int  nkeys, ScanKeyData *  key, bool  allow_strat, bool  allow_sync  )

inlinestatic

Definition at line 900 of file tableam.h.

{
    uint32      flags = SO_TYPE_SEQSCAN | SO_ALLOW_PAGEMODE;
 
    if (allow_strat)
        flags |= SO_ALLOW_STRAT;
    if (allow_sync)
        flags |= SO_ALLOW_SYNC;
 
    return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key, NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, and SO_TYPE_SEQSCAN.

Referenced by bt_check_every_level(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), pgstat_heap(), and systable_beginscan().

table_beginscan_tid()

static TableScanDesc table_beginscan_tid ( Relation  rel, Snapshot  snapshot  )

inlinestatic

Definition at line 961 of file tableam.h.

{
    uint32      flags = SO_TYPE_TIDSCAN;
 
    return rel->rd_tableam->scan_begin(rel, snapshot, 0, NULL, NULL, flags);
}

References fb(), RelationData::rd_tableam, TableAmRoutine::scan_begin, and SO_TYPE_TIDSCAN.

Referenced by currtid_internal(), and TidListEval().

table_beginscan_tidrange()

static TableScanDesc table_beginscan_tidrange ( Relation  rel, Snapshot  snapshot, ItemPointer  mintid, ItemPointer  maxtid  )

inlinestatic

Definition at line 1049 of file tableam.h.

{
    TableScanDesc sscan;
    uint32      flags = SO_TYPE_TIDRANGESCAN | SO_ALLOW_PAGEMODE;
 
    sscan = rel->rd_tableam->scan_begin(rel, snapshot, 0, NULL, NULL, flags);
 
    /* Set the range of TIDs to scan */
    sscan->rs_rd->rd_tableam->scan_set_tidrange(sscan, mintid, maxtid);
 
    return sscan;
}

References fb(), RelationData::rd_tableam, TableScanDescData::rs_rd, TableAmRoutine::scan_begin, TableAmRoutine::scan_set_tidrange, SO_ALLOW_PAGEMODE, and SO_TYPE_TIDRANGESCAN.

Referenced by TidRangeNext().

table_block_parallelscan_estimate()

Size table_block_parallelscan_estimate ( Relation  rel )

extern

Definition at line 414 of file tableam.c.

{
    return sizeof(ParallelBlockTableScanDescData);
}

table_block_parallelscan_initialize()

Size table_block_parallelscan_initialize ( Relation  rel, ParallelTableScanDesc  pscan  )

extern

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

extern

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

extern

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

extern

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

extern

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

extern

Definition at line 687 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_endscan()

static void table_endscan ( TableScanDesc  scan )

inlinestatic

Definition at line 985 of file tableam.h.

{
    scan->rs_rd->rd_tableam->scan_end(scan);
}

References RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_end.

Referenced by acquire_sample_rows(), AlterTableMoveAll(), AlterTableSpaceOptions(), ATRewriteTable(), check_db_file_conflict(), check_default_partition_contents(), CopyRelationTo(), CreateDatabaseUsingFileCopy(), currtid_internal(), do_autovacuum(), DropSetting(), DropTableSpace(), ExecEndBitmapHeapScan(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndTidRangeScan(), ExecEndTidScan(), 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(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), MergePartitionsMoveRows(), objectsInSchemaToOids(), pgrowlocks(), pgstat_heap(), populate_typ_list(), ReindexMultipleTables(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), remove_dbtablespaces(), RemoveSubscriptionRel(), RenameTableSpace(), SplitPartitionMoveRows(), systable_endscan(), ThereIsAtLeastOneRole(), vac_truncate_clog(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

table_finish_bulk_insert()

static void table_finish_bulk_insert ( Relation  rel, int  options  )

inlinestatic

Definition at line 1574 of file tableam.h.

{
    /* optional callback */
    if (rel->rd_tableam && rel->rd_tableam->finish_bulk_insert)
        rel->rd_tableam->finish_bulk_insert(rel, options);
}

References TableAmRoutine::finish_bulk_insert, and RelationData::rd_tableam.

Referenced by ATRewriteTable(), CopyMultiInsertBufferCleanup(), deleteSplitPartitionContext(), intorel_shutdown(), MergePartitionsMoveRows(), and transientrel_shutdown().

table_index_build_range_scan()

static double table_index_build_range_scan ( Relation  table_rel, Relation  index_rel, IndexInfo *  index_info, bool  allow_sync, bool  anyvisible, bool  progress, BlockNumber  start_blockno, BlockNumber  numblocks, IndexBuildCallback  callback, void *  callback_state, TableScanDesc  scan  )

inlinestatic

Definition at line 1787 of file tableam.h.

{
    return table_rel->rd_tableam->index_build_range_scan(table_rel,
                                                         index_rel,
                                                         index_info,
                                                         allow_sync,
                                                         anyvisible,
                                                         progress,
                                                         start_blockno,
                                                         numblocks,
                                                         callback,
                                                         callback_state,
                                                         scan);
}

References callback(), fb(), and progress.

Referenced by summarize_range().

table_index_build_scan()

static double table_index_build_scan ( Relation  table_rel, Relation  index_rel, IndexInfo *  index_info, bool  allow_sync, bool  progress, IndexBuildCallback  callback, void *  callback_state, TableScanDesc  scan  )

inlinestatic

Definition at line 1754 of file tableam.h.

{
    return table_rel->rd_tableam->index_build_range_scan(table_rel,
                                                         index_rel,
                                                         index_info,
                                                         allow_sync,
                                                         false,
                                                         progress,
                                                         0,
                                                         InvalidBlockNumber,
                                                         callback,
                                                         callback_state,
                                                         scan);
}

References callback(), fb(), InvalidBlockNumber, and progress.

Referenced by _brin_parallel_scan_and_build(), _bt_parallel_scan_and_sort(), _bt_spools_heapscan(), _gin_parallel_scan_and_build(), blbuild(), brinbuild(), bt_check_every_level(), ginbuild(), gistbuild(), hashbuild(), and spgbuild().

table_index_delete_tuples()

static TransactionId table_index_delete_tuples ( Relation  rel, TM_IndexDeleteOp *  delstate  )

inlinestatic

Definition at line 1331 of file tableam.h.

{
    return rel->rd_tableam->index_delete_tuples(rel, delstate);
}

References fb(), TableAmRoutine::index_delete_tuples, and RelationData::rd_tableam.

Referenced by _bt_delitems_delete_check(), and index_compute_xid_horizon_for_tuples().

table_index_fetch_begin()

static IndexFetchTableData * table_index_fetch_begin ( Relation  rel )

inlinestatic

Definition at line 1167 of file tableam.h.

{
    return rel->rd_tableam->index_fetch_begin(rel);
}

References TableAmRoutine::index_fetch_begin, and RelationData::rd_tableam.

Referenced by index_beginscan(), index_beginscan_parallel(), table_index_fetch_tuple_check(), and unique_key_recheck().

table_index_fetch_end()

static void table_index_fetch_end ( struct IndexFetchTableData *  scan )

inlinestatic

Definition at line 1186 of file tableam.h.

{
    scan->rel->rd_tableam->index_fetch_end(scan);
}

References TableAmRoutine::index_fetch_end, RelationData::rd_tableam, and IndexFetchTableData::rel.

Referenced by index_endscan(), table_index_fetch_tuple_check(), and unique_key_recheck().

table_index_fetch_reset()

static void table_index_fetch_reset ( struct IndexFetchTableData *  scan )

inlinestatic

Definition at line 1177 of file tableam.h.

{
    scan->rel->rd_tableam->index_fetch_reset(scan);
}

References TableAmRoutine::index_fetch_reset, RelationData::rd_tableam, and IndexFetchTableData::rel.

Referenced by index_getnext_tid(), index_parallelrescan(), index_rescan(), and index_restrpos().

table_index_fetch_tuple()

static bool table_index_fetch_tuple ( struct IndexFetchTableData *  scan, ItemPointer  tid, Snapshot  snapshot, TupleTableSlot *  slot, bool *  call_again, bool *  all_dead  )

inlinestatic

Definition at line 1216 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_index_fetch_tuple with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_index_fetch_tuple call during logical decoding");
 
    return scan->rel->rd_tableam->index_fetch_tuple(scan, tid, snapshot,
                                                    slot, call_again,
                                                    all_dead);
}

References bsysscan, CheckXidAlive, elog, ERROR, fb(), TableAmRoutine::index_fetch_tuple, RelationData::rd_tableam, IndexFetchTableData::rel, TransactionIdIsValid, and unlikely.

Referenced by index_fetch_heap(), table_index_fetch_tuple_check(), and unique_key_recheck().

table_index_fetch_tuple_check()

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

extern

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

static void table_index_validate_scan ( Relation  table_rel, Relation  index_rel, IndexInfo *  index_info, Snapshot  snapshot, ValidateIndexState *  state  )

inlinestatic

Definition at line 1818 of file tableam.h.

{
    table_rel->rd_tableam->index_validate_scan(table_rel,
                                               index_rel,
                                               index_info,
                                               snapshot,
                                               state);
}

References fb().

Referenced by validate_index().

table_multi_insert()

static void table_multi_insert ( Relation  rel, TupleTableSlot **  slots, int  nslots, CommandId  cid, int  options, BulkInsertStateData *  bistate  )

inlinestatic

Definition at line 1432 of file tableam.h.

{
    rel->rd_tableam->multi_insert(rel, slots, nslots,
                                  cid, options, bistate);
}

References fb(), TableAmRoutine::multi_insert, and RelationData::rd_tableam.

Referenced by CopyMultiInsertBufferFlush().

table_parallelscan_estimate()

Size table_parallelscan_estimate ( Relation  rel, Snapshot  snapshot  )

extern

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  )

extern

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

static void table_parallelscan_reinitialize ( Relation  rel, ParallelTableScanDesc  pscan  )

inlinestatic

Definition at line 1149 of file tableam.h.

{
    rel->rd_tableam->parallelscan_reinitialize(rel, pscan);
}

References fb(), TableAmRoutine::parallelscan_reinitialize, and RelationData::rd_tableam.

Referenced by ExecSeqScanReInitializeDSM(), and ExecTidRangeScanReInitializeDSM().

table_relation_copy_data()

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

inlinestatic

Definition at line 1630 of file tableam.h.

{
    rel->rd_tableam->relation_copy_data(rel, newrlocator);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::relation_copy_data.

Referenced by ATExecSetTableSpace().

table_relation_copy_for_cluster()

static void table_relation_copy_for_cluster ( Relation  OldTable, Relation  NewTable, Relation  OldIndex, bool  use_sort, TransactionId  OldestXmin, TransactionId *  xid_cutoff, MultiXactId *  multi_cutoff, double *  num_tuples, double *  tups_vacuumed, double *  tups_recently_dead  )

inlinestatic

Definition at line 1657 of file tableam.h.

{
    OldTable->rd_tableam->relation_copy_for_cluster(OldTable, NewTable, OldIndex,
                                                    use_sort, OldestXmin,
                                                    xid_cutoff, multi_cutoff,
                                                    num_tuples, tups_vacuumed,
                                                    tups_recently_dead);
}

References fb().

Referenced by copy_table_data().

table_relation_estimate_size()

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

inlinestatic

Definition at line 1916 of file tableam.h.

{
    rel->rd_tableam->relation_estimate_size(rel, attr_widths, pages, tuples,
                                            allvisfrac);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::relation_estimate_size.

Referenced by estimate_rel_size().

table_relation_fetch_toast_slice()

static void table_relation_fetch_toast_slice ( Relation  toastrel, Oid  valueid, int32  attrsize, int32  sliceoffset, int32  slicelength, struct varlena *  result  )

inlinestatic

Definition at line 1895 of file tableam.h.

{
    toastrel->rd_tableam->relation_fetch_toast_slice(toastrel, valueid,
                                                     attrsize,
                                                     sliceoffset, slicelength,
                                                     result);
}

References fb().

Referenced by toast_fetch_datum(), and toast_fetch_datum_slice().

table_relation_needs_toast_table()

static bool table_relation_needs_toast_table ( Relation  rel )

inlinestatic

Definition at line 1856 of file tableam.h.

{
    return rel->rd_tableam->relation_needs_toast_table(rel);
}

References RelationData::rd_tableam, and TableAmRoutine::relation_needs_toast_table.

Referenced by needs_toast_table().

table_relation_nontransactional_truncate()

static void table_relation_nontransactional_truncate ( Relation  rel )

inlinestatic

Definition at line 1618 of file tableam.h.

{
    rel->rd_tableam->relation_nontransactional_truncate(rel);
}

References RelationData::rd_tableam, and TableAmRoutine::relation_nontransactional_truncate.

Referenced by heap_truncate_one_rel().

table_relation_set_new_filelocator()

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

inlinestatic

Definition at line 1600 of file tableam.h.

{
    rel->rd_tableam->relation_set_new_filelocator(rel, newrlocator,
                                                  persistence, freezeXid,
                                                  minmulti);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::relation_set_new_filelocator.

Referenced by heap_create(), and RelationSetNewRelfilenumber().

table_relation_size()

static uint64 table_relation_size ( Relation  rel, ForkNumber  forkNumber  )

inlinestatic

Definition at line 1847 of file tableam.h.

{
    return rel->rd_tableam->relation_size(rel, forkNumber);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::relation_size.

Referenced by RelationGetNumberOfBlocksInFork().

table_relation_toast_am()

static Oid table_relation_toast_am ( Relation  rel )

inlinestatic

Definition at line 1866 of file tableam.h.

{
    return rel->rd_tableam->relation_toast_am(rel);
}

References RelationData::rd_tableam, and TableAmRoutine::relation_toast_am.

Referenced by create_toast_table().

table_relation_vacuum()

static void table_relation_vacuum ( Relation  rel, const VacuumParams  params, BufferAccessStrategy  bstrategy  )

inlinestatic

Definition at line 1686 of file tableam.h.

{
    rel->rd_tableam->relation_vacuum(rel, params, bstrategy);
}

References RelationData::rd_tableam, and TableAmRoutine::relation_vacuum.

Referenced by vacuum_rel().

table_rescan()

static void table_rescan ( TableScanDesc  scan, ScanKeyData *  key  )

inlinestatic

Definition at line 994 of file tableam.h.

{
    scan->rs_rd->rd_tableam->scan_rescan(scan, key, false, false, false, false);
}

References RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_rescan.

Referenced by ExecReScanBitmapHeapScan(), ExecReScanSeqScan(), ExecReScanTidScan(), RelationFindDeletedTupleInfoSeq(), and RelationFindReplTupleSeq().

table_rescan_set_params()

static void table_rescan_set_params ( TableScanDesc  scan, ScanKeyData *  key, bool  allow_strat, bool  allow_sync, bool  allow_pagemode  )

inlinestatic

Definition at line 1008 of file tableam.h.

{
    scan->rs_rd->rd_tableam->scan_rescan(scan, key, true,
                                         allow_strat, allow_sync,
                                         allow_pagemode);
}

References fb(), RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_rescan.

Referenced by tablesample_init().

table_rescan_tidrange()

static void table_rescan_tidrange ( TableScanDesc  sscan, ItemPointer  mintid, ItemPointer  maxtid  )

inlinestatic

Definition at line 1070 of file tableam.h.

{
    /* Ensure table_beginscan_tidrange() was used. */
    Assert((sscan->rs_flags & SO_TYPE_TIDRANGESCAN) != 0);
 
    sscan->rs_rd->rd_tableam->scan_rescan(sscan, NULL, false, false, false, false);
    sscan->rs_rd->rd_tableam->scan_set_tidrange(sscan, mintid, maxtid);
}

References Assert, fb(), and SO_TYPE_TIDRANGESCAN.

Referenced by TidRangeNext().

table_scan_analyze_next_block()

static bool table_scan_analyze_next_block ( TableScanDesc  scan, ReadStream *  stream  )

inlinestatic

Definition at line 1701 of file tableam.h.

{
    return scan->rs_rd->rd_tableam->scan_analyze_next_block(scan, stream);
}

References RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_analyze_next_block.

Referenced by acquire_sample_rows().

table_scan_analyze_next_tuple()

static bool table_scan_analyze_next_tuple ( TableScanDesc  scan, TransactionId  OldestXmin, double *  liverows, double *  deadrows, TupleTableSlot *  slot  )

inlinestatic

Definition at line 1717 of file tableam.h.

{
    return scan->rs_rd->rd_tableam->scan_analyze_next_tuple(scan, OldestXmin,
                                                            liverows, deadrows,
                                                            slot);
}

References fb(), RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_analyze_next_tuple.

Referenced by acquire_sample_rows().

table_scan_bitmap_next_tuple()

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

inlinestatic

Definition at line 1944 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_scan_bitmap_next_tuple with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_scan_bitmap_next_tuple call during logical decoding");
 
    return scan->rs_rd->rd_tableam->scan_bitmap_next_tuple(scan,
                                                           slot,
                                                           recheck,
                                                           lossy_pages,
                                                           exact_pages);
}

References bsysscan, CheckXidAlive, elog, ERROR, RelationData::rd_tableam, TableScanDescData::rs_rd, TableAmRoutine::scan_bitmap_next_tuple, TransactionIdIsValid, and unlikely.

Referenced by BitmapHeapNext().

table_scan_getnextslot()

static bool table_scan_getnextslot ( TableScanDesc  sscan, ScanDirection  direction, TupleTableSlot *  slot  )

inlinestatic

Definition at line 1020 of file tableam.h.

{
    slot->tts_tableOid = RelationGetRelid(sscan->rs_rd);
 
    /* We don't expect actual scans using NoMovementScanDirection */
    Assert(direction == ForwardScanDirection ||
           direction == BackwardScanDirection);
 
    /*
     * We don't expect direct calls to table_scan_getnextslot with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_scan_getnextslot call during logical decoding");
 
    return sscan->rs_rd->rd_tableam->scan_getnextslot(sscan, direction, slot);
}

References Assert, BackwardScanDirection, bsysscan, CheckXidAlive, elog, ERROR, fb(), ForwardScanDirection, RelationGetRelid, TransactionIdIsValid, TupleTableSlot::tts_tableOid, and unlikely.

Referenced by ATRewriteTable(), check_default_partition_contents(), CopyRelationTo(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), MergePartitionsMoveRows(), RelationFindDeletedTupleInfoSeq(), RelationFindReplTupleSeq(), SeqNext(), SplitPartitionMoveRows(), systable_getnext(), validateDomainCheckConstraint(), validateDomainNotNullConstraint(), and validateForeignKeyConstraint().

table_scan_getnextslot_tidrange()

static bool table_scan_getnextslot_tidrange ( TableScanDesc  sscan, ScanDirection  direction, TupleTableSlot *  slot  )

inlinestatic

Definition at line 1086 of file tableam.h.

{
    /* Ensure table_beginscan_tidrange() was used. */
    Assert((sscan->rs_flags & SO_TYPE_TIDRANGESCAN) != 0);
 
    /* We don't expect actual scans using NoMovementScanDirection */
    Assert(direction == ForwardScanDirection ||
           direction == BackwardScanDirection);
 
    return sscan->rs_rd->rd_tableam->scan_getnextslot_tidrange(sscan,
                                                               direction,
                                                               slot);
}

References Assert, BackwardScanDirection, fb(), ForwardScanDirection, and SO_TYPE_TIDRANGESCAN.

Referenced by TidRangeNext().

table_scan_sample_next_block()

static bool table_scan_sample_next_block ( TableScanDesc  scan, SampleScanState *  scanstate  )

inlinestatic

Definition at line 1975 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_scan_sample_next_block with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_scan_sample_next_block call during logical decoding");
    return scan->rs_rd->rd_tableam->scan_sample_next_block(scan, scanstate);
}

References bsysscan, CheckXidAlive, elog, ERROR, fb(), RelationData::rd_tableam, TableScanDescData::rs_rd, TableAmRoutine::scan_sample_next_block, TransactionIdIsValid, and unlikely.

Referenced by tablesample_getnext().

table_scan_sample_next_tuple()

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

inlinestatic

Definition at line 1997 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_scan_sample_next_tuple with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_scan_sample_next_tuple call during logical decoding");
    return scan->rs_rd->rd_tableam->scan_sample_next_tuple(scan, scanstate,
                                                           slot);
}

References bsysscan, CheckXidAlive, elog, ERROR, fb(), RelationData::rd_tableam, TableScanDescData::rs_rd, TableAmRoutine::scan_sample_next_tuple, TransactionIdIsValid, and unlikely.

Referenced by tablesample_getnext().

table_slot_callbacks()

const TupleTableSlotOps * table_slot_callbacks ( Relation  relation )

extern

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  )

extern

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

static void table_tuple_complete_speculative ( Relation  rel, TupleTableSlot *  slot, uint32  specToken, bool  succeeded  )

inlinestatic

Definition at line 1410 of file tableam.h.

{
    rel->rd_tableam->tuple_complete_speculative(rel, slot, specToken,
                                                succeeded);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::tuple_complete_speculative.

Referenced by ExecInsert().

table_tuple_delete()

static TM_Result table_tuple_delete ( Relation  rel, ItemPointer  tid, CommandId  cid, Snapshot  snapshot, Snapshot  crosscheck, bool  wait, TM_FailureData *  tmfd, bool  changingPart  )

inlinestatic

Definition at line 1467 of file tableam.h.

{
    return rel->rd_tableam->tuple_delete(rel, tid, cid,
                                         snapshot, crosscheck,
                                         wait, tmfd, changingPart);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::tuple_delete.

Referenced by ExecDeleteAct(), and simple_table_tuple_delete().

table_tuple_fetch_row_version()

static bool table_tuple_fetch_row_version ( Relation  rel, ItemPointer  tid, Snapshot  snapshot, TupleTableSlot *  slot  )

inlinestatic

Definition at line 1263 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_tuple_fetch_row_version with
     * valid CheckXidAlive for catalog or regular tables.  See detailed
     * comments in xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_tuple_fetch_row_version call during logical decoding");
 
    return rel->rd_tableam->tuple_fetch_row_version(rel, tid, snapshot, slot);
}

References bsysscan, CheckXidAlive, elog, ERROR, RelationData::rd_tableam, TransactionIdIsValid, TableAmRoutine::tuple_fetch_row_version, and unlikely.

Referenced by AfterTriggerExecute(), EvalPlanQualFetchRowMark(), ExecCheckTIDVisible(), ExecCrossPartitionUpdate(), ExecDelete(), ExecMergeMatched(), ExecModifyTable(), ExecUpdate(), GetTupleForTrigger(), heap_entry_is_visible(), and TidNext().

table_tuple_get_latest_tid()

void table_tuple_get_latest_tid ( TableScanDesc  scan, ItemPointer  tid  )

extern

Definition at line 267 of file tableam.c.

{
    Relation    rel = scan->rs_rd;
    const TableAmRoutine *tableam = rel->rd_tableam;
 
    /*
     * We don't expect direct calls to table_tuple_get_latest_tid with valid
     * CheckXidAlive for catalog or regular tables.  See detailed comments in
     * xact.c where these variables are declared.
     */
    if (unlikely(TransactionIdIsValid(CheckXidAlive) && !bsysscan))
        elog(ERROR, "unexpected table_tuple_get_latest_tid call during logical decoding");
 
    /*
     * 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 bsysscan, CheckXidAlive, elog, ereport, errcode(), errmsg(), ERROR, fb(), ItemPointerGetBlockNumberNoCheck(), ItemPointerGetOffsetNumberNoCheck(), RelationData::rd_tableam, RelationGetRelationName, TableScanDescData::rs_rd, TransactionIdIsValid, TableAmRoutine::tuple_get_latest_tid, TableAmRoutine::tuple_tid_valid, and unlikely.

Referenced by currtid_internal(), and TidNext().

table_tuple_insert()

static void table_tuple_insert ( Relation  rel, TupleTableSlot *  slot, CommandId  cid, int  options, BulkInsertStateData *  bistate  )

inlinestatic

Definition at line 1377 of file tableam.h.

{
    rel->rd_tableam->tuple_insert(rel, slot, cid, options,
                                  bistate);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::tuple_insert.

Referenced by ATRewriteTable(), CopyFrom(), ExecInsert(), intorel_receive(), MergePartitionsMoveRows(), simple_table_tuple_insert(), SplitPartitionMoveRows(), and transientrel_receive().

table_tuple_insert_speculative()

static void table_tuple_insert_speculative ( Relation  rel, TupleTableSlot *  slot, CommandId  cid, int  options, BulkInsertStateData *  bistate, uint32  specToken  )

inlinestatic

Definition at line 1396 of file tableam.h.

{
    rel->rd_tableam->tuple_insert_speculative(rel, slot, cid, options,
                                              bistate, specToken);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::tuple_insert_speculative.

Referenced by ExecInsert().

table_tuple_lock()

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

inlinestatic

Definition at line 1559 of file tableam.h.

{
    return rel->rd_tableam->tuple_lock(rel, tid, snapshot, slot,
                                       cid, mode, wait_policy,
                                       flags, tmfd);
}

References fb(), mode, RelationData::rd_tableam, and TableAmRoutine::tuple_lock.

Referenced by ExecDelete(), ExecLockRows(), ExecMergeMatched(), ExecOnConflictUpdate(), ExecUpdate(), FindConflictTuple(), GetTupleForTrigger(), RelationFindReplTupleByIndex(), and RelationFindReplTupleSeq().

table_tuple_satisfies_snapshot()

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

inlinestatic

Definition at line 1310 of file tableam.h.

{
    return rel->rd_tableam->tuple_satisfies_snapshot(rel, slot, snapshot);
}

References RelationData::rd_tableam, and TableAmRoutine::tuple_satisfies_snapshot.

Referenced by ExecCheckTupleVisible(), RI_FKey_check(), and systable_recheck_tuple().

table_tuple_tid_valid()

static bool table_tuple_tid_valid ( TableScanDesc  scan, ItemPointer  tid  )

inlinestatic

Definition at line 1289 of file tableam.h.

{
    return scan->rs_rd->rd_tableam->tuple_tid_valid(scan, tid);
}

References RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::tuple_tid_valid.

Referenced by TidListEval().

table_tuple_update()

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

inlinestatic

Definition at line 1512 of file tableam.h.

{
    return rel->rd_tableam->tuple_update(rel, otid, slot,
                                         cid, snapshot, crosscheck,
                                         wait, tmfd,
                                         lockmode, update_indexes);
}

References fb(), RelationData::rd_tableam, and TableAmRoutine::tuple_update.

Referenced by ExecUpdateAct(), and simple_table_tuple_update().

Variable Documentation

default_table_access_method

PGDLLIMPORT char* default_table_access_method

extern

Definition at line 49 of file tableam.c.

Referenced by ATPrepSetAccessMethod(), and DefineRelation().

synchronize_seqscans

PGDLLIMPORT bool synchronize_seqscans

extern

Definition at line 50 of file tableam.c.

Referenced by initscan(), and table_block_parallelscan_initialize().