Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/row/row0umod.c File Reference

#include "row0umod.h"
#include "dict0dict.h"
#include "dict0boot.h"
#include "trx0undo.h"
#include "trx0roll.h"
#include "btr0btr.h"
#include "mach0data.h"
#include "row0undo.h"
#include "row0vers.h"
#include "trx0trx.h"
#include "trx0rec.h"
#include "row0row.h"
#include "row0upd.h"
#include "que0que.h"
#include "log0log.h"

Include dependency graph for row0umod.c:

Go to the source code of this file.

Functions
UNIV_INLINE ibool	row_undo_mod_undo_also_prev_vers (undo_node_t *node, dulint *undo_no)
static ulint	row_undo_mod_clust_low (undo_node_t *node, que_thr_t *thr, mtr_t *mtr, ulint mode)
static ulint	row_undo_mod_remove_clust_low (undo_node_t *node, que_thr_t *thr __attribute__((unused)), mtr_t *mtr, ulint mode)
static ulint	row_undo_mod_clust (undo_node_t *node, que_thr_t *thr)
static ulint	row_undo_mod_del_mark_or_remove_sec_low (undo_node_t *node, que_thr_t *thr, dict_index_t *index, dtuple_t *entry, ulint mode)
static ulint	row_undo_mod_del_mark_or_remove_sec (undo_node_t *node, que_thr_t *thr, dict_index_t *index, dtuple_t *entry)
static ulint	row_undo_mod_del_unmark_sec_and_undo_update (ulint mode, que_thr_t *thr, dict_index_t *index, dtuple_t *entry)
static ulint	row_undo_mod_upd_del_sec (undo_node_t *node, que_thr_t *thr)
static ulint	row_undo_mod_del_mark_sec (undo_node_t *node, que_thr_t *thr)
static ulint	row_undo_mod_upd_exist_sec (undo_node_t *node, que_thr_t *thr)
static void	row_undo_mod_parse_undo_rec (undo_node_t *node, que_thr_t *thr)
ulint	row_undo_mod (undo_node_t *node, que_thr_t *thr)

---

Function Documentation

ulint row_undo_mod	(	undo_node_t *	node,
		que_thr_t *	thr
	)

Definition at line 711 of file row0umod.c.

References DB_SUCCESS, dict_table_get_first_index(), dict_table_get_next_index(), err, FALSE, undo_node_struct::index, NULL, undo_node_struct::rec_type, row_undo_mod_clust(), row_undo_mod_del_mark_sec(), row_undo_mod_parse_undo_rec(), row_undo_mod_upd_del_sec(), row_undo_mod_upd_exist_sec(), row_undo_search_clust_to_pcur(), undo_node_struct::state, undo_node_struct::table, undo_node_struct::trx, TRX_UNDO_DEL_MARK_REC, trx_undo_rec_release(), TRX_UNDO_UPD_DEL_REC, TRX_UNDO_UPD_EXIST_REC, undo_node_struct::undo_no, UNDO_NODE_FETCH_NEXT, UNDO_NODE_MODIFY, and ut_ad.

Referenced by row_undo().

                                      : DB_SUCCESS or error code */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        ibool   found;
        ulint   err;

        ut_ad(node && thr);
        ut_ad(node->state == UNDO_NODE_MODIFY);

        row_undo_mod_parse_undo_rec(node, thr);

        if (node->table == NULL) {
                found = FALSE;
        } else {
                found = row_undo_search_clust_to_pcur(node);
        }

        if (!found) {
                /* It is already undone, or will be undone by another query
                thread, or table was dropped */

                trx_undo_rec_release(node->trx, node->undo_no);
                node->state = UNDO_NODE_FETCH_NEXT;

                return(DB_SUCCESS);
        }

        node->index = dict_table_get_next_index(
                                dict_table_get_first_index(node->table));

        if (node->rec_type == TRX_UNDO_UPD_EXIST_REC) {

                err = row_undo_mod_upd_exist_sec(node, thr);

        } else if (node->rec_type == TRX_UNDO_DEL_MARK_REC) {

                err = row_undo_mod_del_mark_sec(node, thr);
        } else {
                ut_ad(node->rec_type == TRX_UNDO_UPD_DEL_REC);
                err = row_undo_mod_upd_del_sec(node, thr);
        }

        if (err != DB_SUCCESS) {

                return(err);
        }

        err = row_undo_mod_clust(node, thr);

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_clust	(	undo_node_t *	node,
		que_thr_t *	thr
	)			[static]

Definition at line 189 of file row0umod.c.

References BTR_MODIFY_LEAF, BTR_MODIFY_TREE, btr_pcur_commit_specify_mtr(), DB_SUCCESS, err, mtr_start(), undo_node_struct::pcur, undo_node_struct::rec_type, row_undo_mod_clust_low(), row_undo_mod_remove_clust_low(), row_undo_mod_undo_also_prev_vers(), undo_node_struct::state, undo_node_struct::trx, trx_undo_rec_release(), trx_undo_rec_reserve(), TRX_UNDO_UPD_DEL_REC, undo_node_struct::undo_no, UNDO_NODE_FETCH_NEXT, UNDO_NODE_PREV_VERS, and ut_ad.

Referenced by row_undo_mod().

                                      : DB_SUCCESS or error code: we may run
                                out of file space */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        btr_pcur_t*     pcur;
        mtr_t           mtr;
        ulint           err;
        ibool           success;
        ibool           more_vers;
        dulint          new_undo_no;

        ut_ad(node && thr);

        /* Check if also the previous version of the clustered index record
        should be undone in this same rollback operation */

        more_vers = row_undo_mod_undo_also_prev_vers(node, &new_undo_no);

        pcur = &(node->pcur);

        mtr_start(&mtr);

        /* Try optimistic processing of the record, keeping changes within
        the index page */

        err = row_undo_mod_clust_low(node, thr, &mtr, BTR_MODIFY_LEAF);

        if (err != DB_SUCCESS) {
                btr_pcur_commit_specify_mtr(pcur, &mtr);

                /* We may have to modify tree structure: do a pessimistic
                descent down the index tree */

                mtr_start(&mtr);

                err = row_undo_mod_clust_low(node, thr, &mtr, BTR_MODIFY_TREE);
        }

        btr_pcur_commit_specify_mtr(pcur, &mtr);

        if (err == DB_SUCCESS && node->rec_type == TRX_UNDO_UPD_DEL_REC) {

                mtr_start(&mtr);

                err = row_undo_mod_remove_clust_low(node, thr, &mtr,
                                                        BTR_MODIFY_LEAF);
                if (err != DB_SUCCESS) {
                        btr_pcur_commit_specify_mtr(pcur, &mtr);

                        /* We may have to modify tree structure: do a
                        pessimistic descent down the index tree */

                        mtr_start(&mtr);

                        err = row_undo_mod_remove_clust_low(node, thr, &mtr,
                                                        BTR_MODIFY_TREE);
                }

                btr_pcur_commit_specify_mtr(pcur, &mtr);
        }

        node->state = UNDO_NODE_FETCH_NEXT;

        trx_undo_rec_release(node->trx, node->undo_no);

        if (more_vers && err == DB_SUCCESS) {

                /* Reserve the undo log record to the prior version after
                committing &mtr: this is necessary to comply with the latching
                order, as &mtr may contain the fsp latch which is lower in
                the latch hierarchy than trx->undo_mutex. */

                success = trx_undo_rec_reserve(node->trx, new_undo_no);

                if (success) {
                        node->state = UNDO_NODE_PREV_VERS;
                }
        }

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_clust_low	(	undo_node_t *	node,
		que_thr_t *	thr,
		mtr_t *	mtr,
		ulint	mode
	)			[static]

Definition at line 79 of file row0umod.c.

References btr_cur_optimistic_update(), btr_cur_pessimistic_update(), BTR_KEEP_SYS_FLAG, BTR_MODIFY_LEAF, BTR_MODIFY_TREE, BTR_NO_LOCKING_FLAG, BTR_NO_UNDO_LOG_FLAG, btr_pcur_get_btr_cur(), btr_pcur_restore_position(), undo_node_struct::cmpl_info, err, undo_node_struct::pcur, undo_node_struct::update, and ut_ad.

Referenced by row_undo_mod_clust().

                                      : DB_SUCCESS, DB_FAIL, or error code:
                                we may run out of file space */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr,    /* in: query thread */
        mtr_t*          mtr,    /* in: mtr */
        ulint           mode)   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */
{
        big_rec_t*      dummy_big_rec;
        btr_pcur_t*     pcur;
        btr_cur_t*      btr_cur;
        ulint           err;
        ibool           success;

        pcur = &(node->pcur);
        btr_cur = btr_pcur_get_btr_cur(pcur);

        success = btr_pcur_restore_position(mode, pcur, mtr);

        ut_ad(success);

        if (mode == BTR_MODIFY_LEAF) {

                err = btr_cur_optimistic_update(BTR_NO_LOCKING_FLAG
                                        | BTR_NO_UNDO_LOG_FLAG
                                        | BTR_KEEP_SYS_FLAG,
                                        btr_cur, node->update,
                                        node->cmpl_info, thr, mtr);
        } else {
                ut_ad(mode == BTR_MODIFY_TREE);

                err = btr_cur_pessimistic_update(BTR_NO_LOCKING_FLAG
                                        | BTR_NO_UNDO_LOG_FLAG
                                        | BTR_KEEP_SYS_FLAG,
                                        btr_cur, &dummy_big_rec, node->update,
                                        node->cmpl_info, thr, mtr);
        }

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_del_mark_or_remove_sec	(	undo_node_t *	node,
		que_thr_t *	thr,
		dict_index_t *	index,
		dtuple_t *	entry
	)			[static]

Definition at line 370 of file row0umod.c.

References BTR_MODIFY_LEAF, BTR_MODIFY_TREE, DB_SUCCESS, err, index(), and row_undo_mod_del_mark_or_remove_sec_low().

Referenced by row_undo_mod_upd_del_sec(), and row_undo_mod_upd_exist_sec().

                                      : DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr,    /* in: query thread */
        dict_index_t*   index,  /* in: index */
        dtuple_t*       entry)  /* in: index entry */
{
        ulint   err;

        err = row_undo_mod_del_mark_or_remove_sec_low(node, thr, index,
                                                entry, BTR_MODIFY_LEAF);
        if (err == DB_SUCCESS) {

                return(err);
        }

        err = row_undo_mod_del_mark_or_remove_sec_low(node, thr, index,
                                                entry, BTR_MODIFY_TREE);
        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_del_mark_or_remove_sec_low	(	undo_node_t *	node,
		que_thr_t *	thr,
		dict_index_t *	index,
		dtuple_t *	entry,
		ulint	mode
	)			[static]

Definition at line 278 of file row0umod.c.

References btr_cur_del_mark_set_sec_rec(), btr_cur_optimistic_delete(), btr_cur_pessimistic_delete(), BTR_MODIFY_LEAF, BTR_MODIFY_TREE, BTR_NO_LOCKING_FLAG, btr_pcur_close(), btr_pcur_commit_specify_mtr(), btr_pcur_get_btr_cur(), btr_pcur_get_rec(), btr_pcur_restore_position(), BTR_SEARCH_LEAF, DB_FAIL, DB_SUCCESS, err, FALSE, index(), log_free_check(), mtr_commit(), mtr_start(), undo_node_struct::pcur, row_search_index_entry(), row_vers_old_has_index_entry(), TRUE, ut_a, and ut_ad.

Referenced by row_undo_mod_del_mark_or_remove_sec().

                                      : DB_SUCCESS, DB_FAIL, or
                                DB_OUT_OF_FILE_SPACE */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr,    /* in: query thread */
        dict_index_t*   index,  /* in: index */
        dtuple_t*       entry,  /* in: index entry */
        ulint           mode)   /* in: latch mode BTR_MODIFY_LEAF or
                                BTR_MODIFY_TREE */
{
        ibool           found;
        btr_pcur_t      pcur;
        btr_cur_t*      btr_cur;
        ibool           success;
        ibool           old_has;
        ulint           err;
        mtr_t           mtr;
        mtr_t           mtr_vers;

        log_free_check();
        mtr_start(&mtr);

        found = row_search_index_entry(index, entry, mode, &pcur, &mtr);

        btr_cur = btr_pcur_get_btr_cur(&pcur);

        if (!found) {
                /* Not found */

                btr_pcur_close(&pcur);
                mtr_commit(&mtr);

                return(DB_SUCCESS);
        }

        /* We should remove the index record if no prior version of the row,
        which cannot be purged yet, requires its existence. If some requires,
        we should delete mark the record. */

        mtr_start(&mtr_vers);

        success = btr_pcur_restore_position(BTR_SEARCH_LEAF, &(node->pcur),
                                                                &mtr_vers);
        ut_a(success);

        old_has = row_vers_old_has_index_entry(FALSE,
                                        btr_pcur_get_rec(&(node->pcur)),
                                        &mtr_vers, index, entry);
        if (old_has) {
                err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG,
                                                btr_cur, TRUE, thr, &mtr);
                ut_ad(err == DB_SUCCESS);
        } else {
                /* Remove the index record */

                if (mode == BTR_MODIFY_LEAF) {
                        success = btr_cur_optimistic_delete(btr_cur, &mtr);
                        if (success) {
                                err = DB_SUCCESS;
                        } else {
                                err = DB_FAIL;
                        }
                } else {
                        ut_ad(mode == BTR_MODIFY_TREE);

                        btr_cur_pessimistic_delete(&err, FALSE, btr_cur,
                                                                TRUE, &mtr);

                        /* The delete operation may fail if we have little
                        file space left: TODO: easiest to crash the database
                        and restart with more file space */
                }
        }

        btr_pcur_commit_specify_mtr(&(node->pcur), &mtr_vers);
        btr_pcur_close(&pcur);
        mtr_commit(&mtr);

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_del_mark_sec	(	undo_node_t *	node,
		que_thr_t *	thr
	)			[static]

Definition at line 521 of file row0umod.c.

References BTR_MODIFY_LEAF, BTR_MODIFY_TREE, DB_FAIL, DB_SUCCESS, dict_table_get_next_index(), err, undo_node_struct::index, index(), mem_heap_create, mem_heap_free, NULL, undo_node_struct::row, row_build_index_entry(), and row_undo_mod_del_unmark_sec_and_undo_update().

Referenced by row_undo_mod().

                                      : DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        mem_heap_t*     heap;
        dtuple_t*       entry;
        dict_index_t*   index;
        ulint           err;

        heap = mem_heap_create(1024);

        while (node->index != NULL) {
                index = node->index;

                entry = row_build_index_entry(node->row, index, heap);

                err = row_undo_mod_del_unmark_sec_and_undo_update(
                                                BTR_MODIFY_LEAF,
                                                thr, index, entry);
                if (err == DB_FAIL) {
                        err = row_undo_mod_del_unmark_sec_and_undo_update(
                                                BTR_MODIFY_TREE,
                                                thr, index, entry);
                }

                if (err != DB_SUCCESS) {

                        mem_heap_free(heap);

                        return(err);
                }

                node->index = dict_table_get_next_index(node->index);
        }

        mem_heap_free(heap);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_del_unmark_sec_and_undo_update	(	ulint	mode,
		que_thr_t *	thr,
		dict_index_t *	index,
		dtuple_t *	entry
	)			[static]

Definition at line 399 of file row0umod.c.

References btr_cur_del_mark_set_sec_rec(), btr_cur_get_rec(), btr_cur_optimistic_update(), btr_cur_pessimistic_update(), BTR_KEEP_SYS_FLAG, BTR_MODIFY_LEAF, BTR_MODIFY_TREE, BTR_NO_LOCKING_FLAG, btr_pcur_close(), btr_pcur_get_btr_cur(), btr_pcur_get_rec(), DB_FAIL, DB_OVERFLOW, DB_SUCCESS, DB_UNDERFLOW, dict_index_name_print(), dtuple_print(), err, FALSE, index(), log_free_check(), mem_heap_create, mem_heap_free, mtr_commit(), mtr_start(), rec_print(), row_search_index_entry(), row_upd_build_sec_rec_difference_binary(), thr_get_trx(), trx_print(), upd_get_n_fields(), update, and ut_a.

Referenced by row_undo_mod_del_mark_sec(), and row_undo_mod_upd_exist_sec().

                                      : DB_FAIL or DB_SUCCESS or
                                DB_OUT_OF_FILE_SPACE */
        ulint           mode,   /* in: search mode: BTR_MODIFY_LEAF or
                                BTR_MODIFY_TREE */
        que_thr_t*      thr,    /* in: query thread */
        dict_index_t*   index,  /* in: index */
        dtuple_t*       entry)  /* in: index entry */
{
        mem_heap_t*     heap;
        btr_pcur_t      pcur;
        upd_t*          update;
        ulint           err             = DB_SUCCESS;
        ibool           found;
        big_rec_t*      dummy_big_rec;
        mtr_t           mtr;
        trx_t*          trx             = thr_get_trx(thr);

        log_free_check();
        mtr_start(&mtr);

        found = row_search_index_entry(index, entry, mode, &pcur, &mtr);

        if (!found) {
                fputs("InnoDB: error in sec index entry del undo in\n"
                        "InnoDB: ", stderr);
                dict_index_name_print(stderr, trx, index);
                fputs("\n"
                        "InnoDB: tuple ", stderr);
                dtuple_print(stderr, entry);
                fputs("\n"
                        "InnoDB: record ", stderr);
                rec_print(stderr, btr_pcur_get_rec(&pcur), index);
                putc('\n', stderr);
                trx_print(stderr, trx, 0);
                fputs("\n"
"InnoDB: Submit a detailed bug report to http://bugs.mysql.com\n", stderr);
        } else {
                btr_cur_t*      btr_cur = btr_pcur_get_btr_cur(&pcur);

                err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG,
                                                btr_cur, FALSE, thr, &mtr);
                ut_a(err == DB_SUCCESS);
                heap = mem_heap_create(100);

                update = row_upd_build_sec_rec_difference_binary(index, entry,
                        btr_cur_get_rec(btr_cur), trx, heap);
                if (upd_get_n_fields(update) == 0) {

                        /* Do nothing */

                } else if (mode == BTR_MODIFY_LEAF) {
                        /* Try an optimistic updating of the record, keeping
                        changes within the page */

                        err = btr_cur_optimistic_update(BTR_KEEP_SYS_FLAG
                                                        | BTR_NO_LOCKING_FLAG,
                                                btr_cur, update, 0, thr, &mtr);
                        if (err == DB_OVERFLOW || err == DB_UNDERFLOW) {
                                err = DB_FAIL;
                        }
                } else {
                        ut_a(mode == BTR_MODIFY_TREE);
                        err = btr_cur_pessimistic_update(BTR_KEEP_SYS_FLAG
                                                        | BTR_NO_LOCKING_FLAG,
                                                btr_cur, &dummy_big_rec,
                                                update, 0, thr, &mtr);
                }

                mem_heap_free(heap);
        }

        btr_pcur_close(&pcur);
        mtr_commit(&mtr);

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void row_undo_mod_parse_undo_rec	(	undo_node_t *	node,
		que_thr_t *	thr
	)			[static]

Definition at line 651 of file row0umod.c.

References undo_node_struct::cmpl_info, dict_table_get_first_index(), dict_table_get_on_id(), undo_node_struct::heap, dict_table_struct::ibd_file_missing, undo_node_struct::new_roll_ptr, undo_node_struct::new_trx_id, NULL, undo_node_struct::rec_type, undo_node_struct::ref, undo_node_struct::table, thr_get_trx(), trx_undo_rec_get_pars(), trx_undo_rec_get_row_ref(), trx_undo_update_rec_get_sys_cols(), trx_undo_update_rec_get_update(), undo_node_struct::undo_rec, undo_node_struct::update, and ut_ad.

Referenced by row_undo_mod().

                                     : row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        dict_index_t*   clust_index;
        byte*           ptr;
        dulint          undo_no;
        dulint          table_id;
        dulint          trx_id;
        dulint          roll_ptr;
        ulint           info_bits;
        ulint           type;
        ulint           cmpl_info;
        ibool           dummy_extern;
        trx_t*          trx;

        ut_ad(node && thr);
        trx = thr_get_trx(thr);
        ptr = trx_undo_rec_get_pars(node->undo_rec, &type, &cmpl_info,
                                        &dummy_extern, &undo_no, &table_id);
        node->rec_type = type;

        node->table = dict_table_get_on_id(table_id, trx);

        /* TODO: other fixes associated with DROP TABLE + rollback in the
        same table by another user */

        if (node->table == NULL) {
                /* Table was dropped */
                return;
        }

        if (node->table->ibd_file_missing) {
                /* We skip undo operations to missing .ibd files */
                node->table = NULL;

                return;
        }

        clust_index = dict_table_get_first_index(node->table);

        ptr = trx_undo_update_rec_get_sys_cols(ptr, &trx_id, &roll_ptr,
                                                                &info_bits);

        ptr = trx_undo_rec_get_row_ref(ptr, clust_index, &(node->ref),
                                                                node->heap);

        trx_undo_update_rec_get_update(ptr, clust_index, type, trx_id,
                                        roll_ptr, info_bits, trx,
                                        node->heap, &(node->update));
        node->new_roll_ptr = roll_ptr;
        node->new_trx_id = trx_id;
        node->cmpl_info = cmpl_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_remove_clust_low	(	undo_node_t *	node,
		que_thr_t *thr	__attribute__((unused)),
		mtr_t *	mtr,
		ulint	mode
	)			[static]

Definition at line 125 of file row0umod.c.

References btr_cur_optimistic_delete(), btr_cur_pessimistic_delete(), BTR_MODIFY_LEAF, BTR_MODIFY_TREE, btr_pcur_get_btr_cur(), btr_pcur_restore_position(), DB_FAIL, DB_SUCCESS, err, FALSE, undo_node_struct::new_trx_id, undo_node_struct::pcur, undo_node_struct::rec_type, row_vers_must_preserve_del_marked(), TRX_UNDO_UPD_DEL_REC, and ut_ad.

Referenced by row_undo_mod_clust().

                                      : DB_SUCCESS, DB_FAIL, or error code:
                                we may run out of file space */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr __attribute__((unused)), /* in: query thread */
        mtr_t*          mtr,    /* in: mtr */
        ulint           mode)   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */
{
        btr_pcur_t*     pcur;
        btr_cur_t*      btr_cur;
        ulint           err;
        ibool           success;

        pcur = &(node->pcur);
        btr_cur = btr_pcur_get_btr_cur(pcur);

        success = btr_pcur_restore_position(mode, pcur, mtr);

        if (!success) {

                return(DB_SUCCESS);
        }

        /* Find out if we can remove the whole clustered index record */

        if (node->rec_type == TRX_UNDO_UPD_DEL_REC
                && !row_vers_must_preserve_del_marked(node->new_trx_id, mtr)) {

                /* Ok, we can remove */
        } else {
                return(DB_SUCCESS);
        }

        if (mode == BTR_MODIFY_LEAF) {
                success = btr_cur_optimistic_delete(btr_cur, mtr);

                if (success) {
                        err = DB_SUCCESS;
                } else {
                        err = DB_FAIL;
                }
        } else {
                ut_ad(mode == BTR_MODIFY_TREE);

                /* Note that since this operation is analogous to purge,
                we can free also inherited externally stored fields:
                hence the last FALSE in the call below */

                btr_cur_pessimistic_delete(&err, FALSE, btr_cur, FALSE, mtr);

                /* The delete operation may fail if we have little
                file space left: TODO: easiest to crash the database
                and restart with more file space */
        }

        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UNIV_INLINE ibool row_undo_mod_undo_also_prev_vers	(	undo_node_t *	node,
		dulint *	undo_no
	)

Definition at line 50 of file row0umod.c.

References FALSE, undo_node_struct::heap, trx_struct::id, undo_node_struct::new_roll_ptr, undo_node_struct::new_trx_id, trx_struct::roll_limit, undo_node_struct::trx, trx_undo_get_undo_rec_low(), trx_undo_rec_get_undo_no(), ut_dulint_cmp(), and ut_dulint_zero.

Referenced by row_undo_mod_clust().

                                      : TRUE if also previous modify or
                                insert of this row should be undone */
        undo_node_t*    node,   /* in: row undo node */
        dulint*         undo_no)/* out: the undo number */
{
        trx_undo_rec_t* undo_rec;
        trx_t*          trx;

        trx = node->trx;

        if (0 != ut_dulint_cmp(node->new_trx_id, trx->id)) {

                *undo_no = ut_dulint_zero;
                return(FALSE);
        }

        undo_rec = trx_undo_get_undo_rec_low(node->new_roll_ptr, node->heap);

        *undo_no = trx_undo_rec_get_undo_no(undo_rec);

        return(ut_dulint_cmp(trx->roll_limit, *undo_no) <= 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_upd_del_sec	(	undo_node_t *	node,
		que_thr_t *	thr
	)			[static]

Definition at line 482 of file row0umod.c.

References DB_SUCCESS, dict_table_get_next_index(), err, undo_node_struct::index, index(), mem_heap_create, mem_heap_free, NULL, undo_node_struct::row, row_build_index_entry(), and row_undo_mod_del_mark_or_remove_sec().

Referenced by row_undo_mod().

                                      : DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        mem_heap_t*     heap;
        dtuple_t*       entry;
        dict_index_t*   index;
        ulint           err;

        heap = mem_heap_create(1024);

        while (node->index != NULL) {
                index = node->index;

                entry = row_build_index_entry(node->row, index, heap);

                err = row_undo_mod_del_mark_or_remove_sec(node, thr, index,
                                                                entry);
                if (err != DB_SUCCESS) {

                        mem_heap_free(heap);

                        return(err);
                }

                node->index = dict_table_get_next_index(node->index);
        }

        mem_heap_free(heap);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint row_undo_mod_upd_exist_sec	(	undo_node_t *	node,
		que_thr_t *	thr
	)			[static]

Definition at line 567 of file row0umod.c.

References BTR_MODIFY_LEAF, BTR_MODIFY_TREE, undo_node_struct::cmpl_info, DB_FAIL, DB_SUCCESS, dict_table_get_next_index(), err, undo_node_struct::index, index(), mem_heap_create, mem_heap_free, NULL, undo_node_struct::row, row_build_index_entry(), row_undo_mod_del_mark_or_remove_sec(), row_undo_mod_del_unmark_sec_and_undo_update(), row_upd_changes_ord_field_binary(), row_upd_index_replace_new_col_vals(), UPD_NODE_NO_ORD_CHANGE, and undo_node_struct::update.

Referenced by row_undo_mod().

                                      : DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
        undo_node_t*    node,   /* in: row undo node */
        que_thr_t*      thr)    /* in: query thread */
{
        mem_heap_t*     heap;
        dtuple_t*       entry;
        dict_index_t*   index;
        ulint           err;

        if (node->cmpl_info & UPD_NODE_NO_ORD_CHANGE) {
                /* No change in secondary indexes */

                return(DB_SUCCESS);
        }

        heap = mem_heap_create(1024);

        while (node->index != NULL) {
                index = node->index;

                if (row_upd_changes_ord_field_binary(node->row, node->index,
                                                        node->update)) {

                        /* Build the newest version of the index entry */
                        entry = row_build_index_entry(node->row, index, heap);

                        /* NOTE that if we updated the fields of a
                        delete-marked secondary index record so that
                        alphabetically they stayed the same, e.g.,
                        'abc' -> 'aBc', we cannot return to the original
                        values because we do not know them. But this should
                        not cause problems because in row0sel.c, in queries
                        we always retrieve the clustered index record or an
                        earlier version of it, if the secondary index record
                        through which we do the search is delete-marked. */

                        err = row_undo_mod_del_mark_or_remove_sec(node, thr,
                                                                index, entry);
                        if (err != DB_SUCCESS) {
                                mem_heap_free(heap);

                                return(err);
                        }

                        /* We may have to update the delete mark in the
                        secondary index record of the previous version of
                        the row. We also need to update the fields of
                        the secondary index record if we updated its fields
                        but alphabetically they stayed the same, e.g.,
                        'abc' -> 'aBc'. */

                        row_upd_index_replace_new_col_vals(entry, index,
                                                        node->update, NULL);
                        err = row_undo_mod_del_unmark_sec_and_undo_update(
                                                BTR_MODIFY_LEAF,
                                                thr, index, entry);
                        if (err == DB_FAIL) {
                                err =
                                   row_undo_mod_del_unmark_sec_and_undo_update(
                                                BTR_MODIFY_TREE,
                                                thr, index, entry);
                        }

                        if (err != DB_SUCCESS) {
                                mem_heap_free(heap);

                                return(err);
                        }
                }

                node->index = dict_table_get_next_index(node->index);
        }

        mem_heap_free(heap);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.