PostgreSQL Source Code git master
tableam.h File Reference
#include "access/relscan.h"
#include "access/sdir.h"
#include "access/xact.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 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 , SO_NEED_TUPLES = 1 << 10
}
 
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 TupleTableSlotOpstable_slot_callbacks (Relation relation)
 
TupleTableSlottable_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, bool need_tuple)
 
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)
 
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 IndexFetchTableDatatable_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, 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, 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, BlockNumber *blockno, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages)
 
static bool table_scan_bitmap_next_tuple (TableScanDesc scan, 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 TableAmRoutineGetTableAmRoutine (Oid amhandler)
 
const TableAmRoutineGetHeapamTableAmRoutine (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 29 of file tableam.h.

◆ TABLE_INSERT_FROZEN

#define TABLE_INSERT_FROZEN   0x0004

Definition at line 261 of file tableam.h.

◆ TABLE_INSERT_NO_LOGICAL

#define TABLE_INSERT_NO_LOGICAL   0x0008

Definition at line 262 of file tableam.h.

◆ TABLE_INSERT_SKIP_FSM

#define TABLE_INSERT_SKIP_FSM   0x0002

Definition at line 260 of file tableam.h.

◆ TUPLE_LOCK_FLAG_FIND_LAST_VERSION

#define TUPLE_LOCK_FLAG_FIND_LAST_VERSION   (1 << 1)

Definition at line 268 of file tableam.h.

◆ TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS

#define TUPLE_LOCK_FLAG_LOCK_UPDATE_IN_PROGRESS   (1 << 0)

Definition at line 266 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 272 of file tableam.h.

◆ ScanOptions

typedef enum ScanOptions ScanOptions

◆ TableAmRoutine

◆ TM_FailureData

◆ TM_IndexDelete

◆ TM_IndexDeleteOp

◆ TM_IndexStatus

◆ TM_Result

typedef enum TM_Result TM_Result

◆ TU_UpdateIndexes

Enumeration Type Documentation

◆ 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 
SO_NEED_TUPLES 

Definition at line 45 of file tableam.h.

46{
47 /* one of SO_TYPE_* may be specified */
48 SO_TYPE_SEQSCAN = 1 << 0,
49 SO_TYPE_BITMAPSCAN = 1 << 1,
50 SO_TYPE_SAMPLESCAN = 1 << 2,
51 SO_TYPE_TIDSCAN = 1 << 3,
52 SO_TYPE_TIDRANGESCAN = 1 << 4,
53 SO_TYPE_ANALYZE = 1 << 5,
54
55 /* several of SO_ALLOW_* may be specified */
56 /* allow or disallow use of access strategy */
57 SO_ALLOW_STRAT = 1 << 6,
58 /* report location to syncscan logic? */
59 SO_ALLOW_SYNC = 1 << 7,
60 /* verify visibility page-at-a-time? */
61 SO_ALLOW_PAGEMODE = 1 << 8,
62
63 /* unregister snapshot at scan end? */
64 SO_TEMP_SNAPSHOT = 1 << 9,
65
66 /*
67 * At the discretion of the table AM, bitmap table scans may be able to
68 * skip fetching a block from the table if none of the table data is
69 * needed. If table data may be needed, set SO_NEED_TUPLES.
70 */
71 SO_NEED_TUPLES = 1 << 10,
ScanOptions
Definition: tableam.h:46
@ SO_ALLOW_STRAT
Definition: tableam.h:57
@ SO_TYPE_TIDRANGESCAN
Definition: tableam.h:52
@ SO_TYPE_ANALYZE
Definition: tableam.h:53
@ SO_TEMP_SNAPSHOT
Definition: tableam.h:64
@ SO_TYPE_TIDSCAN
Definition: tableam.h:51
@ SO_NEED_TUPLES
Definition: tableam.h:71
@ SO_ALLOW_PAGEMODE
Definition: tableam.h:61
@ SO_TYPE_SAMPLESCAN
Definition: tableam.h:50
@ SO_ALLOW_SYNC
Definition: tableam.h:59
@ SO_TYPE_SEQSCAN
Definition: tableam.h:48
@ SO_TYPE_BITMAPSCAN
Definition: tableam.h:49

◆ TM_Result

enum TM_Result
Enumerator
TM_Ok 
TM_Invisible 
TM_SelfModified 
TM_Updated 
TM_Deleted 
TM_BeingModified 
TM_WouldBlock 

Definition at line 78 of file tableam.h.

79{
80 /*
81 * Signals that the action succeeded (i.e. update/delete performed, lock
82 * was acquired)
83 */
84 TM_Ok,
85
86 /* The affected tuple wasn't visible to the relevant snapshot */
88
89 /* The affected tuple was already modified by the calling backend */
91
92 /*
93 * The affected tuple was updated by another transaction. This includes
94 * the case where tuple was moved to another partition.
95 */
97
98 /* The affected tuple was deleted by another transaction */
100
101 /*
102 * The affected tuple is currently being modified by another session. This
103 * will only be returned if table_(update/delete/lock_tuple) are
104 * instructed not to wait.
105 */
107
108 /* lock couldn't be acquired, action skipped. Only used by lock_tuple */
110} TM_Result;
TM_Result
Definition: tableam.h:79
@ TM_Ok
Definition: tableam.h:84
@ TM_BeingModified
Definition: tableam.h:106
@ TM_Deleted
Definition: tableam.h:99
@ TM_WouldBlock
Definition: tableam.h:109
@ TM_Updated
Definition: tableam.h:96
@ TM_SelfModified
Definition: tableam.h:90
@ TM_Invisible
Definition: tableam.h:87

◆ TU_UpdateIndexes

Enumerator
TU_None 
TU_All 
TU_Summarizing 

Definition at line 116 of file tableam.h.

117{
118 /* No indexed columns were updated (incl. TID addressing of tuple) */
119 TU_None,
120
121 /* A non-summarizing indexed column was updated, or the TID has changed */
122 TU_All,
123
124 /* Only summarized columns were updated, TID is unchanged */
TU_UpdateIndexes
Definition: tableam.h:117
@ TU_Summarizing
Definition: tableam.h:125
@ TU_All
Definition: tableam.h:122
@ TU_None
Definition: tableam.h:119

Function Documentation

◆ GetHeapamTableAmRoutine()

const TableAmRoutine * GetHeapamTableAmRoutine ( void  )

Definition at line 2685 of file heapam_handler.c.

2686{
2687 return &heapam_methods;
2688}
static const TableAmRoutine heapam_methods

References heapam_methods.

Referenced by formrdesc(), and heap_getnext().

◆ GetTableAmRoutine()

const TableAmRoutine * GetTableAmRoutine ( Oid  amhandler)

Definition at line 28 of file tableamapi.c.

29{
30 Datum datum;
31 const TableAmRoutine *routine;
32
33 datum = OidFunctionCall0(amhandler);
34 routine = (TableAmRoutine *) DatumGetPointer(datum);
35
36 if (routine == NULL || !IsA(routine, TableAmRoutine))
37 elog(ERROR, "table access method handler %u did not return a TableAmRoutine struct",
38 amhandler);
39
40 /*
41 * Assert that all required callbacks are present. That makes it a bit
42 * easier to keep AMs up to date, e.g. when forward porting them to a new
43 * major version.
44 */
45 Assert(routine->scan_begin != NULL);
46 Assert(routine->scan_end != NULL);
47 Assert(routine->scan_rescan != NULL);
48 Assert(routine->scan_getnextslot != NULL);
49
50 Assert(routine->parallelscan_estimate != NULL);
51 Assert(routine->parallelscan_initialize != NULL);
52 Assert(routine->parallelscan_reinitialize != NULL);
53
54 Assert(routine->index_fetch_begin != NULL);
55 Assert(routine->index_fetch_reset != NULL);
56 Assert(routine->index_fetch_end != NULL);
57 Assert(routine->index_fetch_tuple != NULL);
58
59 Assert(routine->tuple_fetch_row_version != NULL);
60 Assert(routine->tuple_tid_valid != NULL);
61 Assert(routine->tuple_get_latest_tid != NULL);
62 Assert(routine->tuple_satisfies_snapshot != NULL);
63 Assert(routine->index_delete_tuples != NULL);
64
65 Assert(routine->tuple_insert != NULL);
66
67 /*
68 * Could be made optional, but would require throwing error during
69 * parse-analysis.
70 */
71 Assert(routine->tuple_insert_speculative != NULL);
72 Assert(routine->tuple_complete_speculative != NULL);
73
74 Assert(routine->multi_insert != NULL);
75 Assert(routine->tuple_delete != NULL);
76 Assert(routine->tuple_update != NULL);
77 Assert(routine->tuple_lock != NULL);
78
79 Assert(routine->relation_set_new_filelocator != NULL);
81 Assert(routine->relation_copy_data != NULL);
82 Assert(routine->relation_copy_for_cluster != NULL);
83 Assert(routine->relation_vacuum != NULL);
84 Assert(routine->scan_analyze_next_block != NULL);
85 Assert(routine->scan_analyze_next_tuple != NULL);
86 Assert(routine->index_build_range_scan != NULL);
87 Assert(routine->index_validate_scan != NULL);
88
89 Assert(routine->relation_size != NULL);
90 Assert(routine->relation_needs_toast_table != NULL);
91
92 Assert(routine->relation_estimate_size != NULL);
93
94 /* optional, but one callback implies presence of the other */
95 Assert((routine->scan_bitmap_next_block == NULL) ==
96 (routine->scan_bitmap_next_tuple == NULL));
97 Assert(routine->scan_sample_next_block != NULL);
98 Assert(routine->scan_sample_next_tuple != NULL);
99
100 return routine;
101}
#define Assert(condition)
Definition: c.h:815
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define OidFunctionCall0(functionId)
Definition: fmgr.h:677
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
uintptr_t Datum
Definition: postgres.h:69
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
Size(* parallelscan_initialize)(Relation rel, ParallelTableScanDesc pscan)
Definition: tableam.h:400
void(* relation_copy_data)(Relation rel, const RelFileLocator *newrlocator)
Definition: tableam.h:624
bool(* scan_sample_next_tuple)(TableScanDesc scan, struct SampleScanState *scanstate, TupleTableSlot *slot)
Definition: tableam.h:877
void(* index_fetch_reset)(struct IndexFetchTableData *data)
Definition: tableam.h:430
void(* tuple_complete_speculative)(Relation rel, TupleTableSlot *slot, uint32 specToken, bool succeeded)
Definition: tableam.h:524
void(* parallelscan_reinitialize)(Relation rel, ParallelTableScanDesc pscan)
Definition: tableam.h:407
void(* tuple_get_latest_tid)(TableScanDesc scan, ItemPointer tid)
Definition: tableam.h:489
void(* 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)
Definition: tableam.h:628
void(* relation_estimate_size)(Relation rel, int32 *attr_widths, BlockNumber *pages, double *tuples, double *allvisfrac)
Definition: tableam.h:772
double(* 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)
Definition: tableam.h:693
TableScanDesc(* scan_begin)(Relation rel, Snapshot snapshot, int nkeys, struct ScanKeyData *key, ParallelTableScanDesc pscan, uint32 flags)
Definition: tableam.h:328
bool(* relation_needs_toast_table)(Relation rel)
Definition: tableam.h:736
bool(* scan_bitmap_next_block)(TableScanDesc scan, BlockNumber *blockno, bool *recheck, uint64 *lossy_pages, uint64 *exact_pages)
Definition: tableam.h:820
bool(* tuple_tid_valid)(TableScanDesc scan, ItemPointer tid)
Definition: tableam.h:482
void(* multi_insert)(Relation rel, TupleTableSlot **slots, int nslots, CommandId cid, int options, struct BulkInsertStateData *bistate)
Definition: tableam.h:530
bool(* scan_bitmap_next_tuple)(TableScanDesc scan, TupleTableSlot *slot)
Definition: tableam.h:833
void(* scan_end)(TableScanDesc scan)
Definition: tableam.h:338
uint64(* relation_size)(Relation rel, ForkNumber forkNumber)
Definition: tableam.h:726
TM_Result(* tuple_lock)(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, uint8 flags, TM_FailureData *tmfd)
Definition: tableam.h:556
bool(* scan_sample_next_block)(TableScanDesc scan, struct SampleScanState *scanstate)
Definition: tableam.h:861
void(* relation_nontransactional_truncate)(Relation rel)
Definition: tableam.h:616
TM_Result(* 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)
Definition: tableam.h:544
void(* tuple_insert)(Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct BulkInsertStateData *bistate)
Definition: tableam.h:511
void(* scan_rescan)(TableScanDesc scan, struct ScanKeyData *key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
Definition: tableam.h:344
bool(* tuple_fetch_row_version)(Relation rel, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot)
Definition: tableam.h:474
void(* relation_vacuum)(Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: tableam.h:654
bool(* scan_analyze_next_block)(TableScanDesc scan, ReadStream *stream)
Definition: tableam.h:675
Size(* parallelscan_estimate)(Relation rel)
Definition: tableam.h:393
void(* relation_set_new_filelocator)(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
Definition: tableam.h:602
struct IndexFetchTableData *(* index_fetch_begin)(Relation rel)
Definition: tableam.h:424
bool(* scan_analyze_next_tuple)(TableScanDesc scan, TransactionId OldestXmin, double *liverows, double *deadrows, TupleTableSlot *slot)
Definition: tableam.h:686
TransactionId(* index_delete_tuples)(Relation rel, TM_IndexDeleteOp *delstate)
Definition: tableam.h:501
void(* index_fetch_end)(struct IndexFetchTableData *data)
Definition: tableam.h:435
bool(* index_fetch_tuple)(struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead)
Definition: tableam.h:457
void(* tuple_insert_speculative)(Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct BulkInsertStateData *bistate, uint32 specToken)
Definition: tableam.h:516
TM_Result(* tuple_delete)(Relation rel, ItemPointer tid, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
Definition: tableam.h:534
void(* index_validate_scan)(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, Snapshot snapshot, struct ValidateIndexState *state)
Definition: tableam.h:706
bool(* scan_getnextslot)(TableScanDesc scan, ScanDirection direction, TupleTableSlot *slot)
Definition: tableam.h:351
bool(* tuple_satisfies_snapshot)(Relation rel, TupleTableSlot *slot, Snapshot snapshot)
Definition: tableam.h:496

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

291{
292 TM_Result result;
293 TM_FailureData tmfd;
294
295 result = table_tuple_delete(rel, tid,
297 snapshot, InvalidSnapshot,
298 true /* wait for commit */ ,
299 &tmfd, false /* changingPart */ );
300
301 switch (result)
302 {
303 case TM_SelfModified:
304 /* Tuple was already updated in current command? */
305 elog(ERROR, "tuple already updated by self");
306 break;
307
308 case TM_Ok:
309 /* done successfully */
310 break;
311
312 case TM_Updated:
313 elog(ERROR, "tuple concurrently updated");
314 break;
315
316 case TM_Deleted:
317 elog(ERROR, "tuple concurrently deleted");
318 break;
319
320 default:
321 elog(ERROR, "unrecognized table_tuple_delete status: %u", result);
322 break;
323 }
324}
#define InvalidSnapshot
Definition: snapshot.h:119
static TM_Result table_tuple_delete(Relation rel, ItemPointer tid, CommandId cid, Snapshot snapshot, Snapshot crosscheck, bool wait, TM_FailureData *tmfd, bool changingPart)
Definition: tableam.h:1497
CommandId GetCurrentCommandId(bool used)
Definition: xact.c:828

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

277{
278 table_tuple_insert(rel, slot, GetCurrentCommandId(true), 0, NULL);
279}
static void table_tuple_insert(Relation rel, TupleTableSlot *slot, CommandId cid, int options, struct BulkInsertStateData *bistate)
Definition: tableam.h:1408

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

339{
340 TM_Result result;
341 TM_FailureData tmfd;
342 LockTupleMode lockmode;
343
344 result = table_tuple_update(rel, otid, slot,
346 snapshot, InvalidSnapshot,
347 true /* wait for commit */ ,
348 &tmfd, &lockmode, update_indexes);
349
350 switch (result)
351 {
352 case TM_SelfModified:
353 /* Tuple was already updated in current command? */
354 elog(ERROR, "tuple already updated by self");
355 break;
356
357 case TM_Ok:
358 /* done successfully */
359 break;
360
361 case TM_Updated:
362 elog(ERROR, "tuple concurrently updated");
363 break;
364
365 case TM_Deleted:
366 elog(ERROR, "tuple concurrently deleted");
367 break;
368
369 default:
370 elog(ERROR, "unrecognized table_tuple_update status: %u", result);
371 break;
372 }
373}
LockTupleMode
Definition: lockoptions.h:50
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)
Definition: tableam.h:1541

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

◆ table_beginscan_analyze()

static TableScanDesc table_beginscan_analyze ( Relation  rel)
inlinestatic

Definition at line 1014 of file tableam.h.

1015{
1016 uint32 flags = SO_TYPE_ANALYZE;
1017
1018 return rel->rd_tableam->scan_begin(rel, NULL, 0, NULL, NULL, flags);
1019}

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,
bool  need_tuple 
)
inlinestatic

Definition at line 958 of file tableam.h.

960{
962
963 if (need_tuple)
964 flags |= SO_NEED_TUPLES;
965
966 return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key,
967 NULL, flags);
968}

References sort-test::key, RelationData::rd_tableam, TableAmRoutine::scan_begin, SO_ALLOW_PAGEMODE, SO_NEED_TUPLES, and SO_TYPE_BITMAPSCAN.

Referenced by BitmapTableScanSetup().

◆ table_beginscan_catalog()

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

Definition at line 112 of file tableam.c.

113{
114 uint32 flags = SO_TYPE_SEQSCAN |
116 Oid relid = RelationGetRelid(relation);
118
119 return relation->rd_tableam->scan_begin(relation, snapshot, nkeys, key,
120 NULL, flags);
121}
unsigned int Oid
Definition: postgres_ext.h:32
#define RelationGetRelid(relation)
Definition: rel.h:512
Snapshot GetCatalogSnapshot(Oid relid)
Definition: snapmgr.c:314
Snapshot RegisterSnapshot(Snapshot snapshot)
Definition: snapmgr.c:752

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(), 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 165 of file tableam.c.

166{
167 Snapshot snapshot;
168 uint32 flags = SO_TYPE_SEQSCAN |
170
172
173 if (!pscan->phs_snapshot_any)
174 {
175 /* Snapshot was serialized -- restore it */
176 snapshot = RestoreSnapshot((char *) pscan + pscan->phs_snapshot_off);
177 RegisterSnapshot(snapshot);
178 flags |= SO_TEMP_SNAPSHOT;
179 }
180 else
181 {
182 /* SnapshotAny passed by caller (not serialized) */
183 snapshot = SnapshotAny;
184 }
185
186 return relation->rd_tableam->scan_begin(relation, snapshot, 0, NULL,
187 pscan, flags);
188}
#define RelFileLocatorEquals(locator1, locator2)
Snapshot RestoreSnapshot(char *start_address)
Definition: snapmgr.c:1721
#define SnapshotAny
Definition: snapmgr.h:33
RelFileLocator phs_locator
Definition: relscan.h:82
RelFileLocator rd_locator
Definition: rel.h:57

References Assert, ParallelTableScanDescData::phs_locator, ParallelTableScanDescData::phs_snapshot_any, ParallelTableScanDescData::phs_snapshot_off, 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(), 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 978 of file tableam.h.

982{
984
985 if (allow_strat)
986 flags |= SO_ALLOW_STRAT;
987 if (allow_sync)
988 flags |= SO_ALLOW_SYNC;
989 if (allow_pagemode)
990 flags |= SO_ALLOW_PAGEMODE;
991
992 return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key, NULL, flags);
993}

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

940{
942
943 if (allow_strat)
944 flags |= SO_ALLOW_STRAT;
945 if (allow_sync)
946 flags |= SO_ALLOW_SYNC;
947
948 return rel->rd_tableam->scan_begin(rel, snapshot, nkeys, key, NULL, flags);
949}

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

1002{
1003 uint32 flags = SO_TYPE_TIDSCAN;
1004
1005 return rel->rd_tableam->scan_begin(rel, snapshot, 0, NULL, NULL, flags);
1006}

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

1093{
1094 TableScanDesc sscan;
1096
1097 sscan = rel->rd_tableam->scan_begin(rel, snapshot, 0, NULL, NULL, flags);
1098
1099 /* Set the range of TIDs to scan */
1100 sscan->rs_rd->rd_tableam->scan_set_tidrange(sscan, mintid, maxtid);
1101
1102 return sscan;
1103}
void(* scan_set_tidrange)(TableScanDesc scan, ItemPointer mintid, ItemPointer maxtid)
Definition: tableam.h:372
Relation rs_rd
Definition: relscan.h:36

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

383{
384 return sizeof(ParallelBlockTableScanDescData);
385}
struct ParallelBlockTableScanDescData ParallelBlockTableScanDescData

◆ table_block_parallelscan_initialize()

Size table_block_parallelscan_initialize ( Relation  rel,
ParallelTableScanDesc  pscan 
)

Definition at line 388 of file tableam.c.

389{
391
392 bpscan->base.phs_locator = rel->rd_locator;
394 /* compare phs_syncscan initialization to similar logic in initscan */
397 bpscan->phs_nblocks > NBuffers / 4;
398 SpinLockInit(&bpscan->phs_mutex);
401
402 return sizeof(ParallelBlockTableScanDescData);
403}
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:453
#define InvalidBlockNumber
Definition: block.h:33
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:273
int NBuffers
Definition: globals.c:141
#define RelationUsesLocalBuffers(relation)
Definition: rel.h:644
struct ParallelBlockTableScanDescData * ParallelBlockTableScanDesc
Definition: relscan.h:102
#define SpinLockInit(lock)
Definition: spin.h:57
pg_atomic_uint64 phs_nallocated
Definition: relscan.h:99
ParallelTableScanDescData base
Definition: relscan.h:94
bool synchronize_seqscans
Definition: tableam.c:49

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

◆ table_block_parallelscan_nextpage()

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

Definition at line 491 of file tableam.c.

494{
495 BlockNumber page;
496 uint64 nallocated;
497
498 /*
499 * The logic below allocates block numbers out to parallel workers in a
500 * way that each worker will receive a set of consecutive block numbers to
501 * scan. Earlier versions of this would allocate the next highest block
502 * number to the next worker to call this function. This would generally
503 * result in workers never receiving consecutive block numbers. Some
504 * operating systems would not detect the sequential I/O pattern due to
505 * each backend being a different process which could result in poor
506 * performance due to inefficient or no readahead. To work around this
507 * issue, we now allocate a range of block numbers for each worker and
508 * when they come back for another block, we give them the next one in
509 * that range until the range is complete. When the worker completes the
510 * range of blocks we then allocate another range for it and return the
511 * first block number from that range.
512 *
513 * Here we name these ranges of blocks "chunks". The initial size of
514 * these chunks is determined in table_block_parallelscan_startblock_init
515 * based on the size of the relation. Towards the end of the scan, we
516 * start making reductions in the size of the chunks in order to attempt
517 * to divide the remaining work over all the workers as evenly as
518 * possible.
519 *
520 * Here pbscanwork is local worker memory. phsw_chunk_remaining tracks
521 * the number of blocks remaining in the chunk. When that reaches 0 then
522 * we must allocate a new chunk for the worker.
523 *
524 * phs_nallocated tracks how many blocks have been allocated to workers
525 * already. When phs_nallocated >= rs_nblocks, all blocks have been
526 * allocated.
527 *
528 * Because we use an atomic fetch-and-add to fetch the current value, the
529 * phs_nallocated counter will exceed rs_nblocks, because workers will
530 * still increment the value, when they try to allocate the next block but
531 * all blocks have been allocated already. The counter must be 64 bits
532 * wide because of that, to avoid wrapping around when rs_nblocks is close
533 * to 2^32.
534 *
535 * The actual block to return is calculated by adding the counter to the
536 * starting block number, modulo nblocks.
537 */
538
539 /*
540 * First check if we have any remaining blocks in a previous chunk for
541 * this worker. We must consume all of the blocks from that before we
542 * allocate a new chunk to the worker.
543 */
544 if (pbscanwork->phsw_chunk_remaining > 0)
545 {
546 /*
547 * Give them the next block in the range and update the remaining
548 * number of blocks.
549 */
550 nallocated = ++pbscanwork->phsw_nallocated;
551 pbscanwork->phsw_chunk_remaining--;
552 }
553 else
554 {
555 /*
556 * When we've only got PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS chunks
557 * remaining in the scan, we half the chunk size. Since we reduce the
558 * chunk size here, we'll hit this again after doing
559 * PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS at the new size. After a few
560 * iterations of this, we'll end up doing the last few blocks with the
561 * chunk size set to 1.
562 */
563 if (pbscanwork->phsw_chunk_size > 1 &&
564 pbscanwork->phsw_nallocated > pbscan->phs_nblocks -
566 pbscanwork->phsw_chunk_size >>= 1;
567
568 nallocated = pbscanwork->phsw_nallocated =
570 pbscanwork->phsw_chunk_size);
571
572 /*
573 * Set the remaining number of blocks in this chunk so that subsequent
574 * calls from this worker continue on with this chunk until it's done.
575 */
576 pbscanwork->phsw_chunk_remaining = pbscanwork->phsw_chunk_size - 1;
577 }
578
579 if (nallocated >= pbscan->phs_nblocks)
580 page = InvalidBlockNumber; /* all blocks have been allocated */
581 else
582 page = (nallocated + pbscan->phs_startblock) % pbscan->phs_nblocks;
583
584 /*
585 * Report scan location. Normally, we report the current page number.
586 * When we reach the end of the scan, though, we report the starting page,
587 * not the ending page, just so the starting positions for later scans
588 * doesn't slew backwards. We only report the position at the end of the
589 * scan once, though: subsequent callers will report nothing.
590 */
591 if (pbscan->base.phs_syncscan)
592 {
593 if (page != InvalidBlockNumber)
594 ss_report_location(rel, page);
595 else if (nallocated == pbscan->phs_nblocks)
597 }
598
599 return page;
600}
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:522
uint32 BlockNumber
Definition: block.h:31
uint64_t uint64
Definition: c.h:489
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:76
void ss_report_location(Relation rel, BlockNumber location)
Definition: syncscan.c:289
#define PARALLEL_SEQSCAN_RAMPDOWN_CHUNKS
Definition: tableam.c:43

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

◆ table_block_parallelscan_reinitialize()

void table_block_parallelscan_reinitialize ( Relation  rel,
ParallelTableScanDesc  pscan 
)

Definition at line 406 of file tableam.c.

407{
409
411}
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:485

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

424{
425 BlockNumber sync_startpage = InvalidBlockNumber;
426
427 /* Reset the state we use for controlling allocation size. */
428 memset(pbscanwork, 0, sizeof(*pbscanwork));
429
430 StaticAssertStmt(MaxBlockNumber <= 0xFFFFFFFE,
431 "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
432
433 /*
434 * We determine the chunk size based on the size of the relation. First we
435 * split the relation into PARALLEL_SEQSCAN_NCHUNKS chunks but we then
436 * take the next highest power of 2 number of the chunk size. This means
437 * we split the relation into somewhere between PARALLEL_SEQSCAN_NCHUNKS
438 * and PARALLEL_SEQSCAN_NCHUNKS / 2 chunks.
439 */
440 pbscanwork->phsw_chunk_size = pg_nextpower2_32(Max(pbscan->phs_nblocks /
442
443 /*
444 * Ensure we don't go over the maximum chunk size with larger tables. This
445 * means we may get much more than PARALLEL_SEQSCAN_NCHUNKS for larger
446 * tables. Too large a chunk size has been shown to be detrimental to
447 * synchronous scan performance.
448 */
449 pbscanwork->phsw_chunk_size = Min(pbscanwork->phsw_chunk_size,
451
452retry:
453 /* Grab the spinlock. */
454 SpinLockAcquire(&pbscan->phs_mutex);
455
456 /*
457 * If the scan's startblock has not yet been initialized, we must do so
458 * now. If this is not a synchronized scan, we just start at block 0, but
459 * if it is a synchronized scan, we must get the starting position from
460 * the synchronized scan machinery. We can't hold the spinlock while
461 * doing that, though, so release the spinlock, get the information we
462 * need, and retry. If nobody else has initialized the scan in the
463 * meantime, we'll fill in the value we fetched on the second time
464 * through.
465 */
466 if (pbscan->phs_startblock == InvalidBlockNumber)
467 {
468 if (!pbscan->base.phs_syncscan)
469 pbscan->phs_startblock = 0;
470 else if (sync_startpage != InvalidBlockNumber)
471 pbscan->phs_startblock = sync_startpage;
472 else
473 {
474 SpinLockRelease(&pbscan->phs_mutex);
475 sync_startpage = ss_get_location(rel, pbscan->phs_nblocks);
476 goto retry;
477 }
478 }
479 SpinLockRelease(&pbscan->phs_mutex);
480}
#define MaxBlockNumber
Definition: block.h:35
#define Min(x, y)
Definition: c.h:961
#define Max(x, y)
Definition: c.h:955
#define StaticAssertStmt(condition, errmessage)
Definition: c.h:895
static uint32 pg_nextpower2_32(uint32 num)
Definition: pg_bitutils.h:189
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
BlockNumber ss_get_location(Relation rel, BlockNumber relnblocks)
Definition: syncscan.c:254
#define PARALLEL_SEQSCAN_MAX_CHUNK_SIZE
Definition: tableam.c:45
#define PARALLEL_SEQSCAN_NCHUNKS
Definition: tableam.c:41

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

◆ table_block_relation_estimate_size()

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

Definition at line 653 of file tableam.c.

658{
659 BlockNumber curpages;
660 BlockNumber relpages;
661 double reltuples;
662 BlockNumber relallvisible;
663 double density;
664
665 /* it should have storage, so we can call the smgr */
666 curpages = RelationGetNumberOfBlocks(rel);
667
668 /* coerce values in pg_class to more desirable types */
669 relpages = (BlockNumber) rel->rd_rel->relpages;
670 reltuples = (double) rel->rd_rel->reltuples;
671 relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
672
673 /*
674 * HACK: if the relation has never yet been vacuumed, use a minimum size
675 * estimate of 10 pages. The idea here is to avoid assuming a
676 * newly-created table is really small, even if it currently is, because
677 * that may not be true once some data gets loaded into it. Once a vacuum
678 * or analyze cycle has been done on it, it's more reasonable to believe
679 * the size is somewhat stable.
680 *
681 * (Note that this is only an issue if the plan gets cached and used again
682 * after the table has been filled. What we're trying to avoid is using a
683 * nestloop-type plan on a table that has grown substantially since the
684 * plan was made. Normally, autovacuum/autoanalyze will occur once enough
685 * inserts have happened and cause cached-plan invalidation; but that
686 * doesn't happen instantaneously, and it won't happen at all for cases
687 * such as temporary tables.)
688 *
689 * We test "never vacuumed" by seeing whether reltuples < 0.
690 *
691 * If the table has inheritance children, we don't apply this heuristic.
692 * Totally empty parent tables are quite common, so we should be willing
693 * to believe that they are empty.
694 */
695 if (curpages < 10 &&
696 reltuples < 0 &&
697 !rel->rd_rel->relhassubclass)
698 curpages = 10;
699
700 /* report estimated # pages */
701 *pages = curpages;
702 /* quick exit if rel is clearly empty */
703 if (curpages == 0)
704 {
705 *tuples = 0;
706 *allvisfrac = 0;
707 return;
708 }
709
710 /* estimate number of tuples from previous tuple density */
711 if (reltuples >= 0 && relpages > 0)
712 density = reltuples / (double) relpages;
713 else
714 {
715 /*
716 * When we have no data because the relation was never yet vacuumed,
717 * estimate tuple width from attribute datatypes. We assume here that
718 * the pages are completely full, which is OK for tables but is
719 * probably an overestimate for indexes. Fortunately
720 * get_relation_info() can clamp the overestimate to the parent
721 * table's size.
722 *
723 * Note: this code intentionally disregards alignment considerations,
724 * because (a) that would be gilding the lily considering how crude
725 * the estimate is, (b) it creates platform dependencies in the
726 * default plans which are kind of a headache for regression testing,
727 * and (c) different table AMs might use different padding schemes.
728 */
729 int32 tuple_width;
730 int fillfactor;
731
732 /*
733 * Without reltuples/relpages, we also need to consider fillfactor.
734 * The other branch considers it implicitly by calculating density
735 * from actual relpages/reltuples statistics.
736 */
738
739 tuple_width = get_rel_data_width(rel, attr_widths);
740 tuple_width += overhead_bytes_per_tuple;
741 /* note: integer division is intentional here */
742 density = (usable_bytes_per_page * fillfactor / 100) / tuple_width;
743 }
744 *tuples = rint(density * (double) curpages);
745
746 /*
747 * We use relallvisible as-is, rather than scaling it up like we do for
748 * the pages and tuples counts, on the theory that any pages added since
749 * the last VACUUM are most likely not marked all-visible. But costsize.c
750 * wants it converted to a fraction.
751 */
752 if (relallvisible == 0 || curpages <= 0)
753 *allvisfrac = 0;
754 else if ((double) relallvisible >= curpages)
755 *allvisfrac = 1;
756 else
757 *allvisfrac = (double) relallvisible / curpages;
758}
int32_t int32
Definition: c.h:484
static int fillfactor
Definition: pgbench.c:188
int32 get_rel_data_width(Relation rel, int32 *attr_widths)
Definition: plancat.c:1192
#define RelationGetFillFactor(relation, defaultff)
Definition: rel.h:370
#define HEAP_DEFAULT_FILLFACTOR
Definition: rel.h:356
Form_pg_class rd_rel
Definition: rel.h:111

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

Referenced by heapam_estimate_rel_size().

◆ table_block_relation_size()

uint64 table_block_relation_size ( Relation  rel,
ForkNumber  forkNumber 
)

Definition at line 616 of file tableam.c.

617{
618 uint64 nblocks = 0;
619
620 /* InvalidForkNumber indicates returning the size for all forks */
621 if (forkNumber == InvalidForkNumber)
622 {
623 for (int i = 0; i < MAX_FORKNUM; i++)
624 nblocks += smgrnblocks(RelationGetSmgr(rel), i);
625 }
626 else
627 nblocks = smgrnblocks(RelationGetSmgr(rel), forkNumber);
628
629 return nblocks * BLCKSZ;
630}
int i
Definition: isn.c:72
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:574
@ InvalidForkNumber
Definition: relpath.h:57
#define MAX_FORKNUM
Definition: relpath.h:70
BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:677

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

◆ table_endscan()

◆ table_finish_bulk_insert()

static void table_finish_bulk_insert ( Relation  rel,
int  options 
)
inlinestatic

Definition at line 1601 of file tableam.h.

1602{
1603 /* optional callback */
1604 if (rel->rd_tableam && rel->rd_tableam->finish_bulk_insert)
1606}
void(* finish_bulk_insert)(Relation rel, int options)
Definition: tableam.h:578

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

1825{
1826 return table_rel->rd_tableam->index_build_range_scan(table_rel,
1827 index_rel,
1828 index_info,
1829 allow_sync,
1830 anyvisible,
1831 progress,
1832 start_blockno,
1833 numblocks,
1834 callback,
1835 callback_state,
1836 scan);
1837}
static int progress
Definition: pgbench.c:262
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46

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

1789{
1790 return table_rel->rd_tableam->index_build_range_scan(table_rel,
1791 index_rel,
1792 index_info,
1793 allow_sync,
1794 false,
1795 progress,
1796 0,
1798 callback,
1799 callback_state,
1800 scan);
1801}

References callback(), TableAmRoutine::index_build_range_scan, InvalidBlockNumber, progress, and RelationData::rd_tableam.

Referenced by _brin_parallel_scan_and_build(), _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 1362 of file tableam.h.

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

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

◆ table_index_fetch_end()

static void table_index_fetch_end ( struct IndexFetchTableData scan)
inlinestatic

◆ table_index_fetch_reset()

static void table_index_fetch_reset ( struct IndexFetchTableData scan)
inlinestatic

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

1252{
1253 /*
1254 * We don't expect direct calls to table_index_fetch_tuple with valid
1255 * CheckXidAlive for catalog or regular tables. See detailed comments in
1256 * xact.c where these variables are declared.
1257 */
1259 elog(ERROR, "unexpected table_index_fetch_tuple call during logical decoding");
1260
1261 return scan->rel->rd_tableam->index_fetch_tuple(scan, tid, snapshot,
1262 slot, call_again,
1263 all_dead);
1264}
#define unlikely(x)
Definition: c.h:333
#define TransactionIdIsValid(xid)
Definition: transam.h:41
bool bsysscan
Definition: xact.c:99
TransactionId CheckXidAlive
Definition: xact.c:98

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

212{
214 TupleTableSlot *slot;
215 bool call_again = false;
216 bool found;
217
218 slot = table_slot_create(rel, NULL);
219 scan = table_index_fetch_begin(rel);
220 found = table_index_fetch_tuple(scan, tid, snapshot, slot, &call_again,
221 all_dead);
224
225 return found;
226}
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
Definition: execTuples.c:1441
TupleTableSlot * table_slot_create(Relation relation, List **reglist)
Definition: tableam.c:91
static IndexFetchTableData * table_index_fetch_begin(Relation rel)
Definition: tableam.h:1198
static void table_index_fetch_end(struct IndexFetchTableData *scan)
Definition: tableam.h:1217
static bool table_index_fetch_tuple(struct IndexFetchTableData *scan, ItemPointer tid, Snapshot snapshot, TupleTableSlot *slot, bool *call_again, bool *all_dead)
Definition: tableam.h:1247

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

1850{
1851 table_rel->rd_tableam->index_validate_scan(table_rel,
1852 index_rel,
1853 index_info,
1854 snapshot,
1855 state);
1856}
Definition: regguts.h:323

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

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

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

131{
132 Size sz = 0;
133
134 if (IsMVCCSnapshot(snapshot))
135 sz = add_size(sz, EstimateSnapshotSpace(snapshot));
136 else
137 Assert(snapshot == SnapshotAny);
138
139 sz = add_size(sz, rel->rd_tableam->parallelscan_estimate(rel));
140
141 return sz;
142}
size_t Size
Definition: c.h:562
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size EstimateSnapshotSpace(Snapshot snapshot)
Definition: snapmgr.c:1640
#define IsMVCCSnapshot(snapshot)
Definition: snapmgr.h:55

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

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

◆ table_parallelscan_initialize()

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

Definition at line 145 of file tableam.c.

147{
148 Size snapshot_off = rel->rd_tableam->parallelscan_initialize(rel, pscan);
149
150 pscan->phs_snapshot_off = snapshot_off;
151
152 if (IsMVCCSnapshot(snapshot))
153 {
154 SerializeSnapshot(snapshot, (char *) pscan + pscan->phs_snapshot_off);
155 pscan->phs_snapshot_any = false;
156 }
157 else
158 {
159 Assert(snapshot == SnapshotAny);
160 pscan->phs_snapshot_any = true;
161 }
162}
void SerializeSnapshot(Snapshot snapshot, char *start_address)
Definition: snapmgr.c:1664

References Assert, IsMVCCSnapshot, TableAmRoutine::parallelscan_initialize, ParallelTableScanDescData::phs_snapshot_any, ParallelTableScanDescData::phs_snapshot_off, RelationData::rd_tableam, SerializeSnapshot(), and SnapshotAny.

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

◆ table_parallelscan_reinitialize()

static void table_parallelscan_reinitialize ( Relation  rel,
ParallelTableScanDesc  pscan 
)
inlinestatic

Definition at line 1180 of file tableam.h.

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

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

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

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

1693{
1694 OldTable->rd_tableam->relation_copy_for_cluster(OldTable, NewTable, OldIndex,
1695 use_sort, OldestXmin,
1696 xid_cutoff, multi_cutoff,
1697 num_tuples, tups_vacuumed,
1698 tups_recently_dead);
1699}

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

1946{
1947 rel->rd_tableam->relation_estimate_size(rel, attr_widths, pages, tuples,
1948 allvisfrac);
1949}

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

1925{
1926 toastrel->rd_tableam->relation_fetch_toast_slice(toastrel, valueid,
1927 attrsize,
1928 sliceoffset, slicelength,
1929 result);
1930}
void(* relation_fetch_toast_slice)(Relation toastrel, Oid valueid, int32 attrsize, int32 sliceoffset, int32 slicelength, struct varlena *result)
Definition: tableam.h:750

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

1884{
1885 return rel->rd_tableam->relation_needs_toast_table(rel);
1886}

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

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

1632{
1633 rel->rd_tableam->relation_set_new_filelocator(rel, newrlocator,
1634 persistence, freezeXid,
1635 minmulti);
1636}

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

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

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

1894{
1895 return rel->rd_tableam->relation_toast_am(rel);
1896}
Oid(* relation_toast_am)(Relation rel)
Definition: tableam.h:743

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

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

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

Referenced by vacuum_rel().

◆ table_rescan()

static void table_rescan ( TableScanDesc  scan,
struct ScanKeyData key 
)
inlinestatic

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

1051{
1052 scan->rs_rd->rd_tableam->scan_rescan(scan, key, true,
1053 allow_strat, allow_sync,
1054 allow_pagemode);
1055}

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

1113{
1114 /* Ensure table_beginscan_tidrange() was used. */
1115 Assert((sscan->rs_flags & SO_TYPE_TIDRANGESCAN) != 0);
1116
1117 sscan->rs_rd->rd_tableam->scan_rescan(sscan, NULL, false, false, false, false);
1118 sscan->rs_rd->rd_tableam->scan_set_tidrange(sscan, mintid, maxtid);
1119}
uint32 rs_flags
Definition: relscan.h:64

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,
ReadStream stream 
)
inlinestatic

Definition at line 1728 of file tableam.h.

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

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

1747{
1748 return scan->rs_rd->rd_tableam->scan_analyze_next_tuple(scan, OldestXmin,
1749 liverows, deadrows,
1750 slot);
1751}

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,
BlockNumber blockno,
bool *  recheck,
uint64 lossy_pages,
uint64 exact_pages 
)
inlinestatic

Definition at line 1977 of file tableam.h.

1982{
1983 /*
1984 * We don't expect direct calls to table_scan_bitmap_next_block with valid
1985 * CheckXidAlive for catalog or regular tables. See detailed comments in
1986 * xact.c where these variables are declared.
1987 */
1989 elog(ERROR, "unexpected table_scan_bitmap_next_block call during logical decoding");
1990
1991 return scan->rs_rd->rd_tableam->scan_bitmap_next_block(scan,
1992 blockno, recheck,
1993 lossy_pages,
1994 exact_pages);
1995}

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,
TupleTableSlot slot 
)
inlinestatic

Definition at line 2006 of file tableam.h.

2008{
2009 /*
2010 * We don't expect direct calls to table_scan_bitmap_next_tuple with valid
2011 * CheckXidAlive for catalog or regular tables. See detailed comments in
2012 * xact.c where these variables are declared.
2013 */
2015 elog(ERROR, "unexpected table_scan_bitmap_next_tuple call during logical decoding");
2016
2017 return scan->rs_rd->rd_tableam->scan_bitmap_next_tuple(scan,
2018 slot);
2019}

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

1062{
1063 slot->tts_tableOid = RelationGetRelid(sscan->rs_rd);
1064
1065 /* We don't expect actual scans using NoMovementScanDirection */
1066 Assert(direction == ForwardScanDirection ||
1067 direction == BackwardScanDirection);
1068
1069 /*
1070 * We don't expect direct calls to table_scan_getnextslot with valid
1071 * CheckXidAlive for catalog or regular tables. See detailed comments in
1072 * xact.c where these variables are declared.
1073 */
1075 elog(ERROR, "unexpected table_scan_getnextslot call during logical decoding");
1076
1077 return sscan->rs_rd->rd_tableam->scan_getnextslot(sscan, direction, slot);
1078}
@ BackwardScanDirection
Definition: sdir.h:26
@ ForwardScanDirection
Definition: sdir.h:28
Oid tts_tableOid
Definition: tuptable.h:130

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 ATRewriteTable(), check_default_partition_contents(), DoCopyTo(), heapam_relation_copy_for_cluster(), IndexCheckExclusion(), RelationFindReplTupleSeq(), SeqNext(), 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 1127 of file tableam.h.

1129{
1130 /* Ensure table_beginscan_tidrange() was used. */
1131 Assert((sscan->rs_flags & SO_TYPE_TIDRANGESCAN) != 0);
1132
1133 /* We don't expect actual scans using NoMovementScanDirection */
1134 Assert(direction == ForwardScanDirection ||
1135 direction == BackwardScanDirection);
1136
1137 return sscan->rs_rd->rd_tableam->scan_getnextslot_tidrange(sscan,
1138 direction,
1139 slot);
1140}
bool(* scan_getnextslot_tidrange)(TableScanDesc scan, ScanDirection direction, TupleTableSlot *slot)
Definition: tableam.h:380

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

2033{
2034 /*
2035 * We don't expect direct calls to table_scan_sample_next_block with valid
2036 * CheckXidAlive for catalog or regular tables. See detailed comments in
2037 * xact.c where these variables are declared.
2038 */
2040 elog(ERROR, "unexpected table_scan_sample_next_block call during logical decoding");
2041 return scan->rs_rd->rd_tableam->scan_sample_next_block(scan, scanstate);
2042}

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

2056{
2057 /*
2058 * We don't expect direct calls to table_scan_sample_next_tuple with valid
2059 * CheckXidAlive for catalog or regular tables. See detailed comments in
2060 * xact.c where these variables are declared.
2061 */
2063 elog(ERROR, "unexpected table_scan_sample_next_tuple call during logical decoding");
2064 return scan->rs_rd->rd_tableam->scan_sample_next_tuple(scan, scanstate,
2065 slot);
2066}

References bsysscan, CheckXidAlive, elog, ERROR, 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)

Definition at line 58 of file tableam.c.

59{
60 const TupleTableSlotOps *tts_cb;
61
62 if (relation->rd_tableam)
63 tts_cb = relation->rd_tableam->slot_callbacks(relation);
64 else if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
65 {
66 /*
67 * Historically FDWs expect to store heap tuples in slots. Continue
68 * handing them one, to make it less painful to adapt FDWs to new
69 * versions. The cost of a heap slot over a virtual slot is pretty
70 * small.
71 */
72 tts_cb = &TTSOpsHeapTuple;
73 }
74 else
75 {
76 /*
77 * These need to be supported, as some parts of the code (like COPY)
78 * need to create slots for such relations too. It seems better to
79 * centralize the knowledge that a heap slot is the right thing in
80 * that case here.
81 */
82 Assert(relation->rd_rel->relkind == RELKIND_VIEW ||
83 relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
84 tts_cb = &TTSOpsVirtual;
85 }
86
87 return tts_cb;
88}
const TupleTableSlotOps TTSOpsVirtual
Definition: execTuples.c:84
const TupleTableSlotOps TTSOpsHeapTuple
Definition: execTuples.c:85
const TupleTableSlotOps *(* slot_callbacks)(Relation rel)
Definition: tableam.h:304

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

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

◆ table_slot_create()

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

Definition at line 91 of file tableam.c.

92{
93 const TupleTableSlotOps *tts_cb;
94 TupleTableSlot *slot;
95
96 tts_cb = table_slot_callbacks(relation);
97 slot = MakeSingleTupleTableSlot(RelationGetDescr(relation), tts_cb);
98
99 if (reglist)
100 *reglist = lappend(*reglist, slot);
101
102 return slot;
103}
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
Definition: execTuples.c:1425
List * lappend(List *list, void *datum)
Definition: list.c:339
#define RelationGetDescr(relation)
Definition: rel.h:538
const TupleTableSlotOps * table_slot_callbacks(Relation relation)
Definition: tableam.c:58

References 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(), DoCopyTo(), 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(), RelationFindReplTupleSeq(), systable_beginscan(), systable_beginscan_ordered(), table_index_fetch_tuple_check(), 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 1441 of file tableam.h.

1443{
1444 rel->rd_tableam->tuple_complete_speculative(rel, slot, specToken,
1445 succeeded);
1446}

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

1500{
1501 return rel->rd_tableam->tuple_delete(rel, tid, cid,
1502 snapshot, crosscheck,
1503 wait, tmfd, changingPart);
1504}

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

1298{
1299 /*
1300 * We don't expect direct calls to table_tuple_fetch_row_version with
1301 * valid CheckXidAlive for catalog or regular tables. See detailed
1302 * comments in xact.c where these variables are declared.
1303 */
1305 elog(ERROR, "unexpected table_tuple_fetch_row_version call during logical decoding");
1306
1307 return rel->rd_tableam->tuple_fetch_row_version(rel, tid, snapshot, slot);
1308}

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 
)

Definition at line 235 of file tableam.c.

236{
237 Relation rel = scan->rs_rd;
238 const TableAmRoutine *tableam = rel->rd_tableam;
239
240 /*
241 * We don't expect direct calls to table_tuple_get_latest_tid with valid
242 * CheckXidAlive for catalog or regular tables. See detailed comments in
243 * xact.c where these variables are declared.
244 */
246 elog(ERROR, "unexpected table_tuple_get_latest_tid call during logical decoding");
247
248 /*
249 * Since this can be called with user-supplied TID, don't trust the input
250 * too much.
251 */
252 if (!tableam->tuple_tid_valid(scan, tid))
254 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
255 errmsg("tid (%u, %u) is not valid for relation \"%s\"",
259
260 tableam->tuple_get_latest_tid(scan, tid);
261}
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ereport(elevel,...)
Definition: elog.h:149
static OffsetNumber ItemPointerGetOffsetNumberNoCheck(const ItemPointerData *pointer)
Definition: itemptr.h:114
static BlockNumber ItemPointerGetBlockNumberNoCheck(const ItemPointerData *pointer)
Definition: itemptr.h:93
#define RelationGetRelationName(relation)
Definition: rel.h:546

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

1410{
1411 rel->rd_tableam->tuple_insert(rel, slot, cid, options,
1412 bistate);
1413}

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

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

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

1590{
1591 return rel->rd_tableam->tuple_lock(rel, tid, snapshot, slot,
1592 cid, mode, wait_policy,
1593 flags, tmfd);
1594}
static PgChecksumMode mode
Definition: pg_checksums.c:55

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

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

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

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

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

1545{
1546 return rel->rd_tableam->tuple_update(rel, otid, slot,
1547 cid, snapshot, crosscheck,
1548 wait, tmfd,
1549 lockmode, update_indexes);
1550}

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 ATPrepSetAccessMethod(), and DefineRelation().

◆ synchronize_seqscans

PGDLLIMPORT bool synchronize_seqscans
extern

Definition at line 49 of file tableam.c.

Referenced by initscan(), and table_block_parallelscan_initialize().