← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/row/row0uins.c

  • Committer: Mats Kindahl
  • Date: 2008-08-26 07:32:59 UTC
  • mto: (489.1.2 codestyle)
  • mto: This revision was merged to the branch mainline in revision 491.
  • Revision ID: mats@mysql.com-20080826073259-9k4evtajgldgolli
Replaced use of thd_proc_info() macro with calls to
set_proc_info() and get_proc_info() internally.  Introduced
functions set_thd_proc_info() and get_thd_proc_info() for
external users, i.e., plug-ins.

The set_thd_proc_info() accepted callers info that can be used to
print debug output, but the information was not used. The return
value was changed to void and the old value is not fetched any
more. To be able to get the value of proc_info for external
users, the function get_thd_proc_info() was introduced.

The thd_proc_info() macro called set_thd_proc_info() but almost
never used the return value of set_thd_proc_info() so the macro
was replaced with a call of THD::set_proc_info().

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/row/row0uins.c
 
1
/******************************************************
 
2
Fresh insert undo
 
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
 
6
Created 2/25/1997 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#include "row0uins.h"
 
10
 
 
11
#ifdef UNIV_NONINL
 
12
#include "row0uins.ic"
 
13
#endif
 
14
 
 
15
#include "dict0dict.h"
 
16
#include "dict0boot.h"
 
17
#include "dict0crea.h"
 
18
#include "trx0undo.h"
 
19
#include "trx0roll.h"
 
20
#include "btr0btr.h"
 
21
#include "mach0data.h"
 
22
#include "row0undo.h"
 
23
#include "row0vers.h"
 
24
#include "trx0trx.h"
 
25
#include "trx0rec.h"
 
26
#include "row0row.h"
 
27
#include "row0upd.h"
 
28
#include "que0que.h"
 
29
#include "ibuf0ibuf.h"
 
30
#include "log0log.h"
 
31
 
 
32
/*******************************************************************
 
33
Removes a clustered index record. The pcur in node was positioned on the
 
34
record, now it is detached. */
 
35
static
 
36
ulint
 
37
row_undo_ins_remove_clust_rec(
 
38
/*==========================*/
 
39
                                /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
 
40
        undo_node_t*    node)   /* in: undo node */
 
41
{
 
42
        btr_cur_t*      btr_cur;
 
43
        ibool           success;
 
44
        ulint           err;
 
45
        ulint           n_tries         = 0;
 
46
        mtr_t           mtr;
 
47
 
 
48
        mtr_start(&mtr);
 
49
 
 
50
        success = btr_pcur_restore_position(BTR_MODIFY_LEAF, &(node->pcur),
 
51
                                            &mtr);
 
52
        ut_a(success);
 
53
 
 
54
        if (ut_dulint_cmp(node->table->id, DICT_INDEXES_ID) == 0) {
 
55
 
 
56
                /* Drop the index tree associated with the row in
 
57
                SYS_INDEXES table: */
 
58
 
 
59
                dict_drop_index_tree(btr_pcur_get_rec(&(node->pcur)), &mtr);
 
60
 
 
61
                mtr_commit(&mtr);
 
62
 
 
63
                mtr_start(&mtr);
 
64
 
 
65
                success = btr_pcur_restore_position(BTR_MODIFY_LEAF,
 
66
                                                    &(node->pcur), &mtr);
 
67
                ut_a(success);
 
68
        }
 
69
 
 
70
        btr_cur = btr_pcur_get_btr_cur(&(node->pcur));
 
71
 
 
72
        success = btr_cur_optimistic_delete(btr_cur, &mtr);
 
73
 
 
74
        btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
 
75
 
 
76
        if (success) {
 
77
                trx_undo_rec_release(node->trx, node->undo_no);
 
78
 
 
79
                return(DB_SUCCESS);
 
80
        }
 
81
retry:
 
82
        /* If did not succeed, try pessimistic descent to tree */
 
83
        mtr_start(&mtr);
 
84
 
 
85
        success = btr_pcur_restore_position(BTR_MODIFY_TREE,
 
86
                                            &(node->pcur), &mtr);
 
87
        ut_a(success);
 
88
 
 
89
        btr_cur_pessimistic_delete(&err, FALSE, btr_cur, TRUE, &mtr);
 
90
 
 
91
        /* The delete operation may fail if we have little
 
92
        file space left: TODO: easiest to crash the database
 
93
        and restart with more file space */
 
94
 
 
95
        if (err == DB_OUT_OF_FILE_SPACE
 
96
            && n_tries < BTR_CUR_RETRY_DELETE_N_TIMES) {
 
97
 
 
98
                btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
 
99
 
 
100
                n_tries++;
 
101
 
 
102
                os_thread_sleep(BTR_CUR_RETRY_SLEEP_TIME);
 
103
 
 
104
                goto retry;
 
105
        }
 
106
 
 
107
        btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
 
108
 
 
109
        trx_undo_rec_release(node->trx, node->undo_no);
 
110
 
 
111
        return(err);
 
112
}
 
113
 
 
114
/*******************************************************************
 
115
Removes a secondary index entry if found. */
 
116
static
 
117
ulint
 
118
row_undo_ins_remove_sec_low(
 
119
/*========================*/
 
120
                                /* out: DB_SUCCESS, DB_FAIL, or
 
121
                                DB_OUT_OF_FILE_SPACE */
 
122
        ulint           mode,   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
 
123
                                depending on whether we wish optimistic or
 
124
                                pessimistic descent down the index tree */
 
125
        dict_index_t*   index,  /* in: index */
 
126
        dtuple_t*       entry)  /* in: index entry to remove */
 
127
{
 
128
        btr_pcur_t      pcur;
 
129
        btr_cur_t*      btr_cur;
 
130
        ibool           found;
 
131
        ibool           success;
 
132
        ulint           err;
 
133
        mtr_t           mtr;
 
134
 
 
135
        log_free_check();
 
136
        mtr_start(&mtr);
 
137
 
 
138
        found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
 
139
 
 
140
        btr_cur = btr_pcur_get_btr_cur(&pcur);
 
141
 
 
142
        if (!found) {
 
143
                /* Not found */
 
144
 
 
145
                btr_pcur_close(&pcur);
 
146
                mtr_commit(&mtr);
 
147
 
 
148
                return(DB_SUCCESS);
 
149
        }
 
150
 
 
151
        if (mode == BTR_MODIFY_LEAF) {
 
152
                success = btr_cur_optimistic_delete(btr_cur, &mtr);
 
153
 
 
154
                if (success) {
 
155
                        err = DB_SUCCESS;
 
156
                } else {
 
157
                        err = DB_FAIL;
 
158
                }
 
159
        } else {
 
160
                ut_ad(mode == BTR_MODIFY_TREE);
 
161
 
 
162
                btr_cur_pessimistic_delete(&err, FALSE, btr_cur, TRUE, &mtr);
 
163
        }
 
164
 
 
165
        btr_pcur_close(&pcur);
 
166
        mtr_commit(&mtr);
 
167
 
 
168
        return(err);
 
169
}
 
170
 
 
171
/*******************************************************************
 
172
Removes a secondary index entry from the index if found. Tries first
 
173
optimistic, then pessimistic descent down the tree. */
 
174
static
 
175
ulint
 
176
row_undo_ins_remove_sec(
 
177
/*====================*/
 
178
                                /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
 
179
        dict_index_t*   index,  /* in: index */
 
180
        dtuple_t*       entry)  /* in: index entry to insert */
 
181
{
 
182
        ulint   err;
 
183
        ulint   n_tries = 0;
 
184
 
 
185
        /* Try first optimistic descent to the B-tree */
 
186
 
 
187
        err = row_undo_ins_remove_sec_low(BTR_MODIFY_LEAF, index, entry);
 
188
 
 
189
        if (err == DB_SUCCESS) {
 
190
 
 
191
                return(err);
 
192
        }
 
193
 
 
194
        /* Try then pessimistic descent to the B-tree */
 
195
retry:
 
196
        err = row_undo_ins_remove_sec_low(BTR_MODIFY_TREE, index, entry);
 
197
 
 
198
        /* The delete operation may fail if we have little
 
199
        file space left: TODO: easiest to crash the database
 
200
        and restart with more file space */
 
201
 
 
202
        if (err != DB_SUCCESS && n_tries < BTR_CUR_RETRY_DELETE_N_TIMES) {
 
203
 
 
204
                n_tries++;
 
205
 
 
206
                os_thread_sleep(BTR_CUR_RETRY_SLEEP_TIME);
 
207
 
 
208
                goto retry;
 
209
        }
 
210
 
 
211
        return(err);
 
212
}
 
213
 
 
214
/***************************************************************
 
215
Parses the row reference and other info in a fresh insert undo record. */
 
216
static
 
217
void
 
218
row_undo_ins_parse_undo_rec(
 
219
/*========================*/
 
220
        undo_node_t*    node)   /* in: row undo node */
 
221
{
 
222
        dict_index_t*   clust_index;
 
223
        byte*           ptr;
 
224
        dulint          undo_no;
 
225
        dulint          table_id;
 
226
        ulint           type;
 
227
        ulint           dummy;
 
228
        ibool           dummy_extern;
 
229
 
 
230
        ut_ad(node);
 
231
 
 
232
        ptr = trx_undo_rec_get_pars(node->undo_rec, &type, &dummy,
 
233
                                    &dummy_extern, &undo_no, &table_id);
 
234
        ut_ad(type == TRX_UNDO_INSERT_REC);
 
235
        node->rec_type = type;
 
236
 
 
237
        node->table = dict_table_get_on_id(table_id, node->trx);
 
238
 
 
239
        if (node->table == NULL) {
 
240
 
 
241
                return;
 
242
        }
 
243
 
 
244
        if (node->table->ibd_file_missing) {
 
245
                /* We skip undo operations to missing .ibd files */
 
246
                node->table = NULL;
 
247
 
 
248
                return;
 
249
        }
 
250
 
 
251
        clust_index = dict_table_get_first_index(node->table);
 
252
 
 
253
        ptr = trx_undo_rec_get_row_ref(ptr, clust_index, &(node->ref),
 
254
                                       node->heap);
 
255
}
 
256
 
 
257
/***************************************************************
 
258
Undoes a fresh insert of a row to a table. A fresh insert means that
 
259
the same clustered index unique key did not have any record, even delete
 
260
marked, at the time of the insert. */
 
261
 
 
262
ulint
 
263
row_undo_ins(
 
264
/*=========*/
 
265
                                /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
 
266
        undo_node_t*    node)   /* in: row undo node */
 
267
{
 
268
        dtuple_t*       entry;
 
269
        ibool           found;
 
270
        ulint           err;
 
271
 
 
272
        ut_ad(node);
 
273
        ut_ad(node->state == UNDO_NODE_INSERT);
 
274
 
 
275
        row_undo_ins_parse_undo_rec(node);
 
276
 
 
277
        if (node->table == NULL) {
 
278
                found = FALSE;
 
279
        } else {
 
280
                found = row_undo_search_clust_to_pcur(node);
 
281
        }
 
282
 
 
283
        if (!found) {
 
284
                trx_undo_rec_release(node->trx, node->undo_no);
 
285
 
 
286
                return(DB_SUCCESS);
 
287
        }
 
288
 
 
289
        node->index = dict_table_get_next_index(
 
290
                dict_table_get_first_index(node->table));
 
291
 
 
292
        while (node->index != NULL) {
 
293
                entry = row_build_index_entry(node->row, node->index,
 
294
                                              node->heap);
 
295
                err = row_undo_ins_remove_sec(node->index, entry);
 
296
 
 
297
                if (err != DB_SUCCESS) {
 
298
 
 
299
                        return(err);
 
300
                }
 
301
 
 
302
                node->index = dict_table_get_next_index(node->index);
 
303
        }
 
304
 
 
305
        err = row_undo_ins_remove_clust_rec(node);
 
306
 
 
307
        return(err);
 
308
}