← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-11-13 03:36:33 UTC
  • mto: This revision was merged to the branch mainline in revision 1929.
  • Revision ID: brian@tangent.org-20101113033633-3v9ep5ow832wmf4s
Merge up the tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/row/row0umod.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1997, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1997, 2010, 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
58
58
some of its fields were changed. Now, it is possible that the delete marked
59
59
version has become obsolete at the time the undo is started. */
60
60
 
61
 
/*************************************************************************
62
 
IMPORTANT NOTE: Any operation that generates redo MUST check that there
63
 
is enough space in the redo log before for that operation. This is
64
 
done by calling log_free_check(). The reason for checking the
65
 
availability of the redo log space before the start of the operation is
66
 
that we MUST not hold any synchonization objects when performing the
67
 
check.
68
 
If you make a change in this module make sure that no codepath is
69
 
introduced where a call to log_free_check() is bypassed. */
70
 
 
71
61
/***********************************************************//**
72
62
Checks if also the previous version of the clustered index record was
73
63
modified or inserted by the same transaction, and its undo number is such
74
64
that it should be undone in the same rollback.
75
65
@return TRUE if also previous modify or insert of this row should be undone */
76
 
static
 
66
UNIV_INLINE
77
67
ibool
78
68
row_undo_mod_undo_also_prev_vers(
79
69
/*=============================*/
85
75
 
86
76
        trx = node->trx;
87
77
 
88
 
        if (node->new_trx_id != trx->id) {
 
78
        if (0 != ut_dulint_cmp(node->new_trx_id, trx->id)) {
89
79
 
90
 
                *undo_no = 0;
 
80
                *undo_no = ut_dulint_zero;
91
81
                return(FALSE);
92
82
        }
93
83
 
95
85
 
96
86
        *undo_no = trx_undo_rec_get_undo_no(undo_rec);
97
87
 
98
 
        return(trx->roll_limit <= *undo_no);
 
88
        return(ut_dulint_cmp(trx->roll_limit, *undo_no) <= 0);
99
89
}
100
90
 
101
91
/***********************************************************//**
114
104
        btr_pcur_t*     pcur;
115
105
        btr_cur_t*      btr_cur;
116
106
        ulint           err;
117
 
#ifdef UNIV_DEBUG
118
107
        ibool           success;
119
 
#endif /* UNIV_DEBUG */
120
108
 
121
109
        pcur = &(node->pcur);
122
110
        btr_cur = btr_pcur_get_btr_cur(pcur);
123
111
 
124
 
#ifdef UNIV_DEBUG
125
 
        success =
126
 
#endif /* UNIV_DEBUG */
127
 
        btr_pcur_restore_position(mode, pcur, mtr);
 
112
        success = btr_pcur_restore_position(mode, pcur, mtr);
128
113
 
129
114
        ut_ad(success);
130
115
 
246
231
 
247
232
        ut_ad(node && thr);
248
233
 
249
 
        log_free_check();
250
 
 
251
234
        /* Check if also the previous version of the clustered index record
252
235
        should be undone in this same rollback operation */
253
236
 
331
314
        ulint           mode)   /*!< in: latch mode BTR_MODIFY_LEAF or
332
315
                                BTR_MODIFY_TREE */
333
316
{
334
 
        btr_pcur_t              pcur;
335
 
        btr_cur_t*              btr_cur;
336
 
        ibool                   success;
337
 
        ibool                   old_has;
338
 
        ulint                   err;
339
 
        mtr_t                   mtr;
340
 
        mtr_t                   mtr_vers;
341
 
        enum row_search_result  search_result;
 
317
        ibool           found;
 
318
        btr_pcur_t      pcur;
 
319
        btr_cur_t*      btr_cur;
 
320
        ibool           success;
 
321
        ibool           old_has;
 
322
        ulint           err;
 
323
        mtr_t           mtr;
 
324
        mtr_t           mtr_vers;
342
325
 
343
326
        log_free_check();
344
327
        mtr_start(&mtr);
345
328
 
 
329
        found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
 
330
 
346
331
        btr_cur = btr_pcur_get_btr_cur(&pcur);
347
332
 
348
 
        ut_ad(mode == BTR_MODIFY_TREE || mode == BTR_MODIFY_LEAF);
349
 
 
350
 
        search_result = row_search_index_entry(index, entry, mode,
351
 
                                               &pcur, &mtr);
352
 
 
353
 
        switch (UNIV_EXPECT(search_result, ROW_FOUND)) {
354
 
        case ROW_NOT_FOUND:
 
333
        if (!found) {
355
334
                /* In crash recovery, the secondary index record may
356
335
                be missing if the UPDATE did not have time to insert
357
336
                the secondary index records before the crash.  When we
362
341
                before it has inserted all updated secondary index
363
342
                records, then the undo will not find those records. */
364
343
 
365
 
                err = DB_SUCCESS;
366
 
                goto func_exit;
367
 
        case ROW_FOUND:
368
 
                break;
369
 
        case ROW_BUFFERED:
370
 
        case ROW_NOT_DELETED_REF:
371
 
                /* These are invalid outcomes, because the mode passed
372
 
                to row_search_index_entry() did not include any of the
373
 
                flags BTR_INSERT, BTR_DELETE, or BTR_DELETE_MARK. */
374
 
                ut_error;
 
344
                btr_pcur_close(&pcur);
 
345
                mtr_commit(&mtr);
 
346
 
 
347
                return(DB_SUCCESS);
375
348
        }
376
349
 
377
350
        /* We should remove the index record if no prior version of the row,
421
394
        }
422
395
 
423
396
        btr_pcur_commit_specify_mtr(&(node->pcur), &mtr_vers);
424
 
 
425
 
func_exit:
426
397
        btr_pcur_close(&pcur);
427
398
        mtr_commit(&mtr);
428
399
 
477
448
        dict_index_t*   index,  /*!< in: index */
478
449
        const dtuple_t* entry)  /*!< in: index entry */
479
450
{
480
 
        mem_heap_t*             heap;
481
 
        btr_pcur_t              pcur;
482
 
        btr_cur_t*              btr_cur;
483
 
        upd_t*                  update;
484
 
        ulint                   err             = DB_SUCCESS;
485
 
        big_rec_t*              dummy_big_rec;
486
 
        mtr_t                   mtr;
487
 
        trx_t*                  trx             = thr_get_trx(thr);
488
 
        enum row_search_result  search_result;
 
451
        mem_heap_t*     heap;
 
452
        btr_pcur_t      pcur;
 
453
        upd_t*          update;
 
454
        ulint           err             = DB_SUCCESS;
 
455
        big_rec_t*      dummy_big_rec;
 
456
        mtr_t           mtr;
 
457
        trx_t*          trx             = thr_get_trx(thr);
489
458
 
490
459
        /* Ignore indexes that are being created. */
491
460
        if (UNIV_UNLIKELY(*index->name == TEMP_INDEX_PREFIX)) {
496
465
        log_free_check();
497
466
        mtr_start(&mtr);
498
467
 
499
 
        ut_ad(mode == BTR_MODIFY_TREE || mode == BTR_MODIFY_LEAF);
500
 
 
501
 
        search_result = row_search_index_entry(index, entry, mode,
502
 
                                               &pcur, &mtr);
503
 
 
504
 
        switch (search_result) {
505
 
        case ROW_BUFFERED:
506
 
        case ROW_NOT_DELETED_REF:
507
 
                /* These are invalid outcomes, because the mode passed
508
 
                to row_search_index_entry() did not include any of the
509
 
                flags BTR_INSERT, BTR_DELETE, or BTR_DELETE_MARK. */
510
 
                ut_error;
511
 
        case ROW_NOT_FOUND:
 
468
        if (UNIV_UNLIKELY(!row_search_index_entry(index, entry,
 
469
                                                  mode, &pcur, &mtr))) {
512
470
                fputs("InnoDB: error in sec index entry del undo in\n"
513
471
                      "InnoDB: ", stderr);
514
472
                dict_index_name_print(stderr, trx, index);
523
481
                fputs("\n"
524
482
                      "InnoDB: Submit a detailed bug report"
525
483
                      " to http://bugs.mysql.com\n", stderr);
526
 
                break;
527
 
        case ROW_FOUND:
528
 
                btr_cur = btr_pcur_get_btr_cur(&pcur);
 
484
        } else {
 
485
                btr_cur_t*      btr_cur = btr_pcur_get_btr_cur(&pcur);
 
486
 
529
487
                err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG,
530
488
                                                   btr_cur, FALSE, thr, &mtr);
531
489
                ut_a(err == DB_SUCCESS);
699
657
                        /* Build the newest version of the index entry */
700
658
                        entry = row_build_index_entry(node->row, node->ext,
701
659
                                                      index, heap);
702
 
                        if (UNIV_UNLIKELY(!entry)) {
703
 
                                /* The server must have crashed in
704
 
                                row_upd_clust_rec_by_insert(), in
705
 
                                row_ins_index_entry_low() before
706
 
                                btr_store_big_rec_extern_fields()
707
 
                                has written the externally stored columns
708
 
                                (BLOBs) of the new clustered index entry. */
709
 
 
710
 
                                /* The table must be in DYNAMIC or COMPRESSED
711
 
                                format.  REDUNDANT and COMPACT formats
712
 
                                store a local 768-byte prefix of each
713
 
                                externally stored column. */
714
 
                                ut_a(dict_table_get_format(index->table)
715
 
                                     >= DICT_TF_FORMAT_ZIP);
716
 
 
717
 
                                /* This is only legitimate when
718
 
                                rolling back an incomplete transaction
719
 
                                after crash recovery. */
720
 
                                ut_a(thr_get_trx(thr)->is_recovered);
721
 
 
722
 
                                /* The server must have crashed before
723
 
                                completing the insert of the new
724
 
                                clustered index entry and before
725
 
                                inserting to the secondary indexes.
726
 
                                Because node->row was not yet written
727
 
                                to this index, we can ignore it.  But
728
 
                                we must restore node->undo_row. */
729
 
                        } else {
730
 
                                /* NOTE that if we updated the fields of a
731
 
                                delete-marked secondary index record so that
732
 
                                alphabetically they stayed the same, e.g.,
733
 
                                'abc' -> 'aBc', we cannot return to the
734
 
                                original values because we do not know them.
735
 
                                But this should not cause problems because
736
 
                                in row0sel.c, in queries we always retrieve
737
 
                                the clustered index record or an earlier
738
 
                                version of it, if the secondary index record
739
 
                                through which we do the search is
740
 
                                delete-marked. */
741
 
 
742
 
                                err = row_undo_mod_del_mark_or_remove_sec(
743
 
                                        node, thr, index, entry);
744
 
                                if (err != DB_SUCCESS) {
745
 
                                        mem_heap_free(heap);
746
 
 
747
 
                                        return(err);
748
 
                                }
749
 
 
750
 
                                mem_heap_empty(heap);
 
660
                        ut_a(entry);
 
661
                        /* NOTE that if we updated the fields of a
 
662
                        delete-marked secondary index record so that
 
663
                        alphabetically they stayed the same, e.g.,
 
664
                        'abc' -> 'aBc', we cannot return to the original
 
665
                        values because we do not know them. But this should
 
666
                        not cause problems because in row0sel.c, in queries
 
667
                        we always retrieve the clustered index record or an
 
668
                        earlier version of it, if the secondary index record
 
669
                        through which we do the search is delete-marked. */
 
670
 
 
671
                        err = row_undo_mod_del_mark_or_remove_sec(node, thr,
 
672
                                                                  index,
 
673
                                                                  entry);
 
674
                        if (err != DB_SUCCESS) {
 
675
                                mem_heap_free(heap);
 
676
 
 
677
                                return(err);
751
678
                        }
752
679
 
753
680
                        /* We may have to update the delete mark in the
756
683
                        the secondary index record if we updated its fields
757
684
                        but alphabetically they stayed the same, e.g.,
758
685
                        'abc' -> 'aBc'. */
 
686
                        mem_heap_empty(heap);
759
687
                        entry = row_build_index_entry(node->undo_row,
760
688
                                                      node->undo_ext,
761
689
                                                      index, heap);
795
723
        dict_index_t*   clust_index;
796
724
        byte*           ptr;
797
725
        undo_no_t       undo_no;
798
 
        table_id_t      table_id;
 
726
        dulint          table_id;
799
727
        trx_id_t        trx_id;
800
728
        roll_ptr_t      roll_ptr;
801
729
        ulint           info_bits;