← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to storage/innodb_plugin/include/trx0roll.h

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innodb_plugin/include/trx0roll.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/**************************************************//**
 
20
@file include/trx0roll.h
 
21
Transaction rollback
 
22
 
 
23
Created 3/26/1996 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#ifndef trx0roll_h
 
27
#define trx0roll_h
 
28
 
 
29
#include "univ.i"
 
30
#include "trx0trx.h"
 
31
#include "trx0types.h"
 
32
#include "mtr0mtr.h"
 
33
#include "trx0sys.h"
 
34
 
 
35
#define trx_roll_free_all_savepoints(s) trx_roll_savepoints_free((s), NULL)
 
36
 
 
37
/*******************************************************************//**
 
38
Determines if this transaction is rolling back an incomplete transaction
 
39
in crash recovery.
 
40
@return TRUE if trx is an incomplete transaction that is being rolled
 
41
back in crash recovery */
 
42
UNIV_INTERN
 
43
ibool
 
44
trx_is_recv(
 
45
/*========*/
 
46
        const trx_t*    trx);   /*!< in: transaction */
 
47
/*******************************************************************//**
 
48
Returns a transaction savepoint taken at this point in time.
 
49
@return savepoint */
 
50
UNIV_INTERN
 
51
trx_savept_t
 
52
trx_savept_take(
 
53
/*============*/
 
54
        trx_t*  trx);   /*!< in: transaction */
 
55
/*******************************************************************//**
 
56
Creates an undo number array. */
 
57
UNIV_INTERN
 
58
trx_undo_arr_t*
 
59
trx_undo_arr_create(void);
 
60
/*=====================*/
 
61
/*******************************************************************//**
 
62
Frees an undo number array. */
 
63
UNIV_INTERN
 
64
void
 
65
trx_undo_arr_free(
 
66
/*==============*/
 
67
        trx_undo_arr_t* arr);   /*!< in: undo number array */
 
68
/*******************************************************************//**
 
69
Returns pointer to nth element in an undo number array.
 
70
@return pointer to the nth element */
 
71
UNIV_INLINE
 
72
trx_undo_inf_t*
 
73
trx_undo_arr_get_nth_info(
 
74
/*======================*/
 
75
        trx_undo_arr_t* arr,    /*!< in: undo number array */
 
76
        ulint           n);     /*!< in: position */
 
77
/***********************************************************************//**
 
78
Tries truncate the undo logs. */
 
79
UNIV_INTERN
 
80
void
 
81
trx_roll_try_truncate(
 
82
/*==================*/
 
83
        trx_t*  trx);   /*!< in/out: transaction */
 
84
/********************************************************************//**
 
85
Pops the topmost record when the two undo logs of a transaction are seen
 
86
as a single stack of records ordered by their undo numbers. Inserts the
 
87
undo number of the popped undo record to the array of currently processed
 
88
undo numbers in the transaction. When the query thread finishes processing
 
89
of this undo record, it must be released with trx_undo_rec_release.
 
90
@return undo log record copied to heap, NULL if none left, or if the
 
91
undo number of the top record would be less than the limit */
 
92
UNIV_INTERN
 
93
trx_undo_rec_t*
 
94
trx_roll_pop_top_rec_of_trx(
 
95
/*========================*/
 
96
        trx_t*          trx,    /*!< in: transaction */
 
97
        undo_no_t       limit,  /*!< in: least undo number we need */
 
98
        roll_ptr_t*     roll_ptr,/*!< out: roll pointer to undo record */
 
99
        mem_heap_t*     heap);  /*!< in: memory heap where copied */
 
100
/********************************************************************//**
 
101
Reserves an undo log record for a query thread to undo. This should be
 
102
called if the query thread gets the undo log record not using the pop
 
103
function above.
 
104
@return TRUE if succeeded */
 
105
UNIV_INTERN
 
106
ibool
 
107
trx_undo_rec_reserve(
 
108
/*=================*/
 
109
        trx_t*          trx,    /*!< in/out: transaction */
 
110
        undo_no_t       undo_no);/*!< in: undo number of the record */
 
111
/*******************************************************************//**
 
112
Releases a reserved undo record. */
 
113
UNIV_INTERN
 
114
void
 
115
trx_undo_rec_release(
 
116
/*=================*/
 
117
        trx_t*          trx,    /*!< in/out: transaction */
 
118
        undo_no_t       undo_no);/*!< in: undo number */
 
119
/*********************************************************************//**
 
120
Starts a rollback operation. */
 
121
UNIV_INTERN
 
122
void
 
123
trx_rollback(
 
124
/*=========*/
 
125
        trx_t*          trx,    /*!< in: transaction */
 
126
        trx_sig_t*      sig,    /*!< in: signal starting the rollback */
 
127
        que_thr_t**     next_thr);/*!< in/out: next query thread to run;
 
128
                                if the value which is passed in is
 
129
                                a pointer to a NULL pointer, then the
 
130
                                calling function can start running
 
131
                                a new query thread */
 
132
/*******************************************************************//**
 
133
Rollback or clean up any incomplete transactions which were
 
134
encountered in crash recovery.  If the transaction already was
 
135
committed, then we clean up a possible insert undo log. If the
 
136
transaction was not yet committed, then we roll it back. */
 
137
UNIV_INTERN
 
138
void
 
139
trx_rollback_or_clean_recovered(
 
140
/*============================*/
 
141
        ibool   all);   /*!< in: FALSE=roll back dictionary transactions;
 
142
                        TRUE=roll back all non-PREPARED transactions */
 
143
/*******************************************************************//**
 
144
Rollback or clean up any incomplete transactions which were
 
145
encountered in crash recovery.  If the transaction already was
 
146
committed, then we clean up a possible insert undo log. If the
 
147
transaction was not yet committed, then we roll it back.
 
148
Note: this is done in a background thread.
 
149
@return a dummy parameter */
 
150
UNIV_INTERN
 
151
os_thread_ret_t
 
152
trx_rollback_or_clean_all_recovered(
 
153
/*================================*/
 
154
        void*   arg __attribute__((unused)));
 
155
                        /*!< in: a dummy parameter required by
 
156
                        os_thread_create */
 
157
/****************************************************************//**
 
158
Finishes a transaction rollback. */
 
159
UNIV_INTERN
 
160
void
 
161
trx_finish_rollback_off_kernel(
 
162
/*===========================*/
 
163
        que_t*          graph,  /*!< in: undo graph which can now be freed */
 
164
        trx_t*          trx,    /*!< in: transaction */
 
165
        que_thr_t**     next_thr);/*!< in/out: next query thread to run;
 
166
                                if the value which is passed in is
 
167
                                a pointer to a NULL pointer, then the
 
168
                                calling function can start running
 
169
                                a new query thread; if this parameter is
 
170
                                NULL, it is ignored */
 
171
/****************************************************************//**
 
172
Builds an undo 'query' graph for a transaction. The actual rollback is
 
173
performed by executing this query graph like a query subprocedure call.
 
174
The reply about the completion of the rollback will be sent by this
 
175
graph.
 
176
@return own: the query graph */
 
177
UNIV_INTERN
 
178
que_t*
 
179
trx_roll_graph_build(
 
180
/*=================*/
 
181
        trx_t*  trx);   /*!< in: trx handle */
 
182
/*********************************************************************//**
 
183
Creates a rollback command node struct.
 
184
@return own: rollback node struct */
 
185
UNIV_INTERN
 
186
roll_node_t*
 
187
roll_node_create(
 
188
/*=============*/
 
189
        mem_heap_t*     heap);  /*!< in: mem heap where created */
 
190
/***********************************************************//**
 
191
Performs an execution step for a rollback command node in a query graph.
 
192
@return query thread to run next, or NULL */
 
193
UNIV_INTERN
 
194
que_thr_t*
 
195
trx_rollback_step(
 
196
/*==============*/
 
197
        que_thr_t*      thr);   /*!< in: query thread */
 
198
/*******************************************************************//**
 
199
Rollback a transaction used in MySQL.
 
200
@return error code or DB_SUCCESS */
 
201
UNIV_INTERN
 
202
int
 
203
trx_rollback_for_mysql(
 
204
/*===================*/
 
205
        trx_t*  trx);   /*!< in: transaction handle */
 
206
/*******************************************************************//**
 
207
Rollback the latest SQL statement for MySQL.
 
208
@return error code or DB_SUCCESS */
 
209
UNIV_INTERN
 
210
int
 
211
trx_rollback_last_sql_stat_for_mysql(
 
212
/*=================================*/
 
213
        trx_t*  trx);   /*!< in: transaction handle */
 
214
/*******************************************************************//**
 
215
Rollback a transaction used in MySQL.
 
216
@return error code or DB_SUCCESS */
 
217
UNIV_INTERN
 
218
int
 
219
trx_general_rollback_for_mysql(
 
220
/*===========================*/
 
221
        trx_t*          trx,    /*!< in: transaction handle */
 
222
        trx_savept_t*   savept);/*!< in: pointer to savepoint undo number, if
 
223
                                partial rollback requested, or NULL for
 
224
                                complete rollback */
 
225
/*******************************************************************//**
 
226
Rolls back a transaction back to a named savepoint. Modifications after the
 
227
savepoint are undone but InnoDB does NOT release the corresponding locks
 
228
which are stored in memory. If a lock is 'implicit', that is, a new inserted
 
229
row holds a lock where the lock information is carried by the trx id stored in
 
230
the row, these locks are naturally released in the rollback. Savepoints which
 
231
were set after this savepoint are deleted.
 
232
@return if no savepoint of the name found then DB_NO_SAVEPOINT,
 
233
otherwise DB_SUCCESS */
 
234
UNIV_INTERN
 
235
ulint
 
236
trx_rollback_to_savepoint_for_mysql(
 
237
/*================================*/
 
238
        trx_t*          trx,                    /*!< in: transaction handle */
 
239
        const char*     savepoint_name,         /*!< in: savepoint name */
 
240
        ib_int64_t*     mysql_binlog_cache_pos);/*!< out: the MySQL binlog cache
 
241
                                                position corresponding to this
 
242
                                                savepoint; MySQL needs this
 
243
                                                information to remove the
 
244
                                                binlog entries of the queries
 
245
                                                executed after the savepoint */
 
246
/*******************************************************************//**
 
247
Creates a named savepoint. If the transaction is not yet started, starts it.
 
248
If there is already a savepoint of the same name, this call erases that old
 
249
savepoint and replaces it with a new. Savepoints are deleted in a transaction
 
250
commit or rollback.
 
251
@return always DB_SUCCESS */
 
252
UNIV_INTERN
 
253
ulint
 
254
trx_savepoint_for_mysql(
 
255
/*====================*/
 
256
        trx_t*          trx,                    /*!< in: transaction handle */
 
257
        const char*     savepoint_name,         /*!< in: savepoint name */
 
258
        ib_int64_t      binlog_cache_pos);      /*!< in: MySQL binlog cache
 
259
                                                position corresponding to this
 
260
                                                connection at the time of the
 
261
                                                savepoint */
 
262
 
 
263
/*******************************************************************//**
 
264
Releases a named savepoint. Savepoints which
 
265
were set after this savepoint are deleted.
 
266
@return if no savepoint of the name found then DB_NO_SAVEPOINT,
 
267
otherwise DB_SUCCESS */
 
268
UNIV_INTERN
 
269
ulint
 
270
trx_release_savepoint_for_mysql(
 
271
/*============================*/
 
272
        trx_t*          trx,                    /*!< in: transaction handle */
 
273
        const char*     savepoint_name);        /*!< in: savepoint name */
 
274
 
 
275
/*******************************************************************//**
 
276
Frees a single savepoint struct. */
 
277
UNIV_INTERN
 
278
void
 
279
trx_roll_savepoint_free(
 
280
/*=====================*/
 
281
        trx_t*                  trx,    /*!< in: transaction handle */
 
282
        trx_named_savept_t*     savep); /*!< in: savepoint to free */
 
283
 
 
284
/*******************************************************************//**
 
285
Frees savepoint structs starting from savep, if savep == NULL then
 
286
free all savepoints. */
 
287
UNIV_INTERN
 
288
void
 
289
trx_roll_savepoints_free(
 
290
/*=====================*/
 
291
        trx_t*                  trx,    /*!< in: transaction handle */
 
292
        trx_named_savept_t*     savep); /*!< in: free all savepoints > this one;
 
293
                                        if this is NULL, free all savepoints
 
294
                                        of trx */
 
295
 
 
296
/** A cell of trx_undo_arr_struct; used during a rollback and a purge */
 
297
struct  trx_undo_inf_struct{
 
298
        trx_id_t        trx_no; /*!< transaction number: not defined during
 
299
                                a rollback */
 
300
        undo_no_t       undo_no;/*!< undo number of an undo record */
 
301
        ibool           in_use; /*!< TRUE if the cell is in use */
 
302
};
 
303
 
 
304
/** During a rollback and a purge, undo numbers of undo records currently being
 
305
processed are stored in this array */
 
306
 
 
307
struct trx_undo_arr_struct{
 
308
        ulint           n_cells;        /*!< number of cells in the array */
 
309
        ulint           n_used;         /*!< number of cells currently in use */
 
310
        trx_undo_inf_t* infos;          /*!< the array of undo infos */
 
311
        mem_heap_t*     heap;           /*!< memory heap from which allocated */
 
312
};
 
313
 
 
314
/** Rollback node states */
 
315
enum roll_node_state {
 
316
        ROLL_NODE_SEND = 1,     /*!< about to send a rollback signal to
 
317
                                the transaction */
 
318
        ROLL_NODE_WAIT          /*!< rollback signal sent to the transaction,
 
319
                                waiting for completion */
 
320
};
 
321
 
 
322
/** Rollback command node in a query graph */
 
323
struct roll_node_struct{
 
324
        que_common_t            common; /*!< node type: QUE_NODE_ROLLBACK */
 
325
        enum roll_node_state    state;  /*!< node execution state */
 
326
        ibool                   partial;/*!< TRUE if we want a partial
 
327
                                        rollback */
 
328
        trx_savept_t            savept; /*!< savepoint to which to
 
329
                                        roll back, in the case of a
 
330
                                        partial rollback */
 
331
};
 
332
 
 
333
/** A savepoint set with SQL's "SAVEPOINT savepoint_id" command */
 
334
struct trx_named_savept_struct{
 
335
        char*           name;           /*!< savepoint name */
 
336
        trx_savept_t    savept;         /*!< the undo number corresponding to
 
337
                                        the savepoint */
 
338
        ib_int64_t      mysql_binlog_cache_pos;
 
339
                                        /*!< the MySQL binlog cache position
 
340
                                        corresponding to this savepoint, not
 
341
                                        defined if the MySQL binlogging is not
 
342
                                        enabled */
 
343
        UT_LIST_NODE_T(trx_named_savept_t)
 
344
                        trx_savepoints; /*!< the list of savepoints of a
 
345
                                        transaction */
 
346
};
 
347
 
 
348
#ifndef UNIV_NONINL
 
349
#include "trx0roll.ic"
 
350
#endif
 
351
 
 
352
#endif