← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/row/row0purge.c

  • Committer: Marisa Plumb
  • Date: 2010-12-04 02:38:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1984.
  • Revision ID: marisa.plumb@gmail.com-20101204023829-2khzxh30wxi256db
updates to a few sql docs 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/row/row0purge.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1997, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1997, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
44
44
#include "row0mysql.h"
45
45
#include "log0log.h"
46
46
 
47
 
/*************************************************************************
48
 
IMPORTANT NOTE: Any operation that generates redo MUST check that there
49
 
is enough space in the redo log before for that operation. This is
50
 
done by calling log_free_check(). The reason for checking the
51
 
availability of the redo log space before the start of the operation is
52
 
that we MUST not hold any synchonization objects when performing the
53
 
check.
54
 
If you make a change in this module make sure that no codepath is
55
 
introduced where a call to log_free_check() is bypassed. */
56
 
 
57
 
/*************************************************************************
58
 
IMPORTANT NOTE: Any operation that generates redo MUST check that there
59
 
is enough space in the redo log before for that operation. This is
60
 
done by calling log_free_check(). The reason for checking the
61
 
availability of the redo log space before the start of the operation is
62
 
that we MUST not hold any synchonization objects when performing the
63
 
check.
64
 
If you make a change in this module make sure that no codepath is
65
 
introduced where a call to log_free_check() is bypassed. */
66
 
 
67
47
/********************************************************************//**
68
48
Creates a purge node to a query graph.
69
49
@return own: purge node */
78
58
 
79
59
        ut_ad(parent && heap);
80
60
 
81
 
        node = static_cast<purge_node_t *>(mem_heap_alloc(heap, sizeof(purge_node_t)));
 
61
        node = mem_heap_alloc(heap, sizeof(purge_node_t));
82
62
 
83
63
        node->common.type = QUE_NODE_PURGE;
84
64
        node->common.parent = parent;
146
126
        pcur = &(node->pcur);
147
127
        btr_cur = btr_pcur_get_btr_cur(pcur);
148
128
 
149
 
        log_free_check();
150
129
        mtr_start(&mtr);
151
130
 
152
131
        success = row_purge_reposition_pcur(mode, node, &mtr);
161
140
 
162
141
        rec = btr_pcur_get_rec(pcur);
163
142
 
164
 
        if (node->roll_ptr != row_get_rec_roll_ptr(
165
 
                    rec, index, rec_get_offsets(rec, index, offsets_,
166
 
                                                ULINT_UNDEFINED, &heap))) {
 
143
        if (0 != ut_dulint_cmp(node->roll_ptr, row_get_rec_roll_ptr(
 
144
                                       rec, index, rec_get_offsets(
 
145
                                               rec, index, offsets_,
 
146
                                               ULINT_UNDEFINED, &heap)))) {
167
147
                if (UNIV_LIKELY_NULL(heap)) {
168
148
                        mem_heap_free(heap);
169
149
                }
235
215
}
236
216
 
237
217
/***********************************************************//**
238
 
Determines if it is possible to remove a secondary index entry.
239
 
Removal is possible if the secondary index entry does not refer to any
240
 
not delete marked version of a clustered index record where DB_TRX_ID
241
 
is newer than the purge view.
242
 
 
243
 
NOTE: This function should only be called by the purge thread, only
244
 
while holding a latch on the leaf page of the secondary index entry
245
 
(or keeping the buffer pool watch on the page).  It is possible that
246
 
this function first returns TRUE and then FALSE, if a user transaction
247
 
inserts a record that the secondary index entry would refer to.
248
 
However, in that case, the user transaction would also re-insert the
249
 
secondary index entry after purge has removed it and released the leaf
250
 
page latch.
251
 
@return TRUE if the secondary index record can be purged */
252
 
UNIV_INTERN
253
 
ibool
254
 
row_purge_poss_sec(
255
 
/*===============*/
256
 
        purge_node_t*   node,   /*!< in/out: row purge node */
257
 
        dict_index_t*   index,  /*!< in: secondary index */
258
 
        const dtuple_t* entry)  /*!< in: secondary index entry */
259
 
{
260
 
        ibool   can_delete;
261
 
        mtr_t   mtr;
262
 
 
263
 
        ut_ad(!dict_index_is_clust(index));
264
 
        mtr_start(&mtr);
265
 
 
266
 
        can_delete = !row_purge_reposition_pcur(BTR_SEARCH_LEAF, node, &mtr)
267
 
                || !row_vers_old_has_index_entry(TRUE,
268
 
                                                 btr_pcur_get_rec(&node->pcur),
269
 
                                                 &mtr, index, entry);
270
 
 
271
 
        btr_pcur_commit_specify_mtr(&node->pcur, &mtr);
272
 
 
273
 
        return(can_delete);
274
 
}
275
 
 
276
 
/***************************************************************
277
 
Removes a secondary index entry if possible, by modifying the
278
 
index tree.  Does not try to buffer the delete.
 
218
Removes a secondary index entry if possible.
279
219
@return TRUE if success or if not found */
280
220
static
281
221
ibool
282
 
row_purge_remove_sec_if_poss_tree(
283
 
/*==============================*/
 
222
row_purge_remove_sec_if_poss_low(
 
223
/*=============================*/
284
224
        purge_node_t*   node,   /*!< in: row purge node */
285
225
        dict_index_t*   index,  /*!< in: index */
286
 
        const dtuple_t* entry)  /*!< in: index entry */
 
226
        const dtuple_t* entry,  /*!< in: index entry */
 
227
        ulint           mode)   /*!< in: latch mode BTR_MODIFY_LEAF or
 
228
                                BTR_MODIFY_TREE */
287
229
{
288
 
        btr_pcur_t              pcur;
289
 
        btr_cur_t*              btr_cur;
290
 
        ibool                   success = TRUE;
291
 
        ulint                   err;
292
 
        mtr_t                   mtr;
293
 
        enum row_search_result  search_result;
 
230
        btr_pcur_t      pcur;
 
231
        btr_cur_t*      btr_cur;
 
232
        ibool           success;
 
233
        ibool           old_has = 0; /* remove warning */
 
234
        ibool           found;
 
235
        ulint           err;
 
236
        mtr_t           mtr;
 
237
        mtr_t           mtr_vers;
294
238
 
295
239
        log_free_check();
296
240
        mtr_start(&mtr);
297
241
 
298
 
        search_result = row_search_index_entry(index, entry, BTR_MODIFY_TREE,
299
 
                                               &pcur, &mtr);
 
242
        found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
300
243
 
301
 
        switch (search_result) {
302
 
        case ROW_NOT_FOUND:
 
244
        if (!found) {
303
245
                /* Not found.  This is a legitimate condition.  In a
304
246
                rollback, InnoDB will remove secondary recs that would
305
247
                be purged anyway.  Then the actual purge will not find
312
254
 
313
255
                /* fputs("PURGE:........sec entry not found\n", stderr); */
314
256
                /* dtuple_print(stderr, entry); */
315
 
                goto func_exit;
316
 
        case ROW_FOUND:
317
 
                break;
318
 
        case ROW_BUFFERED:
319
 
        case ROW_NOT_DELETED_REF:
320
 
                /* These are invalid outcomes, because the mode passed
321
 
                to row_search_index_entry() did not include any of the
322
 
                flags BTR_INSERT, BTR_DELETE, or BTR_DELETE_MARK. */
323
 
                ut_error;
 
257
 
 
258
                btr_pcur_close(&pcur);
 
259
                mtr_commit(&mtr);
 
260
 
 
261
                return(TRUE);
324
262
        }
325
263
 
326
264
        btr_cur = btr_pcur_get_btr_cur(&pcur);
329
267
        which cannot be purged yet, requires its existence. If some requires,
330
268
        we should do nothing. */
331
269
 
332
 
        if (row_purge_poss_sec(node, index, entry)) {
333
 
                /* Remove the index record, which should have been
334
 
                marked for deletion. */
335
 
                ut_ad(REC_INFO_DELETED_FLAG
336
 
                      & rec_get_info_bits(btr_cur_get_rec(btr_cur),
337
 
                                          dict_table_is_comp(index->table)));
338
 
 
339
 
                btr_cur_pessimistic_delete(&err, FALSE, btr_cur,
340
 
                                           RB_NONE, &mtr);
341
 
                switch (UNIV_EXPECT(err, DB_SUCCESS)) {
342
 
                case DB_SUCCESS:
343
 
                        break;
344
 
                case DB_OUT_OF_FILE_SPACE:
345
 
                        success = FALSE;
346
 
                        break;
347
 
                default:
348
 
                        ut_error;
 
270
        mtr_start(&mtr_vers);
 
271
 
 
272
        success = row_purge_reposition_pcur(BTR_SEARCH_LEAF, node, &mtr_vers);
 
273
 
 
274
        if (success) {
 
275
                old_has = row_vers_old_has_index_entry(
 
276
                        TRUE, btr_pcur_get_rec(&(node->pcur)),
 
277
                        &mtr_vers, index, entry);
 
278
        }
 
279
 
 
280
        btr_pcur_commit_specify_mtr(&(node->pcur), &mtr_vers);
 
281
 
 
282
        if (!success || !old_has) {
 
283
                /* Remove the index record */
 
284
 
 
285
                if (mode == BTR_MODIFY_LEAF) {
 
286
                        success = btr_cur_optimistic_delete(btr_cur, &mtr);
 
287
                } else {
 
288
                        ut_ad(mode == BTR_MODIFY_TREE);
 
289
                        btr_cur_pessimistic_delete(&err, FALSE, btr_cur,
 
290
                                                   RB_NONE, &mtr);
 
291
                        success = err == DB_SUCCESS;
 
292
                        ut_a(success || err == DB_OUT_OF_FILE_SPACE);
349
293
                }
350
294
        }
351
295
 
352
 
func_exit:
353
296
        btr_pcur_close(&pcur);
354
297
        mtr_commit(&mtr);
355
298
 
356
299
        return(success);
357
300
}
358
301
 
359
 
/***************************************************************
360
 
Removes a secondary index entry without modifying the index tree,
361
 
if possible.
362
 
@return TRUE if success or if not found */
363
 
static
364
 
ibool
365
 
row_purge_remove_sec_if_poss_leaf(
366
 
/*==============================*/
367
 
        purge_node_t*   node,   /*!< in: row purge node */
368
 
        dict_index_t*   index,  /*!< in: index */
369
 
        const dtuple_t* entry)  /*!< in: index entry */
370
 
{
371
 
        mtr_t                   mtr;
372
 
        btr_pcur_t              pcur;
373
 
        enum row_search_result  search_result;
374
 
 
375
 
        log_free_check();
376
 
 
377
 
        mtr_start(&mtr);
378
 
 
379
 
        /* Set the purge node for the call to row_purge_poss_sec(). */
380
 
        pcur.btr_cur.purge_node = node;
381
 
        /* Set the query thread, so that ibuf_insert_low() will be
382
 
        able to invoke thd_get_trx(). */
383
 
        pcur.btr_cur.thr = static_cast<que_thr_t *>(que_node_get_parent(node));
384
 
 
385
 
        search_result = row_search_index_entry(
386
 
                index, entry, BTR_MODIFY_LEAF | BTR_DELETE, &pcur, &mtr);
387
 
 
388
 
        switch (search_result) {
389
 
                ibool   success;
390
 
        case ROW_FOUND:
391
 
                /* Before attempting to purge a record, check
392
 
                if it is safe to do so. */
393
 
                if (row_purge_poss_sec(node, index, entry)) {
394
 
                        btr_cur_t* btr_cur = btr_pcur_get_btr_cur(&pcur);
395
 
 
396
 
                        /* Only delete-marked records should be purged. */
397
 
                        ut_ad(REC_INFO_DELETED_FLAG
398
 
                              & rec_get_info_bits(
399
 
                                      btr_cur_get_rec(btr_cur),
400
 
                                      dict_table_is_comp(index->table)));
401
 
 
402
 
                        if (!btr_cur_optimistic_delete(btr_cur, &mtr)) {
403
 
 
404
 
                                /* The index entry could not be deleted. */
405
 
                                success = FALSE;
406
 
                                goto func_exit;
407
 
                        }
408
 
                }
409
 
                /* fall through (the index entry is still needed,
410
 
                or the deletion succeeded) */
411
 
        case ROW_NOT_DELETED_REF:
412
 
                /* The index entry is still needed. */
413
 
        case ROW_BUFFERED:
414
 
                /* The deletion was buffered. */
415
 
        case ROW_NOT_FOUND:
416
 
                /* The index entry does not exist, nothing to do. */
417
 
                success = TRUE;
418
 
        func_exit:
419
 
                btr_pcur_close(&pcur);
420
 
                mtr_commit(&mtr);
421
 
                return(success);
422
 
        }
423
 
 
424
 
        ut_error;
425
 
        return(FALSE);
426
 
}
427
 
 
428
302
/***********************************************************//**
429
303
Removes a secondary index entry if possible. */
430
304
UNIV_INLINE
440
314
 
441
315
        /*      fputs("Purge: Removing secondary record\n", stderr); */
442
316
 
443
 
        if (row_purge_remove_sec_if_poss_leaf(node, index, entry)) {
 
317
        success = row_purge_remove_sec_if_poss_low(node, index, entry,
 
318
                                                   BTR_MODIFY_LEAF);
 
319
        if (success) {
444
320
 
445
321
                return;
446
322
        }
447
323
retry:
448
 
        success = row_purge_remove_sec_if_poss_tree(node, index, entry);
 
324
        success = row_purge_remove_sec_if_poss_low(node, index, entry,
 
325
                                                   BTR_MODIFY_TREE);
449
326
        /* The delete operation may fail if we have little
450
327
        file space left: TODO: easiest to crash the database
451
328
        and restart with more file space */
626
503
        byte*           ptr;
627
504
        trx_t*          trx;
628
505
        undo_no_t       undo_no;
629
 
        table_id_t      table_id;
 
506
        dulint          table_id;
630
507
        trx_id_t        trx_id;
631
508
        roll_ptr_t      roll_ptr;
632
509
        ulint           info_bits;
796
673
        que_thr_t*      thr)    /*!< in: query thread */
797
674
{
798
675
        purge_node_t*   node;
799
 
#ifdef UNIV_DEBUG
800
676
        ulint           err;
801
 
#endif /* UNIV_DEBUG */
802
677
 
803
678
        ut_ad(thr);
804
679
 
805
 
        node = static_cast<purge_node_t *>(thr->run_node);
 
680
        node = thr->run_node;
806
681
 
807
682
        ut_ad(que_node_get_type(node) == QUE_NODE_PURGE);
808
683
 
809
 
#ifdef UNIV_DEBUG
810
 
        err =
811
 
#endif /* UNIV_DEBUG */
812
 
        row_purge(node, thr);
 
684
        err = row_purge(node, thr);
813
685
 
814
 
#ifdef UNIV_DEBUG
815
 
        ut_a(err == DB_SUCCESS);
816
 
#endif /* UNIV_DEBUG */
 
686
        ut_ad(err == DB_SUCCESS);
817
687
 
818
688
        return(thr);
819
689
}