1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
|
/*****************************************************************************
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA
*****************************************************************************/
/******************************************************
Transaction undo log record
Created 3/26/1996 Heikki Tuuri
*******************************************************/
#ifndef trx0rec_h
#define trx0rec_h
#include "univ.i"
#include "trx0types.h"
#include "row0types.h"
#include "mtr0mtr.h"
#include "dict0types.h"
#include "que0types.h"
#include "data0data.h"
#include "rem0types.h"
/***************************************************************************
Copies the undo record to the heap. */
UNIV_INLINE
trx_undo_rec_t*
trx_undo_rec_copy(
/*==============*/
/* out, own: copy of undo log record */
trx_undo_rec_t* undo_rec, /* in: undo log record */
mem_heap_t* heap); /* in: heap where copied */
/**************************************************************************
Reads the undo log record type. */
UNIV_INLINE
ulint
trx_undo_rec_get_type(
/*==================*/
/* out: record type */
trx_undo_rec_t* undo_rec); /* in: undo log record */
/**************************************************************************
Reads from an undo log record the record compiler info. */
UNIV_INLINE
ulint
trx_undo_rec_get_cmpl_info(
/*=======================*/
/* out: compiler info */
trx_undo_rec_t* undo_rec); /* in: undo log record */
/**************************************************************************
Returns TRUE if an undo log record contains an extern storage field. */
UNIV_INLINE
ibool
trx_undo_rec_get_extern_storage(
/*============================*/
/* out: TRUE if extern */
trx_undo_rec_t* undo_rec); /* in: undo log record */
/**************************************************************************
Reads the undo log record number. */
UNIV_INLINE
dulint
trx_undo_rec_get_undo_no(
/*=====================*/
/* out: undo no */
trx_undo_rec_t* undo_rec); /* in: undo log record */
/**************************************************************************
* Returns the start of the undo record data area. */
UNIV_INLINE
byte*
trx_undo_rec_get_ptr(
/*==================*/
/* out: compiler info */
trx_undo_rec_t* undo_rec, /* in: undo log record */
dulint undo_no); /* in: undo no read from node */
/**************************************************************************
Reads from an undo log record the general parameters. */
UNIV_INTERN
byte*
trx_undo_rec_get_pars(
/*==================*/
/* out: remaining part of undo log
record after reading these values */
trx_undo_rec_t* undo_rec, /* in: undo log record */
ulint* type, /* out: undo record type:
TRX_UNDO_INSERT_REC, ... */
ulint* cmpl_info, /* out: compiler info, relevant only
for update type records */
ibool* updated_extern, /* out: TRUE if we updated an
externally stored fild */
dulint* undo_no, /* out: undo log record number */
dulint* table_id); /* out: table id */
/***********************************************************************
Builds a row reference from an undo log record. */
UNIV_INTERN
byte*
trx_undo_rec_get_row_ref(
/*=====================*/
/* out: pointer to remaining part of undo
record */
byte* ptr, /* in: remaining part of a copy of an undo log
record, at the start of the row reference;
NOTE that this copy of the undo log record must
be preserved as long as the row reference is
used, as we do NOT copy the data in the
record! */
dict_index_t* index, /* in: clustered index */
dtuple_t** ref, /* out, own: row reference */
mem_heap_t* heap); /* in: memory heap from which the memory
needed is allocated */
/***********************************************************************
Skips a row reference from an undo log record. */
UNIV_INTERN
byte*
trx_undo_rec_skip_row_ref(
/*======================*/
/* out: pointer to remaining part of undo
record */
byte* ptr, /* in: remaining part in update undo log
record, at the start of the row reference */
dict_index_t* index); /* in: clustered index */
/**************************************************************************
Reads from an undo log update record the system field values of the old
version. */
UNIV_INTERN
byte*
trx_undo_update_rec_get_sys_cols(
/*=============================*/
/* out: remaining part of undo log
record after reading these values */
byte* ptr, /* in: remaining part of undo log
record after reading general
parameters */
dulint* trx_id, /* out: trx id */
dulint* roll_ptr, /* out: roll ptr */
ulint* info_bits); /* out: info bits state */
/***********************************************************************
Builds an update vector based on a remaining part of an undo log record. */
UNIV_INTERN
byte*
trx_undo_update_rec_get_update(
/*===========================*/
/* out: remaining part of the record,
NULL if an error detected, which means that
the record is corrupted */
byte* ptr, /* in: remaining part in update undo log
record, after reading the row reference
NOTE that this copy of the undo log record must
be preserved as long as the update vector is
used, as we do NOT copy the data in the
record! */
dict_index_t* index, /* in: clustered index */
ulint type, /* in: TRX_UNDO_UPD_EXIST_REC,
TRX_UNDO_UPD_DEL_REC, or
TRX_UNDO_DEL_MARK_REC; in the last case,
only trx id and roll ptr fields are added to
the update vector */
dulint trx_id, /* in: transaction id from this undorecord */
dulint roll_ptr,/* in: roll pointer from this undo record */
ulint info_bits,/* in: info bits from this undo record */
trx_t* trx, /* in: transaction */
mem_heap_t* heap, /* in: memory heap from which the memory
needed is allocated */
upd_t** upd); /* out, own: update vector */
/***********************************************************************
Builds a partial row from an update undo log record. It contains the
columns which occur as ordering in any index of the table. */
UNIV_INTERN
byte*
trx_undo_rec_get_partial_row(
/*=========================*/
/* out: pointer to remaining part of undo
record */
byte* ptr, /* in: remaining part in update undo log
record of a suitable type, at the start of
the stored index columns;
NOTE that this copy of the undo log record must
be preserved as long as the partial row is
used, as we do NOT copy the data in the
record! */
dict_index_t* index, /* in: clustered index */
dtuple_t** row, /* out, own: partial row */
ibool ignore_prefix, /* in: flag to indicate if we
expect blob prefixes in undo. Used
only in the assertion. */
mem_heap_t* heap); /* in: memory heap from which the memory
needed is allocated */
/***************************************************************************
Writes information to an undo log about an insert, update, or a delete marking
of a clustered index record. This information is used in a rollback of the
transaction and in consistent reads that must look to the history of this
transaction. */
UNIV_INTERN
ulint
trx_undo_report_row_operation(
/*==========================*/
/* out: DB_SUCCESS or error code */
ulint flags, /* in: if BTR_NO_UNDO_LOG_FLAG bit is
set, does nothing */
ulint op_type, /* in: TRX_UNDO_INSERT_OP or
TRX_UNDO_MODIFY_OP */
que_thr_t* thr, /* in: query thread */
dict_index_t* index, /* in: clustered index */
const dtuple_t* clust_entry, /* in: in the case of an insert,
index entry to insert into the
clustered index, otherwise NULL */
const upd_t* update, /* in: in the case of an update,
the update vector, otherwise NULL */
ulint cmpl_info, /* in: compiler info on secondary
index updates */
const rec_t* rec, /* in: case of an update or delete
marking, the record in the clustered
index, otherwise NULL */
dulint* roll_ptr); /* out: rollback pointer to the
inserted undo log record,
ut_dulint_zero if BTR_NO_UNDO_LOG
flag was specified */
/**********************************************************************
Copies an undo record to heap. This function can be called if we know that
the undo log record exists. */
UNIV_INTERN
trx_undo_rec_t*
trx_undo_get_undo_rec_low(
/*======================*/
/* out, own: copy of the record */
dulint roll_ptr, /* in: roll pointer to record */
mem_heap_t* heap); /* in: memory heap where copied */
/**********************************************************************
Copies an undo record to heap. */
UNIV_INTERN
ulint
trx_undo_get_undo_rec(
/*==================*/
/* out: DB_SUCCESS, or
DB_MISSING_HISTORY if the undo log
has been truncated and we cannot
fetch the old version; NOTE: the
caller must have latches on the
clustered index page and purge_view */
dulint roll_ptr, /* in: roll pointer to record */
dulint trx_id, /* in: id of the trx that generated
the roll pointer: it points to an
undo log of this transaction */
trx_undo_rec_t** undo_rec, /* out, own: copy of the record */
mem_heap_t* heap); /* in: memory heap where copied */
/***********************************************************************
Build a previous version of a clustered index record. This function checks
that the caller has a latch on the index page of the clustered index record
and an s-latch on the purge_view. This guarantees that the stack of versions
is locked. */
UNIV_INTERN
ulint
trx_undo_prev_version_build(
/*========================*/
/* out: DB_SUCCESS, or DB_MISSING_HISTORY if
the previous version is not >= purge_view,
which means that it may have been removed,
DB_ERROR if corrupted record */
const rec_t* index_rec,/* in: clustered index record in the
index tree */
mtr_t* index_mtr,/* in: mtr which contains the latch to
index_rec page and purge_view */
const rec_t* rec, /* in: version of a clustered index record */
dict_index_t* index, /* in: clustered index */
ulint* offsets,/* in: rec_get_offsets(rec, index) */
mem_heap_t* heap, /* in: memory heap from which the memory
needed is allocated */
rec_t** old_vers);/* out, own: previous version, or NULL if
rec is the first inserted version, or if
history data has been deleted */
/***************************************************************
Parses a redo log record of adding an undo log record. */
UNIV_INTERN
byte*
trx_undo_parse_add_undo_rec(
/*========================*/
/* out: end of log record or NULL */
byte* ptr, /* in: buffer */
byte* end_ptr,/* in: buffer end */
page_t* page); /* in: page or NULL */
/***************************************************************
Parses a redo log record of erasing of an undo page end. */
UNIV_INTERN
byte*
trx_undo_parse_erase_page_end(
/*==========================*/
/* out: end of log record or NULL */
byte* ptr, /* in: buffer */
byte* end_ptr,/* in: buffer end */
page_t* page, /* in: page or NULL */
mtr_t* mtr); /* in: mtr or NULL */
/* Types of an undo log record: these have to be smaller than 16, as the
compilation info multiplied by 16 is ORed to this value in an undo log
record */
#define TRX_UNDO_INSERT_REC 11 /* fresh insert into clustered index */
#define TRX_UNDO_UPD_EXIST_REC 12 /* update of a non-delete-marked
record */
#define TRX_UNDO_UPD_DEL_REC 13 /* update of a delete marked record to
a not delete marked record; also the
fields of the record can change */
#define TRX_UNDO_DEL_MARK_REC 14 /* delete marking of a record; fields
do not change */
#define TRX_UNDO_CMPL_INFO_MULT 16 /* compilation info is multiplied by
this and ORed to the type above */
#define TRX_UNDO_UPD_EXTERN 128 /* This bit can be ORed to type_cmpl
to denote that we updated external
storage fields: used by purge to
free the external storage */
/* Operation type flags used in trx_undo_report_row_operation */
#define TRX_UNDO_INSERT_OP 1
#define TRX_UNDO_MODIFY_OP 2
#ifndef UNIV_NONINL
#include "trx0rec.ic"
#endif
#endif
|
