tableam.h File Reference

#include "access/relscan.h"
#include "access/sdir.h"
#include "access/xact.h"
#include "executor/tuptable.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 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, struct ScanKeyData *key)
TableScanDesc	table_beginscan_catalog (Relation relation, int nkeys, struct ScanKeyData *key)
static TableScanDesc	table_beginscan_strat (Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key, bool allow_strat, bool allow_sync)
static TableScanDesc	table_beginscan_bm (Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key)
static TableScanDesc	table_beginscan_sampling (Relation rel, Snapshot snapshot, int nkeys, struct 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, struct ScanKeyData *key)
static void	table_rescan_set_params (TableScanDesc scan, struct ScanKeyData *key, bool allow_strat, bool allow_sync, bool allow_pagemode)
void	table_scan_update_snapshot (TableScanDesc scan, Snapshot snapshot)
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)
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, struct BulkInsertStateData *bistate)
static void	table_tuple_insert_speculative (Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct 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, struct 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, struct VacuumParams *params, BufferAccessStrategy bstrategy)
static bool	table_scan_analyze_next_block (TableScanDesc scan, BlockNumber blockno, BufferAccessStrategy bstrategy)
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, struct 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, struct 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, struct IndexInfo *index_info, Snapshot snapshot, struct 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_block (TableScanDesc scan, struct TBMIterateResult *tbmres)
static bool	table_scan_bitmap_next_tuple (TableScanDesc scan, struct TBMIterateResult *tbmres, TupleTableSlot *slot)
static bool	table_scan_sample_next_block (TableScanDesc scan, struct SampleScanState *scanstate)
static bool	table_scan_sample_next_tuple (TableScanDesc scan, struct 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)
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 28 of file tableam.h.

TABLE_INSERT_FROZEN

#define TABLE_INSERT_FROZEN   0x0004

Definition at line 253 of file tableam.h.

TABLE_INSERT_NO_LOGICAL

#define TABLE_INSERT_NO_LOGICAL   0x0008

Definition at line 254 of file tableam.h.

TABLE_INSERT_SKIP_FSM

#define TABLE_INSERT_SKIP_FSM   0x0002

Definition at line 252 of file tableam.h.

TUPLE_LOCK_FLAG_FIND_LAST_VERSION

#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION   (1 << 1)

Definition at line 260 of file tableam.h.

TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS

#define TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS   (1 << 0)

Definition at line 258 of file tableam.h.

Typedef Documentation

IndexBuildCallback

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

Definition at line 264 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

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 45 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 71 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 109 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

)

Definition at line 2609 of file heapam_handler.c.

{
    return &heapam_methods;
}

References heapam_methods.

Referenced by formrdesc(), and heap_getnext().

GetTableAmRoutine()

const TableAmRoutine* GetTableAmRoutine

(

Oid

amhandler

)

Definition at line 35 of file tableamapi.c.

{
    Datum       datum;
    const TableAmRoutine *routine;
 
    datum = OidFunctionCall0(amhandler);
    routine = (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);
 
    /* optional, but one callback implies presence of the other */
    Assert((routine->scan_bitmap_next_block == NULL) ==
           (routine->scan_bitmap_next_tuple == NULL));
    Assert(routine->scan_sample_next_block != NULL);
    Assert(routine->scan_sample_next_tuple != NULL);
 
    return routine;
}

References Assert(), DatumGetPointer(), elog(), ERROR, 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_bitmap_next_block, TableAmRoutine::scan_bitmap_next_tuple, 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
	)

Definition at line 300 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 286 of file tableam.c.

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

References 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 345 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, 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, struct ScanKeyData *  key  )

inlinestatic

Definition at line 901 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 sort-test::key, RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, and SO_TYPE_SEQSCAN.

Referenced by AlterDomainNotNull(), ATRewriteTable(), check_default_partition_contents(), DoCopyTo(), heapam_relation_copy_for_cluster(), pgrowlocks(), RelationFindReplTupleSeq(), SeqNext(), validateDomainConstraint(), and validateForeignKeyConstraint().

table_beginscan_analyze()

static TableScanDesc table_beginscan_analyze ( Relation  rel )

inlinestatic

Definition at line 998 of file tableam.h.

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

References 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, struct ScanKeyData *  key  )

inlinestatic

Definition at line 946 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 sort-test::key, RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, and SO_TYPE_BITMAPSCAN.

Referenced by ExecInitBitmapHeapScan().

table_beginscan_catalog()

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

Definition at line 112 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 GetCatalogSnapshot(), sort-test::key, 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(), GetAllTablesPublicationRelations(), getRelationsInNamespace(), GetSchemaPublicationRelations(), index_update_stats(), 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 175 of file tableam.c.

{
    Snapshot    snapshot;
    uint32      flags = SO_TYPE_SEQSCAN |
        SO_ALLOW_STRAT | SO_ALLOW_SYNC | SO_ALLOW_PAGEMODE;
 
    Assert(RelationGetRelid(relation) == pscan->phs_relid);
 
    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(), ParallelTableScanDescData::phs_relid, ParallelTableScanDescData::phs_snapshot_any, ParallelTableScanDescData::phs_snapshot_off, RelationData::rd_tableam, RegisterSnapshot(), RelationGetRelid, RestoreSnapshot(), TableAmRoutine::scan_begin, SnapshotAny, SO_ALLOW_PAGEMODE, SO_ALLOW_STRAT, SO_ALLOW_SYNC, SO_TEMP_SNAPSHOT, and SO_TYPE_SEQSCAN.

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

table_beginscan_sampling()

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

inlinestatic

Definition at line 962 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 sort-test::key, 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, struct ScanKeyData *  key, bool  allow_strat, bool  allow_sync  )

inlinestatic

Definition at line 925 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 sort-test::key, 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 985 of file tableam.h.

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

References 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 1079 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 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

)

Definition at line 392 of file tableam.c.

{
    return sizeof(ParallelBlockTableScanDescData);
}

table_block_parallelscan_initialize()

Size table_block_parallelscan_initialize	(	Relation	rel,
		ParallelTableScanDesc	pscan
	)

Definition at line 398 of file tableam.c.

{
    ParallelBlockTableScanDesc bpscan = (ParallelBlockTableScanDesc) pscan;
 
    bpscan->base.phs_relid = RelationGetRelid(rel);
    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;
    pg_atomic_init_u64(&bpscan->phs_nallocated, 0);
 
    return sizeof(ParallelBlockTableScanDescData);
}

References ParallelBlockTableScanDescData::base, InvalidBlockNumber, NBuffers, pg_atomic_init_u64(), ParallelBlockTableScanDescData::phs_mutex, ParallelBlockTableScanDescData::phs_nallocated, ParallelBlockTableScanDescData::phs_nblocks, ParallelTableScanDescData::phs_relid, ParallelBlockTableScanDescData::phs_startblock, ParallelTableScanDescData::phs_syncscan, RelationGetNumberOfBlocks, RelationGetRelid, RelationUsesLocalBuffers, SpinLockInit, and synchronize_seqscans.

table_block_parallelscan_nextpage()

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

Definition at line 501 of file tableam.c.

{
    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 size of the relation.  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 rs_nblocks is close
     * to 2^32.
     *
     * The actual block to return is calculated by adding the counter to the
     * starting block number, modulo nblocks.
     */
 
    /*
     * First 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 > pbscan->phs_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;
    }
 
    if (nallocated >= pbscan->phs_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 ParallelBlockTableScanDescData::base, if(), InvalidBlockNumber, PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS, pg_atomic_fetch_add_u64(), ParallelBlockTableScanDescData::phs_nallocated, ParallelBlockTableScanDescData::phs_nblocks, ParallelBlockTableScanDescData::phs_startblock, ParallelTableScanDescData::phs_syncscan, ParallelBlockTableScanWorkerData::phsw_chunk_remaining, ParallelBlockTableScanWorkerData::phsw_chunk_size, ParallelBlockTableScanWorkerData::phsw_nallocated, and ss_report_location().

Referenced by heapgettup_advance_block(), and heapgettup_initial_block().

table_block_parallelscan_reinitialize()

void table_block_parallelscan_reinitialize	(	Relation	rel,
		ParallelTableScanDesc	pscan
	)

Definition at line 416 of file tableam.c.

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

References pg_atomic_write_u64(), and ParallelBlockTableScanDescData::phs_nallocated.

table_block_parallelscan_startblock_init()

void table_block_parallelscan_startblock_init	(	Relation	rel,
		ParallelBlockTableScanWorker	pbscanwork,
		ParallelBlockTableScanDesc	pbscan
	)

Definition at line 431 of file tableam.c.

{
    BlockNumber sync_startpage = InvalidBlockNumber;
 
    /* Reset the state we use for controlling allocation size. */
    memset(pbscanwork, 0, sizeof(*pbscanwork));
 
    StaticAssertStmt(MaxBlockNumber <= 0xFFFFFFFE,
                     "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
 
    /*
     * We determine the chunk size based on the size of the relation. First we
     * split the relation into PARALLEL_SEQSCAN_NCHUNKS chunks but we then
     * take the next highest power of 2 number of the chunk size.  This means
     * we split the relation into somewhere between PARALLEL_SEQSCAN_NCHUNKS
     * and PARALLEL_SEQSCAN_NCHUNKS / 2 chunks.
     */
    pbscanwork->phsw_chunk_size = pg_nextpower2_32(Max(pbscan->phs_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
     * synchronous scan performance.
     */
    pbscanwork->phsw_chunk_size = Min(pbscanwork->phsw_chunk_size,
                                      PARALLEL_SEQSCAN_MAX_CHUNK_SIZE);
 
retry:
    /* Grab the spinlock. */
    SpinLockAcquire(&pbscan->phs_mutex);
 
    /*
     * If the scan's startblock has not yet been initialized, we must do so
     * now.  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 (!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);
}

References ParallelBlockTableScanDescData::base, InvalidBlockNumber, Max, MaxBlockNumber, Min, PARALLEL_SEQSCAN_MAX_CHUNK_SIZE, PARALLEL_SEQSCAN_NCHUNKS, pg_nextpower2_32(), ParallelBlockTableScanDescData::phs_mutex, ParallelBlockTableScanDescData::phs_nblocks, ParallelBlockTableScanDescData::phs_startblock, ParallelTableScanDescData::phs_syncscan, ParallelBlockTableScanWorkerData::phsw_chunk_size, SpinLockAcquire, SpinLockRelease, ss_get_location(), and StaticAssertStmt.

Referenced by heapgettup_initial_block().

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 663 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;
 
        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 / tuple_width;
    }
    *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 get_rel_data_width(), if(), RelationData::rd_rel, and RelationGetNumberOfBlocks.

Referenced by heapam_estimate_rel_size().

table_block_relation_size()

uint64 table_block_relation_size	(	Relation	rel,
		ForkNumber	forkNumber
	)

Definition at line 626 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 i, InvalidForkNumber, MAX_FORKNUM, RelationGetSmgr(), and smgrnblocks().

table_endscan()

static void table_endscan ( TableScanDesc  scan )

inlinestatic

Definition at line 1009 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(), AlterDomainNotNull(), AlterTableMoveAll(), AlterTableSpaceOptions(), ATRewriteTable(), check_db_file_conflict(), check_default_partition_contents(), CreateDatabaseUsingFileCopy(), currtid_internal(), do_autovacuum(), DoCopyTo(), 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(), GetAllTablesPublicationRelations(), getRelationsInNamespace(), GetSchemaPublicationRelations(), heapam_index_build_range_scan(), heapam_index_validate_scan(), heapam_relation_copy_for_cluster(), index_update_stats(), IndexCheckExclusion(), objectsInSchemaToOids(), pgrowlocks(), pgstat_heap(), populate_typ_list(), ReindexMultipleTables(), RelationFindReplTupleSeq(), remove_dbtablespaces(), RemoveSubscriptionRel(), RenameTableSpace(), systable_endscan(), ThereIsAtLeastOneRole(), vac_truncate_clog(), validateDomainConstraint(), and validateForeignKeyConstraint().

table_finish_bulk_insert()

static void table_finish_bulk_insert ( Relation  rel, int  options  )

inlinestatic

Definition at line 1590 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(), intorel_shutdown(), and transientrel_shutdown().

table_index_build_range_scan()

static double table_index_build_range_scan ( Relation  table_rel, Relation  index_rel, struct 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 1805 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(), TableAmRoutine::index_build_range_scan, progress, and RelationData::rd_tableam.

Referenced by summarize_range().

table_index_build_scan()

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

inlinestatic

Definition at line 1772 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(), TableAmRoutine::index_build_range_scan, InvalidBlockNumber, progress, and RelationData::rd_tableam.

Referenced by _bt_parallel_scan_and_sort(), _bt_spools_heapscan(), 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 1351 of file tableam.h.

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

References 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 1187 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(), and table_index_fetch_tuple_check().

table_index_fetch_end()

static void table_index_fetch_end ( struct IndexFetchTableData *  scan )

inlinestatic

Definition at line 1206 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(), and table_index_fetch_tuple_check().

table_index_fetch_reset()

static void table_index_fetch_reset ( struct IndexFetchTableData *  scan )

inlinestatic

Definition at line 1197 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 1236 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, TableAmRoutine::index_fetch_tuple, RelationData::rd_tableam, IndexFetchTableData::rel, TransactionIdIsValid, and unlikely.

Referenced by index_fetch_heap(), and table_index_fetch_tuple_check().

table_index_fetch_tuple_check()

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

Definition at line 218 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(), 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, struct IndexInfo *  index_info, Snapshot  snapshot, struct ValidateIndexState *  state  )

inlinestatic

Definition at line 1836 of file tableam.h.

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

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

Referenced by validate_index().

table_multi_insert()

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

inlinestatic

Definition at line 1452 of file tableam.h.

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

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

Referenced by CopyMultiInsertBufferFlush().

table_parallelscan_estimate()

Size table_parallelscan_estimate	(	Relation	rel,
		Snapshot	snapshot
	)

Definition at line 140 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(), IsMVCCSnapshot, TableAmRoutine::parallelscan_estimate, RelationData::rd_tableam, and SnapshotAny.

Referenced by _bt_parallel_estimate_shared(), and ExecSeqScanEstimate().

table_parallelscan_initialize()

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

Definition at line 155 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(), IsMVCCSnapshot, TableAmRoutine::parallelscan_initialize, ParallelTableScanDescData::phs_snapshot_any, ParallelTableScanDescData::phs_snapshot_off, RelationData::rd_tableam, SerializeSnapshot(), and SnapshotAny.

Referenced by _bt_begin_parallel(), and ExecSeqScanInitializeDSM().

table_parallelscan_reinitialize()

static void table_parallelscan_reinitialize ( Relation  rel, ParallelTableScanDesc  pscan  )

inlinestatic

Definition at line 1169 of file tableam.h.

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

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

Referenced by ExecSeqScanReInitializeDSM().

table_relation_copy_data()

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

inlinestatic

Definition at line 1646 of file tableam.h.

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

References 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 1673 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 RelationData::rd_tableam, and TableAmRoutine::relation_copy_for_cluster.

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 1934 of file tableam.h.

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

References 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 1913 of file tableam.h.

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

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

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 1874 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 1634 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 1616 of file tableam.h.

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

References 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 1865 of file tableam.h.

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

References 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 1884 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, struct VacuumParams *  params, BufferAccessStrategy  bstrategy  )

inlinestatic

Definition at line 1702 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, struct ScanKeyData *  key  )

inlinestatic

Definition at line 1018 of file tableam.h.

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

References sort-test::key, RelationData::rd_tableam, TableScanDescData::rs_rd, and TableAmRoutine::scan_rescan.

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

table_rescan_set_params()

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

inlinestatic

Definition at line 1033 of file tableam.h.

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

References sort-test::key, 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 1100 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(), RelationData::rd_tableam, TableScanDescData::rs_flags, TableScanDescData::rs_rd, TableAmRoutine::scan_rescan, TableAmRoutine::scan_set_tidrange, and SO_TYPE_TIDRANGESCAN.

Referenced by TidRangeNext().

table_scan_analyze_next_block()

static bool table_scan_analyze_next_block ( TableScanDesc  scan, BlockNumber  blockno, BufferAccessStrategy  bstrategy  )

inlinestatic

Definition at line 1717 of file tableam.h.

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

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 1735 of file tableam.h.

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

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

Referenced by acquire_sample_rows().

table_scan_bitmap_next_block()

static bool table_scan_bitmap_next_block ( TableScanDesc  scan, struct TBMIterateResult *  tbmres  )

inlinestatic

Definition at line 1958 of file tableam.h.

{
    /*
     * We don't expect direct calls to table_scan_bitmap_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_bitmap_next_block call during logical decoding");
 
    return scan->rs_rd->rd_tableam->scan_bitmap_next_block(scan,
                                                           tbmres);
}

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

Referenced by BitmapHeapNext().

table_scan_bitmap_next_tuple()

static bool table_scan_bitmap_next_tuple ( TableScanDesc  scan, struct TBMIterateResult *  tbmres, TupleTableSlot *  slot  )

inlinestatic

Definition at line 1982 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,
                                                           tbmres,
                                                           slot);
}

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 1050 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, ForwardScanDirection, RelationData::rd_tableam, RelationGetRelid, TableScanDescData::rs_rd, TableAmRoutine::scan_getnextslot, TransactionIdIsValid, TupleTableSlot::tts_tableOid, and unlikely.

Referenced by AlterDomainNotNull(), ATRewriteTable(), check_default_partition_contents(), DoCopyTo(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), RelationFindReplTupleSeq(), SeqNext(), systable_getnext(), validateDomainConstraint(), and validateForeignKeyConstraint().

table_scan_getnextslot_tidrange()

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

inlinestatic

Definition at line 1116 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, ForwardScanDirection, RelationData::rd_tableam, TableScanDescData::rs_flags, TableScanDescData::rs_rd, TableAmRoutine::scan_getnextslot_tidrange, and SO_TYPE_TIDRANGESCAN.

Referenced by TidRangeNext().

table_scan_sample_next_block()

static bool table_scan_sample_next_block ( TableScanDesc  scan, struct SampleScanState *  scanstate  )

inlinestatic

Definition at line 2009 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, 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, struct SampleScanState *  scanstate, TupleTableSlot *  slot  )

inlinestatic

Definition at line 2031 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, RelationData::rd_tableam, TableScanDescData::rs_rd, TableAmRoutine::scan_sample_next_tuple, TransactionIdIsValid, and unlikely.

Referenced by tablesample_getnext().

table_scan_update_snapshot()

void table_scan_update_snapshot	(	TableScanDesc	scan,
		Snapshot	snapshot
	)

Definition at line 124 of file tableam.c.

{
    Assert(IsMVCCSnapshot(snapshot));
 
    RegisterSnapshot(snapshot);
    scan->rs_snapshot = snapshot;
    scan->rs_flags |= SO_TEMP_SNAPSHOT;
}

References Assert(), IsMVCCSnapshot, RegisterSnapshot(), TableScanDescData::rs_flags, TableScanDescData::rs_snapshot, and SO_TEMP_SNAPSHOT.

Referenced by ExecBitmapHeapInitializeWorker().

table_slot_callbacks()

const TupleTableSlotOps* table_slot_callbacks

(

Relation

relation

)

Definition at line 58 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(), RelationData::rd_rel, RelationData::rd_tableam, TableAmRoutine::slot_callbacks, TTSOpsHeapTuple, and TTSOpsVirtual.

Referenced by ATRewriteTable(), 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 91 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 lappend(), MakeSingleTupleTableSlot(), RelationGetDescr, and table_slot_callbacks().

Referenced by acquire_sample_rows(), AlterDomainNotNull(), apply_handle_tuple_routing(), check_default_partition_contents(), check_exclusion_or_unique_constraint(), CopyFrom(), CopyMultiInsertInfoNextFreeSlot(), DoCopyTo(), EvalPlanQualSlot(), ExecCrossPartitionUpdate(), ExecInitInsertProjection(), ExecInitMerge(), ExecInitMergeTupleSlots(), ExecInitModifyTable(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecInitUpdateProjection(), FindReplTupleInLocalRel(), get_actual_variable_range(), heapam_index_build_range_scan(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), RelationFindReplTupleSeq(), systable_beginscan(), systable_beginscan_ordered(), table_index_fetch_tuple_check(), validateDomainConstraint(), and validateForeignKeyConstraint().

table_tuple_complete_speculative()

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

inlinestatic

Definition at line 1430 of file tableam.h.

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

References 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 1486 of file tableam.h.

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

References 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 1283 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(), and TidNext().

table_tuple_get_latest_tid()

void table_tuple_get_latest_tid	(	TableScanDesc	scan,
		ItemPointer	tid
	)

Definition at line 245 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, 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, struct BulkInsertStateData *  bistate  )

inlinestatic

Definition at line 1397 of file tableam.h.

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

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

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

table_tuple_insert_speculative()

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

inlinestatic

Definition at line 1416 of file tableam.h.

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

References 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 1575 of file tableam.h.

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

References mode, RelationData::rd_tableam, and TableAmRoutine::tuple_lock.

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

table_tuple_satisfies_snapshot()

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

inlinestatic

Definition at line 1330 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 1309 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 1530 of file tableam.h.

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

References 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 48 of file tableam.c.

Referenced by DefineRelation().

synchronize_seqscans

PGDLLIMPORT bool synchronize_seqscans

extern

Definition at line 49 of file tableam.c.

Referenced by initscan(), and table_block_parallelscan_initialize().