MySQL 8.0.31
Source Code Documentation
trx0rec.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1996, 2022, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/trx0rec.h
28 Transaction undo log record
29
30 Created 3/26/1996 Heikki Tuuri
31 *******************************************************/
32
33#ifndef trx0rec_h
34#define trx0rec_h
35
36#include "univ.i"
37
38#include "data0data.h"
39#include "dict0types.h"
40#include "lob0undo.h"
41#include "mtr0mtr.h"
42#include "page0types.h"
43#include "rem0types.h"
44#include "row0log.h"
45#include "row0types.h"
46#include "trx0types.h"
47
48#ifndef UNIV_HOTBACKUP
49#include "que0types.h"
50
51/** Copies the undo record to the heap.
52@param[in] undo_page Undo Page
53@param[in] undo_offset offset of the undo record in the page
54@param[in] heap heap where copied
55@return copy of undo log record */
56static inline trx_undo_rec_t *trx_undo_rec_copy(const page_t *undo_page,
57 uint32_t undo_offset,
58 mem_heap_t *heap);
59
60/** Reads the undo log record type.
61 @return record type */
63 const trx_undo_rec_t *undo_rec); /*!< in: undo log record */
64/** Reads from an undo log record the record compiler info.
65 @return compiler info */
67 const trx_undo_rec_t *undo_rec); /*!< in: undo log record */
68/** Returns true if an undo log record contains an extern storage field.
69 @return true if extern */
71 const trx_undo_rec_t *undo_rec); /*!< in: undo log record */
72/** Reads the undo log record number.
73 @return undo no */
75 const trx_undo_rec_t *undo_rec); /*!< in: undo log record */
76
77/** Reads from an undo log record the table ID
78@param[in] undo_rec Undo log record
79@return the table ID */
81 const trx_undo_rec_t *undo_rec);
82
83/** Builds a row reference from an undo log record.
84 @return pointer to remaining part of undo record */
86 byte *ptr, /*!< in: remaining part of a copy of an undo log
87 record, at the start of the row reference;
88 NOTE that this copy of the undo log record must
89 be preserved as long as the row reference is
90 used, as we do NOT copy the data in the
91 record! */
92 dict_index_t *index, /*!< in: clustered index */
93 dtuple_t **ref, /*!< out, own: row reference */
94 mem_heap_t *heap); /*!< in: memory heap from which the memory
95 needed is allocated */
96/** Reads from an undo log update record the system field values of the old
97 version.
98 @return remaining part of undo log record after reading these values */
100 const byte *ptr, /*!< in: remaining part of undo
101 log record after reading
102 general parameters */
103 trx_id_t *trx_id, /*!< out: trx id */
104 roll_ptr_t *roll_ptr, /*!< out: roll ptr */
105 ulint *info_bits); /*!< out: info bits state */
106
107struct type_cmpl_t;
108
109/** Builds an update vector based on a remaining part of an undo log record.
110@param[in] ptr Remaining part in update undo log record, after reading the row
111reference. NOTE that this copy of the undo log record must be preserved as long
112as the update vector is used, as we do NOT copy the data in the record!
113@param[in] index Clustered index.
114@param[in] type TRX_UNDO_UPD_EXIST_REC, TRX_UNDO_UPD_DEL_REC, or
115TRX_UNDO_DEL_MARK_REC; in the last case, only trx id and roll ptr fields are
116added to the update vector.
117@param[in] trx_id Transaction id from this undo record.
118@param[in] roll_ptr Roll pointer from this undo record.
119@param[in] info_bits Info bits from this undo record.
120@param[in] heap Memory heap from which the memory needed is allocated.
121@param[out] upd Update vector.
122@param[out] lob_undo LOB undo information.
123@param[out] type_cmpl Type compilation info.
124@return remaining part of the record, NULL if an error detected, which
125means that the record is corrupted. */
126byte *trx_undo_update_rec_get_update(const byte *ptr, const dict_index_t *index,
127 ulint type, trx_id_t trx_id,
128 roll_ptr_t roll_ptr, ulint info_bits,
129 mem_heap_t *heap, upd_t **upd,
130 lob::undo_vers_t *lob_undo,
131 type_cmpl_t &type_cmpl);
132
133/** Builds a partial row from an update undo log record, for purge.
134 It contains the columns which occur as ordering in any index of the table.
135 Any missing columns are indicated by col->mtype == DATA_MISSING.
136 @return pointer to remaining part of undo record */
137[[nodiscard]] byte *trx_undo_rec_get_partial_row(
138 const byte *ptr, /*!< in: remaining part in update undo log
139 record of a suitable type, at the start of
140 the stored index columns;
141 NOTE that this copy of the undo log record must
142 be preserved as long as the partial row is
143 used, as we do NOT copy the data in the
144 record! */
145 dict_index_t *index, /*!< in: clustered index */
146 dtuple_t **row, /*!< out, own: partial row */
147 bool ignore_prefix, /*!< in: flag to indicate if we
148 expect blob prefixes in undo. Used
149 only in the assertion. */
150 mem_heap_t *heap); /*!< in: memory heap from which the memory
151 needed is allocated */
152/** Writes information to an undo log about an insert, update, or a delete
153 marking of a clustered index record. This information is used in a rollback of
154 the transaction and in consistent reads that must look to the history of this
155 transaction.
156 @return DB_SUCCESS or error code */
158 ulint flags, /*!< in: if BTR_NO_UNDO_LOG_FLAG bit is
159 set, does nothing */
160 ulint op_type, /*!< in: TRX_UNDO_INSERT_OP or
161 TRX_UNDO_MODIFY_OP */
162 que_thr_t *thr, /*!< in: query thread */
163 dict_index_t *index, /*!< in: clustered index */
164 const dtuple_t *clust_entry, /*!< in: in the case of an insert,
165 index entry to insert into the
166 clustered index, otherwise NULL */
167 const upd_t *update, /*!< in: in the case of an update,
168 the update vector, otherwise NULL */
169 ulint cmpl_info, /*!< in: compiler info on secondary
170 index updates */
171 const rec_t *rec, /*!< in: case of an update or delete
172 marking, the record in the clustered
173 index, otherwise NULL */
174 const ulint *offsets, /*!< in: rec_get_offsets(rec) */
175 roll_ptr_t *roll_ptr); /*!< out: rollback pointer to the
176 inserted undo log record,
177 0 if BTR_NO_UNDO_LOG
178 flag was specified */
179
180/** status bit used for trx_undo_prev_version_build() */
181
182/** TRX_UNDO_PREV_IN_PURGE tells trx_undo_prev_version_build() that it
183is being called purge view and we would like to get the purge record
184even it is in the purge view (in normal case, it will return without
185fetching the purge record */
186constexpr uint32_t TRX_UNDO_PREV_IN_PURGE = 0x1;
187
188/** This tells trx_undo_prev_version_build() to fetch the old value in
189the undo log (which is the after image for an update) */
190constexpr uint32_t TRX_UNDO_GET_OLD_V_VALUE = 0x2;
191
192/** Build a previous version of a clustered index record. The caller must hold
193a latch on the index page of the clustered index record.
194If the vrow passed to this function is not null, then this function will store
195information about virtual columns from the requested version in vrow, unless the
196change did not affect any secondary index nor ordering field of clustered index
197(the change has UPD_NODE_NO_ORD_CHANGE flag) in which case the requested
198information can not be reconstructed from undo log, and the caller may assume
199that the (virtual) columns of secondary index have the same values they have in
200the more recent version (the one `rec` comes from).
201Equivalently, if the vrow is not returned, it is either because it was not
202requested, or not available due to UPD_NODE_NO_ORD_CHANGE.
203Obviously vrow is also not set in case rec is the oldest version in history,
204in which case we also set old_vers to NULL.
205@param[in] index_rec clustered index record in the index tree
206@param[in] index_mtr mtr which contains the latch to index_rec page
207 and purge_view
208@param[in] rec version of a clustered index record
209@param[in] index clustered index
210@param[in,out] offsets rec_get_offsets(rec, index)
211@param[in] heap memory heap from which the memory needed is
212 allocated
213@param[out] old_vers previous version, or NULL if rec is the first
214 inserted version, or if history data has been
215 deleted
216@param[in] v_heap memory heap used to create vrow dtuple if it is
217 not yet created. This heap diffs from "heap"
218 above in that it could be
219 prebuilt->old_vers_heap for selection
220@param[out] vrow virtual column info, if any
221@param[in] v_status status determine if it is going into this
222 function by purge thread or not. And if we read
223 "after image" of undo log has been rebuilt
224@param[in] lob_undo LOB undo information.
225@retval true if previous version was built, or if it was an insert or the table
226has been rebuilt
227@retval false if the previous version is earlier than purge_view, or being
228purged, which means that it may have been removed */
229bool trx_undo_prev_version_build(const rec_t *index_rec, mtr_t *index_mtr,
230 const rec_t *rec, const dict_index_t *index,
231 ulint *offsets, mem_heap_t *heap,
232 rec_t **old_vers, mem_heap_t *v_heap,
233 const dtuple_t **vrow, ulint v_status,
234 lob::undo_vers_t *lob_undo);
235
236#endif /* !UNIV_HOTBACKUP */
237/** Parses a redo log record of adding an undo log record.
238 @return end of log record or NULL */
239byte *trx_undo_parse_add_undo_rec(byte *ptr, /*!< in: buffer */
240 byte *end_ptr, /*!< in: buffer end */
241 page_t *page); /*!< in: page or NULL */
242/** Parses a redo log record of erasing of an undo page end.
243@param[in,out] ptr Buffer.
244@param[in,out] end_ptr Buffer end.
245@param[in,out] page Page or nullptr.
246@param[in,out] mtr MTR or nullptr.
247@return end of log record or nullptr */
248byte *trx_undo_parse_erase_page_end(byte *ptr, byte *end_ptr, page_t *page,
249 mtr_t *mtr);
250
251/** Read from an undo log record a non-virtual column value.
252@param[in,out] ptr pointer to remaining part of the undo record
253@param[in,out] field stored field
254@param[in,out] len length of the field, or UNIV_SQL_NULL
255@param[in,out] orig_len original length of the locally stored part
256of an externally stored column, or 0
257@return remaining part of undo log record after reading these values */
258byte *trx_undo_rec_get_col_val(const byte *ptr, const byte **field, ulint *len,
259 ulint *orig_len);
260
261/** Read virtual column value from undo log
262@param[in] table the table
263@param[in] ptr undo log pointer
264@param[in,out] row the dtuple to fill
265@param[in] in_purge called by purge thread
266@param[in] online true if this is from online DDL log
267@param[in] col_map online rebuild column map
268@param[in,out] heap memory heap to keep value when necessary */
269void trx_undo_read_v_cols(const dict_table_t *table, const byte *ptr,
270 const dtuple_t *row, bool in_purge, bool online,
271 const ulint *col_map, mem_heap_t *heap);
272
273/** Read virtual column index from undo log or online log if the log
274contains such info, and in the undo log case, verify the column is
275still indexed, and output its position
276@param[in] table the table
277@param[in] ptr undo log pointer
278@param[in] first_v_col if this is the first virtual column, which
279 has the version marker
280@param[in,out] is_undo_log this function is used to parse both undo log,
281 and online log for virtual columns. So
282 check to see if this is undo log. When
283 first_v_col is true, is_undo_log is output,
284 when first_v_col is false, is_undo_log is input
285@param[in,out] field_no the column number
286@return remaining part of undo log record after reading these values */
287const byte *trx_undo_read_v_idx(const dict_table_t *table, const byte *ptr,
288 bool first_v_col, bool *is_undo_log,
289 ulint *field_no);
290
291#ifndef UNIV_HOTBACKUP
292
293/* Types of an undo log record: these have to be smaller than 16, as the
294compilation info multiplied by 16 is ORed to this value in an undo log
295record */
296
297/** fresh insert into clustered index */
298constexpr uint32_t TRX_UNDO_INSERT_REC = 11;
299/** update of a non-delete-marked record */
300constexpr uint32_t TRX_UNDO_UPD_EXIST_REC = 12;
301/** update of a delete marked record to a not delete marked record; also the
302fields of the record can change */
303constexpr uint32_t TRX_UNDO_UPD_DEL_REC = 13;
304/* delete marking of a record; fields do not change */
305constexpr uint32_t TRX_UNDO_DEL_MARK_REC = 14;
306/** compilation info is multiplied by this and ORed to the type above */
307constexpr uint32_t TRX_UNDO_CMPL_INFO_MULT = 16;
308/** If this bit is set in type_cmpl, then the undo log record has support for
309 partial update of BLOBs. Also to make the undo log format extensible,
310 introducing a new flag next to the type_cmpl flag. */
311constexpr uint32_t TRX_UNDO_MODIFY_BLOB = 64;
312/* This bit can be ORed to type_cmpl to denote that we updated external storage
313 fields: used by purge to free the external storage */
314constexpr uint32_t TRX_UNDO_UPD_EXTERN = 128;
315
316/** Operation type flags used in trx_undo_report_row_operation */
317constexpr uint32_t TRX_UNDO_INSERT_OP = 1;
318constexpr uint32_t TRX_UNDO_MODIFY_OP = 2;
319
320/** The type and compilation info flag in the undo record for update.
321For easier understanding let the 8 bits be numbered as
3227, 6, 5, 4, 3, 2, 1, 0. */
325
326 const byte *read(const byte *ptr) {
328 return (ptr + 1);
329 }
330
332 /* Get 0-3 */
333 return (m_flag & 0x0F);
334 }
335
337 /* Get bits 5 and 4 */
338 return ((m_flag >> 4) & 0x03);
339 }
340
341 /** Is an LOB updated by this update operation.
342 @return true if LOB is updated, false otherwise. */
344 /* Check if bit 7 is set. */
345 return (m_flag & TRX_UNDO_UPD_EXTERN);
346 }
347
348 /** Does the undo log record contains information about LOB partial
349 update vector.
350 @return true if undo contains LOB update info. */
351 bool is_lob_undo() const {
352 /* Check if bit 6 is set. */
353 return (m_flag & TRX_UNDO_MODIFY_BLOB);
354 }
355
356 private:
357 uint8_t m_flag;
358};
359
360/** Reads from an undo log record the general parameters.
361 @return remaining part of undo log record after reading these values */
363 trx_undo_rec_t *undo_rec, /*!< in: undo log record */
364 ulint *type, /*!< out: undo record type:
365 TRX_UNDO_INSERT_REC, ... */
366 ulint *cmpl_info, /*!< out: compiler info, relevant only
367 for update type records */
368 bool *updated_extern, /*!< out: true if we updated an
369 externally stored fild */
370 undo_no_t *undo_no, /*!< out: undo log record number */
371 table_id_t *table_id, /*!< out: table id */
372 type_cmpl_t &type_cmpl); /*!< out: type compilation info. */
373
374/** Get the max free space of undo log by assuming it's a fresh new page
375and the free space doesn't count for the undo log header too. */
377
378/** Decide if the following undo log record is a multi-value virtual column
379@param[in] undo_rec undo log record
380@return true if this is a multi-value virtual column log, otherwise false */
381bool trx_undo_rec_is_multi_value(const byte *undo_rec);
382
383/** Read from an undo log record of a multi-value virtual column.
384@param[in] ptr pointer to remaining part of the undo record
385@param[in,out] field stored field, nullptr if the col is no longer
386 indexed or existing, in the latter case,
387 this function will only skip the log
388@param[in,out] heap memory heap
389@return remaining part of undo log record after reading these values */
390const byte *trx_undo_rec_get_multi_value(const byte *ptr, dfield_t *field,
391 mem_heap_t *heap);
392#include "trx0rec.ic"
393
394#endif /* !UNIV_HOTBACKUP */
395
396#endif /* trx0rec_h */
int page
Definition: ctype-mb.cc:1235
SQL data field and tuple.
dberr_t
Definition: db0err.h:38
Data dictionary global types.
ib_id_t table_id_t
Table or partition identifier (unique within an InnoDB instance).
Definition: dict0types.h:217
static int flags[50]
Definition: hp_test1.cc:39
Undo logging small changes to BLOBs.
static uint8_t mach_read_from_1(const byte *b)
The following function is used to fetch data from one byte.
Mini-transaction buffer.
static uint update
Definition: myisamlog.cc:90
PT & ref(PT *tp)
Definition: tablespace_impl.cc:358
Index page routines.
byte page_t
Type of the index page.
Definition: page0types.h:151
Query graph global types.
Record manager global types.
byte rec_t
Definition: rem0types.h:40
required string type
Definition: replication_group_member_actions.proto:33
Modification log for online index creation and online table rebuild.
Row operation global types.
Structure for an SQL data field.
Definition: data0data.h:604
Data structure for an index.
Definition: dict0mem.h:1021
Data structure for a database table.
Definition: dict0mem.h:1884
Structure for an SQL data tuple of fields (logical record)
Definition: data0data.h:681
The list of modifications to be applied on LOBs to get older versions.
Definition: lob0undo.h:145
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:299
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:181
Definition: que0que.h:241
The type and compilation info flag in the undo record for update.
Definition: trx0rec.h:323
ulint type_info()
Definition: trx0rec.h:331
uint8_t m_flag
Definition: trx0rec.h:357
ulint cmpl_info()
Definition: trx0rec.h:336
bool is_lob_updated()
Is an LOB updated by this update operation.
Definition: trx0rec.h:343
bool is_lob_undo() const
Does the undo log record contains information about LOB partial update vector.
Definition: trx0rec.h:351
type_cmpl_t()
Definition: trx0rec.h:324
const byte * read(const byte *ptr)
Definition: trx0rec.h:326
Definition: row0upd.h:564
static bool trx_undo_rec_get_extern_storage(const trx_undo_rec_t *undo_rec)
Returns true if an undo log record contains an extern storage field.
bool trx_undo_prev_version_build(const rec_t *index_rec, mtr_t *index_mtr, const rec_t *rec, const dict_index_t *index, ulint *offsets, mem_heap_t *heap, rec_t **old_vers, mem_heap_t *v_heap, const dtuple_t **vrow, ulint v_status, lob::undo_vers_t *lob_undo)
Build a previous version of a clustered index record.
Definition: trx0rec.cc:2435
static undo_no_t trx_undo_rec_get_undo_no(const trx_undo_rec_t *undo_rec)
Reads the undo log record number.
constexpr uint32_t TRX_UNDO_UPD_EXTERN
Definition: trx0rec.h:314
byte * trx_undo_rec_get_row_ref(byte *ptr, dict_index_t *index, dtuple_t **ref, mem_heap_t *heap)
Builds a row reference from an undo log record.
Definition: trx0rec.cc:677
constexpr uint32_t TRX_UNDO_GET_OLD_V_VALUE
This tells trx_undo_prev_version_build() to fetch the old value in the undo log (which is the after i...
Definition: trx0rec.h:190
const byte * trx_undo_read_v_idx(const dict_table_t *table, const byte *ptr, bool first_v_col, bool *is_undo_log, ulint *field_no)
Read virtual column index from undo log or online log if the log contains such info,...
Definition: trx0rec.cc:350
void trx_undo_read_v_cols(const dict_table_t *table, const byte *ptr, const dtuple_t *row, bool in_purge, bool online, const ulint *col_map, mem_heap_t *heap)
Read virtual column value from undo log.
Definition: trx0rec.cc:2656
constexpr uint32_t TRX_UNDO_PREV_IN_PURGE
status bit used for trx_undo_prev_version_build()
Definition: trx0rec.h:186
byte * trx_undo_parse_add_undo_rec(byte *ptr, byte *end_ptr, page_t *page)
Parses a redo log record of adding an undo log record.
Definition: trx0rec.cc:102
byte * trx_undo_update_rec_get_update(const byte *ptr, const dict_index_t *index, ulint type, trx_id_t trx_id, roll_ptr_t roll_ptr, ulint info_bits, mem_heap_t *heap, upd_t **upd, lob::undo_vers_t *lob_undo, type_cmpl_t &type_cmpl)
Builds an update vector based on a remaining part of an undo log record.
Definition: trx0rec.cc:1714
constexpr uint32_t TRX_UNDO_MODIFY_BLOB
If this bit is set in type_cmpl, then the undo log record has support for partial update of BLOBs.
Definition: trx0rec.h:311
static trx_undo_rec_t * trx_undo_rec_copy(const page_t *undo_page, uint32_t undo_offset, mem_heap_t *heap)
Copies the undo record to the heap.
static ulint trx_undo_rec_get_cmpl_info(const trx_undo_rec_t *undo_rec)
Reads from an undo log record the record compiler info.
constexpr uint32_t TRX_UNDO_CMPL_INFO_MULT
compilation info is multiplied by this and ORed to the type above
Definition: trx0rec.h:307
byte * trx_undo_rec_get_pars(trx_undo_rec_t *undo_rec, ulint *type, ulint *cmpl_info, bool *updated_extern, undo_no_t *undo_no, table_id_t *table_id, type_cmpl_t &type_cmpl)
Reads from an undo log record the general parameters.
Definition: trx0rec.cc:549
byte * trx_undo_parse_erase_page_end(byte *ptr, byte *end_ptr, page_t *page, mtr_t *mtr)
Parses a redo log record of erasing of an undo page end.
Definition: trx0rec.cc:2088
dberr_t trx_undo_report_row_operation(ulint flags, ulint op_type, que_thr_t *thr, dict_index_t *index, const dtuple_t *clust_entry, const upd_t *update, ulint cmpl_info, const rec_t *rec, const ulint *offsets, roll_ptr_t *roll_ptr)
Writes information to an undo log about an insert, update, or a delete marking of a clustered index r...
Definition: trx0rec.cc:2105
constexpr uint32_t TRX_UNDO_DEL_MARK_REC
Definition: trx0rec.h:305
constexpr uint32_t TRX_UNDO_INSERT_REC
fresh insert into clustered index
Definition: trx0rec.h:298
byte * trx_undo_rec_get_col_val(const byte *ptr, const byte **field, ulint *len, ulint *orig_len)
Read from an undo log record a non-virtual column value.
Definition: trx0rec.cc:635
byte * trx_undo_rec_get_partial_row(const byte *ptr, dict_index_t *index, dtuple_t **row, bool ignore_prefix, mem_heap_t *heap)
Builds a partial row from an update undo log record, for purge.
Definition: trx0rec.cc:1911
constexpr uint32_t TRX_UNDO_INSERT_OP
Operation type flags used in trx_undo_report_row_operation.
Definition: trx0rec.h:317
static ulint trx_undo_rec_get_type(const trx_undo_rec_t *undo_rec)
Reads the undo log record type.
byte * trx_undo_update_rec_get_sys_cols(const byte *ptr, trx_id_t *trx_id, roll_ptr_t *roll_ptr, ulint *info_bits)
Reads from an undo log update record the system field values of the old version.
Definition: trx0rec.cc:1694
const byte * trx_undo_rec_get_multi_value(const byte *ptr, dfield_t *field, mem_heap_t *heap)
Read from an undo log record of a multi-value virtual column.
Definition: trx0rec.cc:619
constexpr uint32_t TRX_UNDO_UPD_DEL_REC
update of a delete marked record to a not delete marked record; also the fields of the record can cha...
Definition: trx0rec.h:303
table_id_t trx_undo_rec_get_table_id(const trx_undo_rec_t *undo_rec)
Reads from an undo log record the table ID.
Definition: trx0rec.cc:589
bool trx_undo_rec_is_multi_value(const byte *undo_rec)
Decide if the following undo log record is a multi-value virtual column.
Definition: trx0rec.cc:230
constexpr uint32_t TRX_UNDO_MODIFY_OP
Definition: trx0rec.h:318
size_t trx_undo_max_free_space()
Get the max free space of undo log by assuming it's a fresh new page and the free space doesn't count...
Definition: trx0rec.cc:158
constexpr uint32_t TRX_UNDO_UPD_EXIST_REC
update of a non-delete-marked record
Definition: trx0rec.h:300
Transaction undo log record.
Transaction system global type definitions.
byte trx_undo_rec_t
Undo log record.
Definition: trx0types.h:166
ib_id_t undo_no_t
Undo number.
Definition: trx0types.h:141
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:137
ib_id_t roll_ptr_t
Rollback pointer (DB_ROLL_PTR, DATA_ROLL_PTR)
Definition: trx0types.h:139
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:407