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"
dimensions() -> Option<(usize, usize)>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
as_base(&self) -> &ArgWithDisplay<'b, 'c>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
new( w: &'a mut Write, next_line_help: bool, hide_pv: bool, color: bool, cizer: Colorizer, term_w: Option<usize>, max_w: Option<usize>, use_long: bool, ) -> Self104 /*
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,
write_app_help(w: &'a mut Write, app: &App, use_long: bool) -> ClapResult<()>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,
write_parser_help(w: &'a mut Write, parser: &Parser, use_long: bool) -> ClapResult<()>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,
write_parser_help_to_stderr(w: &'a mut Write, parser: &Parser) -> ClapResult<()>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
_write_parser_help( w: &'a mut Write, parser: &Parser, stderr: bool, use_long: bool, ) -> ClapResult<()>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);
write_help(&mut self, parser: &Parser) -> ClapResult<()>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);
write_args_unsorted<'b: 'd, 'c: 'd, 'd, I: 'd>(&mut self, args: I) -> io::Result<()> where I: Iterator<Item = &'d ArgWithOrder<'b, 'c>>,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