1 /*------------------------------------------------------------------------- 2 * 3 * heapam.h 4 * POSTGRES heap access method definitions. 5 * 6 * 7 * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group 8 * Portions Copyright (c) 1994, Regents of the University of California 9 * 10 * src/include/access/heapam.h 11 * 12 *------------------------------------------------------------------------- 13 */ 14 #ifndef HEAPAM_H 15 #define HEAPAM_H 16 17 #include "access/relation.h" /* for backward compatibility */ 18 #include "access/relscan.h" 19 #include "access/sdir.h" 20 #include "access/skey.h" 21 #include "access/table.h" /* for backward compatibility */ 22 #include "access/tableam.h" 23 #include "nodes/lockoptions.h" 24 #include "nodes/primnodes.h" 25 #include "storage/bufpage.h" 26 #include "storage/lockdefs.h" 27 #include "utils/relcache.h" 28 #include "utils/snapshot.h" 29 30 31 /* "options" flag bits for heap_insert */ 32 #define HEAP_INSERT_SKIP_WAL TABLE_INSERT_SKIP_WAL 33 #define HEAP_INSERT_SKIP_FSM TABLE_INSERT_SKIP_FSM 34 #define HEAP_INSERT_FROZEN TABLE_INSERT_FROZEN 35 #define HEAP_INSERT_NO_LOGICAL TABLE_INSERT_NO_LOGICAL 36 #define HEAP_INSERT_SPECULATIVE 0x0010 37 38 typedef struct BulkInsertStateData *BulkInsertState; 39 struct TupleTableSlot; 40 41 #define MaxLockTupleMode LockTupleExclusive 42 43 /* 44 * Descriptor for heap table scans. 45 */ 46 typedef struct HeapScanDescData 47 { 48 TableScanDescData rs_base; /* AM independent part of the descriptor */ 49 50 /* state set up at initscan time */ 51 BlockNumber rs_nblocks; /* total number of blocks in rel */ 52 BlockNumber rs_startblock; /* block # to start at */ 53 BlockNumber rs_numblocks; /* max number of blocks to scan */ 54 /* rs_numblocks is usually InvalidBlockNumber, meaning "scan whole rel" */ 55 56 /* scan current state */ 57 bool rs_inited; /* false = scan not init'd yet */ 58 BlockNumber rs_cblock; /* current block # in scan, if any */ 59 Buffer rs_cbuf; /* current buffer in scan, if any */ 60 /* NB: if rs_cbuf is not InvalidBuffer, we hold a pin on that buffer */ 61 62 /* rs_numblocks is usually InvalidBlockNumber, meaning "scan whole rel" */ 63 BufferAccessStrategy rs_strategy; /* access strategy for reads */ 64 65 HeapTupleData rs_ctup; /* current tuple in scan, if any */ 66 67 /* these fields only used in page-at-a-time mode and for bitmap scans */ 68 int rs_cindex; /* current tuple's index in vistuples */ 69 int rs_ntuples; /* number of visible tuples on page */ 70 OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]; /* their offsets */ 71 } HeapScanDescData; 72 typedef struct HeapScanDescData *HeapScanDesc; 73 74 /* 75 * Descriptor for fetches from heap via an index. 76 */ 77 typedef struct IndexFetchHeapData 78 { 79 IndexFetchTableData xs_base; /* AM independent part of the descriptor */ 80 81 Buffer xs_cbuf; /* current heap buffer in scan, if any */ 82 /* NB: if xs_cbuf is not InvalidBuffer, we hold a pin on that buffer */ 83 } IndexFetchHeapData; 84 85 /* Result codes for HeapTupleSatisfiesVacuum */ 86 typedef enum 87 { 88 HEAPTUPLE_DEAD, /* tuple is dead and deletable */ 89 HEAPTUPLE_LIVE, /* tuple is live (committed, no deleter) */ 90 HEAPTUPLE_RECENTLY_DEAD, /* tuple is dead, but not deletable yet */ 91 HEAPTUPLE_INSERT_IN_PROGRESS, /* inserting xact is still in progress */ 92 HEAPTUPLE_DELETE_IN_PROGRESS /* deleting xact is still in progress */ 93 } HTSV_Result; 94 95 /* ---------------- 96 * function prototypes for heap access method 97 * 98 * heap_create, heap_create_with_catalog, and heap_drop_with_catalog 99 * are declared in catalog/heap.h 100 * ---------------- 101 */ 102 103 104 /* 105 * HeapScanIsValid 106 * True iff the heap scan is valid. 107 */ 108 #define HeapScanIsValid(scan) PointerIsValid(scan) 109 110 extern TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot, 111 int nkeys, ScanKey key, 112 ParallelTableScanDesc parallel_scan, 113 uint32 flags); 114 extern void heap_setscanlimits(TableScanDesc scan, BlockNumber startBlk, 115 BlockNumber endBlk); 116 extern void heapgetpage(TableScanDesc scan, BlockNumber page); 117 extern void heap_rescan(TableScanDesc scan, ScanKey key, bool set_params, 118 bool allow_strat, bool allow_sync, bool allow_pagemode); 119 extern void heap_endscan(TableScanDesc scan); 120 extern HeapTuple heap_getnext(TableScanDesc scan, ScanDirection direction); 121 extern bool heap_getnextslot(TableScanDesc sscan, 122 ScanDirection direction, struct TupleTableSlot *slot); 123 124 extern bool heap_fetch(Relation relation, Snapshot snapshot, 125 HeapTuple tuple, Buffer *userbuf); 126 extern bool heap_hot_search_buffer(ItemPointer tid, Relation relation, 127 Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, 128 bool *all_dead, bool first_call); 129 130 extern void heap_get_latest_tid(TableScanDesc scan, ItemPointer tid); 131 extern void setLastTid(const ItemPointer tid); 132 133 extern BulkInsertState GetBulkInsertState(void); 134 extern void FreeBulkInsertState(BulkInsertState); 135 extern void ReleaseBulkInsertStatePin(BulkInsertState bistate); 136 137 extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid, 138 int options, BulkInsertState bistate); 139 extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots, 140 int ntuples, CommandId cid, int options, 141 BulkInsertState bistate); 142 extern TM_Result heap_delete(Relation relation, ItemPointer tid, 143 CommandId cid, Snapshot crosscheck, bool wait, 144 struct TM_FailureData *tmfd, bool changingPart); 145 extern void heap_finish_speculative(Relation relation, ItemPointer tid); 146 extern void heap_abort_speculative(Relation relation, ItemPointer tid); 147 extern TM_Result heap_update(Relation relation, ItemPointer otid, 148 HeapTuple newtup, 149 CommandId cid, Snapshot crosscheck, bool wait, 150 struct TM_FailureData *tmfd, LockTupleMode *lockmode); 151 extern TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple, 152 CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, 153 bool follow_update, 154 Buffer *buffer, struct TM_FailureData *tmfd); 155 156 extern void heap_inplace_update(Relation relation, HeapTuple tuple); 157 extern bool heap_freeze_tuple(HeapTupleHeader tuple, 158 TransactionId relfrozenxid, TransactionId relminmxid, 159 TransactionId cutoff_xid, TransactionId cutoff_multi); 160 extern bool heap_tuple_needs_freeze(HeapTupleHeader tuple, TransactionId cutoff_xid, 161 MultiXactId cutoff_multi, Buffer buf); 162 extern bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple); 163 164 extern void simple_heap_insert(Relation relation, HeapTuple tup); 165 extern void simple_heap_delete(Relation relation, ItemPointer tid); 166 extern void simple_heap_update(Relation relation, ItemPointer otid, 167 HeapTuple tup); 168 169 extern void heap_sync(Relation relation); 170 171 extern TransactionId heap_compute_xid_horizon_for_tuples(Relation rel, 172 ItemPointerData *items, 173 int nitems); 174 175 /* in heap/pruneheap.c */ 176 extern void heap_page_prune_opt(Relation relation, Buffer buffer); 177 extern int heap_page_prune(Relation relation, Buffer buffer, 178 TransactionId OldestXmin, 179 bool report_stats, TransactionId *latestRemovedXid); 180 extern void heap_page_prune_execute(Buffer buffer, 181 OffsetNumber *redirected, int nredirected, 182 OffsetNumber *nowdead, int ndead, 183 OffsetNumber *nowunused, int nunused); 184 extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets); 185 186 /* in heap/syncscan.c */ 187 extern void ss_report_location(Relation rel, BlockNumber location); 188 extern BlockNumber ss_get_location(Relation rel, BlockNumber relnblocks); 189 extern void SyncScanShmemInit(void); 190 extern Size SyncScanShmemSize(void); 191 192 /* in heap/vacuumlazy.c */ 193 struct VacuumParams; 194 extern void heap_vacuum_rel(Relation onerel, 195 struct VacuumParams *params, BufferAccessStrategy bstrategy); 196 197 /* in heap/heapam_visibility.c */ 198 extern bool HeapTupleSatisfiesVisibility(HeapTuple stup, Snapshot snapshot, 199 Buffer buffer); 200 extern TM_Result HeapTupleSatisfiesUpdate(HeapTuple stup, CommandId curcid, 201 Buffer buffer); 202 extern HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple stup, TransactionId OldestXmin, 203 Buffer buffer); 204 extern void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer, 205 uint16 infomask, TransactionId xid); 206 extern bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple); 207 extern bool XidInMVCCSnapshot(TransactionId xid, Snapshot snapshot); 208 extern bool HeapTupleIsSurelyDead(HeapTuple htup, TransactionId OldestXmin); 209 210 /* 211 * To avoid leaking too much knowledge about reorderbuffer implementation 212 * details this is implemented in reorderbuffer.c not heapam_visibility.c 213 */ 214 struct HTAB; 215 extern bool ResolveCminCmaxDuringDecoding(struct HTAB *tuplecid_data, 216 Snapshot snapshot, 217 HeapTuple htup, 218 Buffer buffer, 219 CommandId *cmin, CommandId *cmax); 220 221 #endif /* HEAPAM_H */ 222