PostgreSQL Source Code  git master
heapam.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * heapam.h
4  * POSTGRES heap access method definitions.
5  *
6  *
7  * Portions Copyright (c) 1996-2023, 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/dsm.h"
27 #include "storage/lockdefs.h"
28 #include "storage/shm_toc.h"
29 #include "utils/relcache.h"
30 #include "utils/snapshot.h"
31 
32 
33 /* "options" flag bits for heap_insert */
34 #define HEAP_INSERT_SKIP_FSM TABLE_INSERT_SKIP_FSM
35 #define HEAP_INSERT_FROZEN TABLE_INSERT_FROZEN
36 #define HEAP_INSERT_NO_LOGICAL TABLE_INSERT_NO_LOGICAL
37 #define HEAP_INSERT_SPECULATIVE 0x0010
38 
40 struct TupleTableSlot;
41 struct VacuumCutoffs;
42 
43 #define MaxLockTupleMode LockTupleExclusive
44 
45 /*
46  * Descriptor for heap table scans.
47  */
48 typedef struct HeapScanDescData
49 {
50  TableScanDescData rs_base; /* AM independent part of the descriptor */
51 
52  /* state set up at initscan time */
53  BlockNumber rs_nblocks; /* total number of blocks in rel */
54  BlockNumber rs_startblock; /* block # to start at */
55  BlockNumber rs_numblocks; /* max number of blocks to scan */
56  /* rs_numblocks is usually InvalidBlockNumber, meaning "scan whole rel" */
57 
58  /* scan current state */
59  bool rs_inited; /* false = scan not init'd yet */
60  OffsetNumber rs_coffset; /* current offset # in non-page-at-a-time mode */
61  BlockNumber rs_cblock; /* current block # in scan, if any */
62  Buffer rs_cbuf; /* current buffer in scan, if any */
63  /* NB: if rs_cbuf is not InvalidBuffer, we hold a pin on that buffer */
64 
65  BufferAccessStrategy rs_strategy; /* access strategy for reads */
66 
67  HeapTupleData rs_ctup; /* current tuple in scan, if any */
68 
69  /*
70  * For parallel scans to store page allocation data. NULL when not
71  * performing a parallel scan.
72  */
74 
75  /* these fields only used in page-at-a-time mode and for bitmap scans */
76  int rs_cindex; /* current tuple's index in vistuples */
77  int rs_ntuples; /* number of visible tuples on page */
81 
82 /*
83  * Descriptor for fetches from heap via an index.
84  */
85 typedef struct IndexFetchHeapData
86 {
87  IndexFetchTableData xs_base; /* AM independent part of the descriptor */
88 
89  Buffer xs_cbuf; /* current heap buffer in scan, if any */
90  /* NB: if xs_cbuf is not InvalidBuffer, we hold a pin on that buffer */
92 
93 /* Result codes for HeapTupleSatisfiesVacuum */
94 typedef enum
95 {
96  HEAPTUPLE_DEAD, /* tuple is dead and deletable */
97  HEAPTUPLE_LIVE, /* tuple is live (committed, no deleter) */
98  HEAPTUPLE_RECENTLY_DEAD, /* tuple is dead, but not deletable yet */
99  HEAPTUPLE_INSERT_IN_PROGRESS, /* inserting xact is still in progress */
100  HEAPTUPLE_DELETE_IN_PROGRESS /* deleting xact is still in progress */
102 
103 /*
104  * heap_prepare_freeze_tuple may request that heap_freeze_execute_prepared
105  * check any tuple's to-be-frozen xmin and/or xmax status using pg_xact
106  */
107 #define HEAP_FREEZE_CHECK_XMIN_COMMITTED 0x01
108 #define HEAP_FREEZE_CHECK_XMAX_ABORTED 0x02
109 
110 /* heap_prepare_freeze_tuple state describing how to freeze a tuple */
111 typedef struct HeapTupleFreeze
112 {
113  /* Fields describing how to process tuple */
118 
119  /* xmin/xmax check flags */
121  /* Page offset number for tuple */
124 
125 /*
126  * State used by VACUUM to track the details of freezing all eligible tuples
127  * on a given heap page.
128  *
129  * VACUUM prepares freeze plans for each page via heap_prepare_freeze_tuple
130  * calls (every tuple with storage gets its own call). This page-level freeze
131  * state is updated across each call, which ultimately determines whether or
132  * not freezing the page is required.
133  *
134  * Aside from the basic question of whether or not freezing will go ahead, the
135  * state also tracks the oldest extant XID/MXID in the table as a whole, for
136  * the purposes of advancing relfrozenxid/relminmxid values in pg_class later
137  * on. Each heap_prepare_freeze_tuple call pushes NewRelfrozenXid and/or
138  * NewRelminMxid back as required to avoid unsafe final pg_class values. Any
139  * and all unfrozen XIDs or MXIDs that remain after VACUUM finishes _must_
140  * have values >= the final relfrozenxid/relminmxid values in pg_class. This
141  * includes XIDs that remain as MultiXact members from any tuple's xmax.
142  *
143  * When 'freeze_required' flag isn't set after all tuples are examined, the
144  * final choice on freezing is made by vacuumlazy.c. It can decide to trigger
145  * freezing based on whatever criteria it deems appropriate. However, it is
146  * recommended that vacuumlazy.c avoid early freezing when freezing does not
147  * enable setting the target page all-frozen in the visibility map afterwards.
148  */
149 typedef struct HeapPageFreeze
150 {
151  /* Is heap_prepare_freeze_tuple caller required to freeze page? */
153 
154  /*
155  * "Freeze" NewRelfrozenXid/NewRelminMxid trackers.
156  *
157  * Trackers used when heap_freeze_execute_prepared freezes, or when there
158  * are zero freeze plans for a page. It is always valid for vacuumlazy.c
159  * to freeze any page, by definition. This even includes pages that have
160  * no tuples with storage to consider in the first place. That way the
161  * 'totally_frozen' results from heap_prepare_freeze_tuple can always be
162  * used in the same way, even when no freeze plans need to be executed to
163  * "freeze the page". Only the "freeze" path needs to consider the need
164  * to set pages all-frozen in the visibility map under this scheme.
165  *
166  * When we freeze a page, we generally freeze all XIDs < OldestXmin, only
167  * leaving behind XIDs that are ineligible for freezing, if any. And so
168  * you might wonder why these trackers are necessary at all; why should
169  * _any_ page that VACUUM freezes _ever_ be left with XIDs/MXIDs that
170  * ratchet back the top-level NewRelfrozenXid/NewRelminMxid trackers?
171  *
172  * It is useful to use a definition of "freeze the page" that does not
173  * overspecify how MultiXacts are affected. heap_prepare_freeze_tuple
174  * generally prefers to remove Multis eagerly, but lazy processing is used
175  * in cases where laziness allows VACUUM to avoid allocating a new Multi.
176  * The "freeze the page" trackers enable this flexibility.
177  */
180 
181  /*
182  * "No freeze" NewRelfrozenXid/NewRelminMxid trackers.
183  *
184  * These trackers are maintained in the same way as the trackers used when
185  * VACUUM scans a page that isn't cleanup locked. Both code paths are
186  * based on the same general idea (do less work for this page during the
187  * ongoing VACUUM, at the cost of having to accept older final values).
188  */
191 
193 
194 /*
195  * Per-page state returned from pruning
196  */
197 typedef struct PruneResult
198 {
199  int ndeleted; /* Number of tuples deleted from the page */
200  int nnewlpdead; /* Number of newly LP_DEAD items */
202 
203 /* ----------------
204  * function prototypes for heap access method
205  *
206  * heap_create, heap_create_with_catalog, and heap_drop_with_catalog
207  * are declared in catalog/heap.h
208  * ----------------
209  */
210 
211 
212 /*
213  * HeapScanIsValid
214  * True iff the heap scan is valid.
215  */
216 #define HeapScanIsValid(scan) PointerIsValid(scan)
217 
218 extern TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot,
219  int nkeys, ScanKey key,
220  ParallelTableScanDesc parallel_scan,
221  uint32 flags);
222 extern void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk,
223  BlockNumber numBlks);
224 extern void heapgetpage(TableScanDesc sscan, BlockNumber block);
225 extern void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params,
226  bool allow_strat, bool allow_sync, bool allow_pagemode);
227 extern void heap_endscan(TableScanDesc sscan);
228 extern HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction);
229 extern bool heap_getnextslot(TableScanDesc sscan,
230  ScanDirection direction, struct TupleTableSlot *slot);
231 extern void heap_set_tidrange(TableScanDesc sscan, ItemPointer mintid,
232  ItemPointer maxtid);
233 extern bool heap_getnextslot_tidrange(TableScanDesc sscan,
234  ScanDirection direction,
235  TupleTableSlot *slot);
236 extern bool heap_fetch(Relation relation, Snapshot snapshot,
237  HeapTuple tuple, Buffer *userbuf, bool keep_buf);
238 extern bool heap_hot_search_buffer(ItemPointer tid, Relation relation,
239  Buffer buffer, Snapshot snapshot, HeapTuple heapTuple,
240  bool *all_dead, bool first_call);
241 
242 extern void heap_get_latest_tid(TableScanDesc sscan, ItemPointer tid);
243 
246 extern void ReleaseBulkInsertStatePin(BulkInsertState bistate);
247 
248 extern void heap_insert(Relation relation, HeapTuple tup, CommandId cid,
249  int options, BulkInsertState bistate);
250 extern void heap_multi_insert(Relation relation, struct TupleTableSlot **slots,
251  int ntuples, CommandId cid, int options,
252  BulkInsertState bistate);
253 extern TM_Result heap_delete(Relation relation, ItemPointer tid,
254  CommandId cid, Snapshot crosscheck, bool wait,
255  struct TM_FailureData *tmfd, bool changingPart);
256 extern void heap_finish_speculative(Relation relation, ItemPointer tid);
257 extern void heap_abort_speculative(Relation relation, ItemPointer tid);
258 extern TM_Result heap_update(Relation relation, ItemPointer otid,
259  HeapTuple newtup,
260  CommandId cid, Snapshot crosscheck, bool wait,
261  struct TM_FailureData *tmfd, LockTupleMode *lockmode,
262  TU_UpdateIndexes *update_indexes);
263 extern TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple,
264  CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy,
265  bool follow_updates,
266  Buffer *buffer, struct TM_FailureData *tmfd);
267 
268 extern void heap_inplace_update(Relation relation, HeapTuple tuple);
270  const struct VacuumCutoffs *cutoffs,
271  HeapPageFreeze *pagefrz,
272  HeapTupleFreeze *frz, bool *totally_frozen);
273 extern void heap_freeze_execute_prepared(Relation rel, Buffer buffer,
274  TransactionId snapshotConflictHorizon,
275  HeapTupleFreeze *tuples, int ntuples);
276 extern bool heap_freeze_tuple(HeapTupleHeader tuple,
277  TransactionId relfrozenxid, TransactionId relminmxid,
278  TransactionId FreezeLimit, TransactionId MultiXactCutoff);
279 extern bool heap_tuple_should_freeze(HeapTupleHeader tuple,
280  const struct VacuumCutoffs *cutoffs,
281  TransactionId *NoFreezePageRelfrozenXid,
282  MultiXactId *NoFreezePageRelminMxid);
284 
285 extern void simple_heap_insert(Relation relation, HeapTuple tup);
286 extern void simple_heap_delete(Relation relation, ItemPointer tid);
287 extern void simple_heap_update(Relation relation, ItemPointer otid,
288  HeapTuple tup, TU_UpdateIndexes *update_indexes);
289 
291  TM_IndexDeleteOp *delstate);
292 
293 /* in heap/pruneheap.c */
294 struct GlobalVisState;
295 extern void heap_page_prune_opt(Relation relation, Buffer buffer);
296 extern void heap_page_prune(Relation relation, Buffer buffer,
297  struct GlobalVisState *vistest,
298  PruneResult *presult,
299  OffsetNumber *off_loc);
300 extern void heap_page_prune_execute(Buffer buffer,
301  OffsetNumber *redirected, int nredirected,
302  OffsetNumber *nowdead, int ndead,
303  OffsetNumber *nowunused, int nunused);
304 extern void heap_get_root_tuples(Page page, OffsetNumber *root_offsets);
305 
306 /* in heap/vacuumlazy.c */
307 struct VacuumParams;
308 extern void heap_vacuum_rel(Relation rel,
309  struct VacuumParams *params, BufferAccessStrategy bstrategy);
310 
311 /* in heap/heapam_visibility.c */
312 extern bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot,
313  Buffer buffer);
315  Buffer buffer);
317  Buffer buffer);
319  TransactionId *dead_after);
320 extern void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer,
321  uint16 infomask, TransactionId xid);
323 extern bool HeapTupleIsSurelyDead(HeapTuple htup,
324  struct GlobalVisState *vistest);
325 
326 /*
327  * To avoid leaking too much knowledge about reorderbuffer implementation
328  * details this is implemented in reorderbuffer.c not heapam_visibility.c
329  */
330 struct HTAB;
332  Snapshot snapshot,
333  HeapTuple htup,
334  Buffer buffer,
335  CommandId *cmin, CommandId *cmax);
336 extern void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple,
337  Buffer buffer, Snapshot snapshot);
338 
339 #endif /* HEAPAM_H */
uint32 BlockNumber
Definition: block.h:31
int Buffer
Definition: buf.h:23
Pointer Page
Definition: bufpage.h:78
unsigned short uint16
Definition: c.h:494
unsigned int uint32
Definition: c.h:495
TransactionId MultiXactId
Definition: c.h:651
unsigned char uint8
Definition: c.h:493
uint32 CommandId
Definition: c.h:655
uint32 TransactionId
Definition: c.h:641
void heap_finish_speculative(Relation relation, ItemPointer tid)
Definition: heapam.c:5635
void heap_insert(Relation relation, HeapTuple tup, CommandId cid, int options, BulkInsertState bistate)
Definition: heapam.c:1817
struct HeapTupleFreeze HeapTupleFreeze
bool heap_fetch(Relation relation, Snapshot snapshot, HeapTuple tuple, Buffer *userbuf, bool keep_buf)
Definition: heapam.c:1345
void HeapTupleSetHintBits(HeapTupleHeader tuple, Buffer buffer, uint16 infomask, TransactionId xid)
bool HeapTupleSatisfiesVisibility(HeapTuple htup, Snapshot snapshot, Buffer buffer)
HTSV_Result HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *dead_after)
struct HeapScanDescData * HeapScanDesc
Definition: heapam.h:80
bool HeapTupleIsSurelyDead(HeapTuple htup, struct GlobalVisState *vistest)
void simple_heap_delete(Relation relation, ItemPointer tid)
Definition: heapam.c:2922
void heap_get_root_tuples(Page page, OffsetNumber *root_offsets)
Definition: pruneheap.c:996
void heap_vacuum_rel(Relation rel, struct VacuumParams *params, BufferAccessStrategy bstrategy)
Definition: vacuumlazy.c:303
void heap_page_prune_opt(Relation relation, Buffer buffer)
Definition: pruneheap.c:96
HTSV_Result
Definition: heapam.h:95
@ HEAPTUPLE_RECENTLY_DEAD
Definition: heapam.h:98
@ HEAPTUPLE_INSERT_IN_PROGRESS
Definition: heapam.h:99
@ HEAPTUPLE_LIVE
Definition: heapam.h:97
@ HEAPTUPLE_DELETE_IN_PROGRESS
Definition: heapam.h:100
@ HEAPTUPLE_DEAD
Definition: heapam.h:96
void heap_endscan(TableScanDesc sscan)
Definition: heapam.c:1053
void heap_rescan(TableScanDesc sscan, ScanKey key, bool set_params, bool allow_strat, bool allow_sync, bool allow_pagemode)
Definition: heapam.c:1016
bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
Definition: heapam.c:7321
bool ResolveCminCmaxDuringDecoding(struct HTAB *tuplecid_data, Snapshot snapshot, HeapTuple htup, Buffer buffer, CommandId *cmin, CommandId *cmax)
void heap_inplace_update(Relation relation, HeapTuple tuple)
Definition: heapam.c:5875
TM_Result heap_delete(Relation relation, ItemPointer tid, CommandId cid, Snapshot crosscheck, bool wait, struct TM_FailureData *tmfd, bool changingPart)
Definition: heapam.c:2506
bool heap_tuple_should_freeze(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
Definition: heapam.c:7376
bool heap_freeze_tuple(HeapTupleHeader tuple, TransactionId relfrozenxid, TransactionId relminmxid, TransactionId FreezeLimit, TransactionId MultiXactCutoff)
Definition: heapam.c:6915
struct HeapPageFreeze HeapPageFreeze
void ReleaseBulkInsertStatePin(BulkInsertState bistate)
Definition: heapam.c:1790
void heap_multi_insert(Relation relation, struct TupleTableSlot **slots, int ntuples, CommandId cid, int options, BulkInsertState bistate)
Definition: heapam.c:2086
HeapTuple heap_getnext(TableScanDesc sscan, ScanDirection direction)
Definition: heapam.c:1086
bool heap_hot_search_buffer(ItemPointer tid, Relation relation, Buffer buffer, Snapshot snapshot, HeapTuple heapTuple, bool *all_dead, bool first_call)
Definition: heapam.c:1465
void simple_heap_update(Relation relation, ItemPointer otid, HeapTuple tup, TU_UpdateIndexes *update_indexes)
Definition: heapam.c:4037
bool heap_getnextslot_tidrange(TableScanDesc sscan, ScanDirection direction, TupleTableSlot *slot)
Definition: heapam.c:1238
void heap_set_tidrange(TableScanDesc sscan, ItemPointer mintid, ItemPointer maxtid)
Definition: heapam.c:1165
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
struct HeapScanDescData HeapScanDescData
void heap_abort_speculative(Relation relation, ItemPointer tid)
Definition: heapam.c:5722
TableScanDesc heap_beginscan(Relation relation, Snapshot snapshot, int nkeys, ScanKey key, ParallelTableScanDesc parallel_scan, uint32 flags)
Definition: heapam.c:931
void heap_freeze_execute_prepared(Relation rel, Buffer buffer, TransactionId snapshotConflictHorizon, HeapTupleFreeze *tuples, int ntuples)
Definition: heapam.c:6664
struct PruneResult PruneResult
void heap_page_prune(Relation relation, Buffer buffer, struct GlobalVisState *vistest, PruneResult *presult, OffsetNumber *off_loc)
Definition: pruneheap.c:213
bool heap_getnextslot(TableScanDesc sscan, ScanDirection direction, struct TupleTableSlot *slot)
Definition: heapam.c:1135
void simple_heap_insert(Relation relation, HeapTuple tup)
Definition: heapam.c:2448
bool heap_prepare_freeze_tuple(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, HeapPageFreeze *pagefrz, HeapTupleFreeze *frz, bool *totally_frozen)
Definition: heapam.c:6361
TM_Result heap_update(Relation relation, ItemPointer otid, HeapTuple newtup, CommandId cid, Snapshot crosscheck, bool wait, struct TM_FailureData *tmfd, LockTupleMode *lockmode, TU_UpdateIndexes *update_indexes)
Definition: heapam.c:2968
TransactionId heap_index_delete_tuples(Relation rel, TM_IndexDeleteOp *delstate)
Definition: heapam.c:7629
bool HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
TM_Result heap_lock_tuple(Relation relation, HeapTuple tuple, CommandId cid, LockTupleMode mode, LockWaitPolicy wait_policy, bool follow_updates, Buffer *buffer, struct TM_FailureData *tmfd)
Definition: heapam.c:4126
TM_Result HeapTupleSatisfiesUpdate(HeapTuple htup, CommandId curcid, Buffer buffer)
struct BulkInsertStateData * BulkInsertState
Definition: heapam.h:39
void heap_get_latest_tid(TableScanDesc sscan, ItemPointer tid)
Definition: heapam.c:1617
void heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlks)
Definition: heapam.c:354
void HeapCheckForSerializableConflictOut(bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
Definition: heapam.c:10139
void heapgetpage(TableScanDesc sscan, BlockNumber block)
Definition: heapam.c:377
struct IndexFetchHeapData IndexFetchHeapData
void FreeBulkInsertState(BulkInsertState)
Definition: heapam.c:1778
void heap_page_prune_execute(Buffer buffer, OffsetNumber *redirected, int nredirected, OffsetNumber *nowdead, int ndead, OffsetNumber *nowunused, int nunused)
Definition: pruneheap.c:797
BulkInsertState GetBulkInsertState(void)
Definition: heapam.c:1761
#define MaxHeapTuplesPerPage
Definition: htup_details.h:572
LockWaitPolicy
Definition: lockoptions.h:37
LockTupleMode
Definition: lockoptions.h:50
uint16 OffsetNumber
Definition: off.h:24
static PgChecksumMode mode
Definition: pg_checksums.c:56
ScanDirection
Definition: sdir.h:25
static HTAB * tuplecid_data
Definition: snapmgr.c:108
Definition: dynahash.c:220
MultiXactId NoFreezePageRelminMxid
Definition: heapam.h:190
TransactionId FreezePageRelfrozenXid
Definition: heapam.h:178
bool freeze_required
Definition: heapam.h:152
MultiXactId FreezePageRelminMxid
Definition: heapam.h:179
TransactionId NoFreezePageRelfrozenXid
Definition: heapam.h:189
int rs_ntuples
Definition: heapam.h:77
BufferAccessStrategy rs_strategy
Definition: heapam.h:65
OffsetNumber rs_coffset
Definition: heapam.h:60
bool rs_inited
Definition: heapam.h:59
Buffer rs_cbuf
Definition: heapam.h:62
ParallelBlockTableScanWorkerData * rs_parallelworkerdata
Definition: heapam.h:73
BlockNumber rs_startblock
Definition: heapam.h:54
HeapTupleData rs_ctup
Definition: heapam.h:67
OffsetNumber rs_vistuples[MaxHeapTuplesPerPage]
Definition: heapam.h:78
BlockNumber rs_numblocks
Definition: heapam.h:55
BlockNumber rs_nblocks
Definition: heapam.h:53
BlockNumber rs_cblock
Definition: heapam.h:61
TableScanDescData rs_base
Definition: heapam.h:50
uint8 frzflags
Definition: heapam.h:117
uint16 t_infomask2
Definition: heapam.h:115
TransactionId xmax
Definition: heapam.h:114
OffsetNumber offset
Definition: heapam.h:122
uint8 checkflags
Definition: heapam.h:120
uint16 t_infomask
Definition: heapam.h:116
Buffer xs_cbuf
Definition: heapam.h:89
IndexFetchTableData xs_base
Definition: heapam.h:87
int nnewlpdead
Definition: heapam.h:200
int ndeleted
Definition: heapam.h:199
TU_UpdateIndexes
Definition: tableam.h:110
TM_Result
Definition: tableam.h:72