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

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/include/row0ins.h File Reference

#include "univ.i"
#include "data0data.h"
#include "que0types.h"
#include "dict0types.h"
#include "trx0types.h"
#include "row0types.h"

Include dependency graph for row0ins.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ins_node_struct
Defines
#define	INS_NODE_MAGIC_N   15849075
#define	INS_SEARCHED   0
#define	INS_VALUES   1
#define	INS_DIRECT   2
#define	INS_NODE_SET_IX_LOCK   1
#define	INS_NODE_ALLOC_ROW_ID   2
#define	INS_NODE_INSERT_ENTRIES   3
Functions
ulint	row_ins_check_foreign_constraint (ibool check_ref, dict_foreign_t *foreign, dict_table_t *table, dtuple_t *entry, que_thr_t *thr)
ins_node_t *	ins_node_create (ulint ins_type, dict_table_t *table, mem_heap_t *heap)
void	ins_node_set_new_row (ins_node_t *node, dtuple_t *row)
ulint	row_ins_index_entry_low (ulint mode, dict_index_t *index, dtuple_t *entry, ulint *ext_vec, ulint n_ext_vec, que_thr_t *thr)
ulint	row_ins_index_entry (dict_index_t *index, dtuple_t *entry, ulint *ext_vec, ulint n_ext_vec, que_thr_t *thr)
ulint	row_ins (ins_node_t *node, que_thr_t *thr)
que_thr_t *	row_ins_step (que_thr_t *thr)

---

Define Documentation

#define INS_DIRECT   2

Definition at line 156 of file row0ins.h.

Referenced by ind_create_graph_create(), row_get_prebuilt_insert_row(), and tab_create_graph_create().

#define INS_NODE_ALLOC_ROW_ID   2

Definition at line 161 of file row0ins.h.

Referenced by row_ins(), row_ins_alloc_row_id_step(), row_ins_step(), and row_insert_for_mysql().

#define INS_NODE_INSERT_ENTRIES   3

Definition at line 162 of file row0ins.h.

Referenced by row_ins().

#define INS_NODE_MAGIC_N   15849075

Definition at line 151 of file row0ins.h.

Referenced by ins_node_create().

#define INS_NODE_SET_IX_LOCK   1

Definition at line 160 of file row0ins.h.

Referenced by ins_node_create(), ins_node_set_new_row(), row_ins_step(), and row_insert_for_mysql().

#define INS_SEARCHED   0

Definition at line 154 of file row0ins.h.

Referenced by pars_insert_statement(), row_ins(), and row_ins_step().

#define INS_VALUES   1

Definition at line 155 of file row0ins.h.

Referenced by pars_insert_statement(), and row_ins().

---

Function Documentation

ins_node_t* ins_node_create	(	ulint	ins_type,
		dict_table_t *	table,
		mem_heap_t *	heap
	)

Definition at line 73 of file row0ins.c.

References ins_node_struct::common, ins_node_struct::entry, ins_node_struct::entry_sys_heap, ins_node_struct::index, INS_NODE_MAGIC_N, INS_NODE_SET_IX_LOCK, ins_node_struct::ins_type, ins_node_struct::magic_n, mem_heap_alloc(), mem_heap_create, NULL, QUE_NODE_INSERT, ins_node_struct::select, ins_node_struct::state, ins_node_struct::table, ins_node_struct::trx_id, que_common_struct::type, and ut_dulint_zero.

Referenced by ind_create_graph_create(), pars_insert_statement(), row_get_prebuilt_insert_row(), and tab_create_graph_create().

                                                   : insert node struct */
        ulint           ins_type,       /* in: INS_VALUES, ... */
        dict_table_t*   table,          /* in: table where to insert */
        mem_heap_t*     heap)           /* in: mem heap where created */
{
        ins_node_t*     node;

        node = mem_heap_alloc(heap, sizeof(ins_node_t));

        node->common.type = QUE_NODE_INSERT;

        node->ins_type = ins_type;

        node->state = INS_NODE_SET_IX_LOCK;
        node->table = table;
        node->index = NULL;
        node->entry = NULL;

        node->select = NULL;

        node->trx_id = ut_dulint_zero;

        node->entry_sys_heap = mem_heap_create(128);

        node->magic_n = INS_NODE_MAGIC_N;

        return(node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ins_node_set_new_row	(	ins_node_t *	node,
		dtuple_t *	row
	)

Definition at line 191 of file row0ins.c.

References ins_node_struct::entry, ins_node_struct::entry_sys_heap, ins_node_struct::index, ins_node_create_entry_list(), INS_NODE_SET_IX_LOCK, mem_heap_empty(), NULL, ins_node_struct::row, row_ins_alloc_sys_fields(), ins_node_struct::state, ins_node_struct::trx_id, and ut_dulint_zero.

Referenced by dict_build_col_def_step(), dict_build_field_def_step(), dict_build_index_def_step(), pars_insert_statement(), and row_get_prebuilt_insert_row().

                                     : insert node */
        dtuple_t*       row)    /* in: new row (or first row) for the node */
{
        node->state = INS_NODE_SET_IX_LOCK;
        node->index = NULL;
        node->entry = NULL;

        node->row = row;

        mem_heap_empty(node->entry_sys_heap);

        /* Create templates for index entries */

        ins_node_create_entry_list(node);

        /* Allocate from entry_sys_heap buffers for sys fields */

        row_ins_alloc_sys_fields(node);

        /* As we allocated a new trx id buf, the trx id should be written
        there again: */

        node->trx_id = ut_dulint_zero;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint row_ins	(	ins_node_t *	node,
		que_thr_t *	thr
	)

Definition at line 2354 of file row0ins.c.

References DB_SUCCESS, dict_table_get_first_index(), dict_table_get_next_index(), ins_node_struct::entry, err, ins_node_struct::index, INS_NODE_ALLOC_ROW_ID, INS_NODE_INSERT_ENTRIES, INS_SEARCHED, INS_VALUES, NULL, row_ins_alloc_row_id_step(), row_ins_get_row_from_select(), row_ins_get_row_from_values(), row_ins_index_entry_step(), ins_node_struct::state, ut_ad, UT_LIST_GET_FIRST, and UT_LIST_GET_NEXT.

Referenced by row_ins_step().

                                      : DB_SUCCESS if operation successfully
                                completed, else error code or DB_LOCK_WAIT */
        ins_node_t*     node,   /* in: row insert node */
        que_thr_t*      thr)    /* in: query thread */
{
        ulint   err;

        ut_ad(node && thr);

        if (node->state == INS_NODE_ALLOC_ROW_ID) {

                row_ins_alloc_row_id_step(node);

                node->index = dict_table_get_first_index(node->table);
                node->entry = UT_LIST_GET_FIRST(node->entry_list);

                if (node->ins_type == INS_SEARCHED) {

                        row_ins_get_row_from_select(node);

                } else if (node->ins_type == INS_VALUES) {

                        row_ins_get_row_from_values(node);
                }

                node->state = INS_NODE_INSERT_ENTRIES;
        }

        ut_ad(node->state == INS_NODE_INSERT_ENTRIES);

        while (node->index != NULL) {
                err = row_ins_index_entry_step(node, thr);

                if (err != DB_SUCCESS) {

                        return(err);
                }

                node->index = dict_table_get_next_index(node->index);
                node->entry = UT_LIST_GET_NEXT(tuple_list, node->entry);
        }

        ut_ad(node->entry == NULL);

        node->state = INS_NODE_ALLOC_ROW_ID;

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint row_ins_check_foreign_constraint	(	ibool	check_ref,
		dict_foreign_t *	foreign,
		dict_table_t *	table,
		dtuple_t *	entry,
		que_thr_t *	thr
	)

Definition at line 1178 of file row0ins.c.

References trx_struct::check_foreigns, cmp, DB_SUCCESS, dfield_get_len(), dict_operation_lock, dtuple_get_nth_field(), err, FALSE, upd_node_struct::foreign, upd_node_struct::is_delete, dict_foreign_struct::n_fields, NULL, que_node_get_type(), QUE_NODE_UPDATE, REC_OFFS_NORMAL_SIZE, que_thr_struct::run_node, RW_LOCK_SHARED, thr_get_trx(), and ut_ad.

Referenced by row_ins_check_foreign_constraints(), and row_upd_check_references_constraints().

                                      : DB_SUCCESS,
                                DB_NO_REFERENCED_ROW,
                                or DB_ROW_IS_REFERENCED */
        ibool           check_ref,/* in: TRUE if we want to check that
                                the referenced table is ok, FALSE if we
                                want to to check the foreign key table */
        dict_foreign_t* foreign,/* in: foreign constraint; NOTE that the
                                tables mentioned in it must be in the
                                dictionary cache if they exist at all */
        dict_table_t*   table,  /* in: if check_ref is TRUE, then the foreign
                                table, else the referenced table */
        dtuple_t*       entry,  /* in: index entry for index */
        que_thr_t*      thr)    /* in: query thread */
{
        upd_node_t*     upd_node;
        dict_table_t*   check_table;
        dict_index_t*   check_index;
        ulint           n_fields_cmp;
        rec_t*          rec;
        btr_pcur_t      pcur;
        ibool           moved;
        int             cmp;
        ulint           err;
        ulint           i;
        mtr_t           mtr;
        trx_t*          trx             = thr_get_trx(thr);
        mem_heap_t*     heap            = NULL;
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
        ulint*          offsets         = offsets_;
        *offsets_ = (sizeof offsets_) / sizeof *offsets_;

run_again:
#ifdef UNIV_SYNC_DEBUG
        ut_ad(rw_lock_own(&dict_operation_lock, RW_LOCK_SHARED));
#endif /* UNIV_SYNC_DEBUG */

        err = DB_SUCCESS;

        if (trx->check_foreigns == FALSE) {
                /* The user has suppressed foreign key checks currently for
                this session */
                goto exit_func;
        }

        /* If any of the foreign key fields in entry is SQL NULL, we
        suppress the foreign key check: this is compatible with Oracle,
        for example */

        for (i = 0; i < foreign->n_fields; i++) {
                if (UNIV_SQL_NULL == dfield_get_len(
                                         dtuple_get_nth_field(entry, i))) {

                        goto exit_func;
                }
        }

        if (que_node_get_type(thr->run_node) == QUE_NODE_UPDATE) {
                upd_node = thr->run_node;

                if (!(upd_node->is_delete) && upd_node->foreign == foreign) {
                        /* If a cascaded update is done as defined by a
                        foreign key constraint, do not check that
                        constraint for the child row. In ON UPDATE CASCADE
                        the update of the parent row is only half done when
                        we come here: if we would check the constraint here
                        for the child row it would fail.

                        A QUESTION remains: if in the child table there are
                        several constraints which refer to the same parent
                        table, we should merge all updates to the child as
                        one update? And the updates can be contradictory!
                        Currently we just perform the update associated
                        with each foreign key constraint, one after
                        another, and the user has problems predicting in
                        which order they are performed. */

                        goto exit_func;
                }
        }

        if (check_ref) {
                check_table = foreign->referenced_table;
                check_index = foreign->referenced_index;
        } else {
                check_table = foreign->foreign_table;
                check_index = foreign->foreign_index;
        }

        if (check_table == NULL || check_table->ibd_file_missing) {
                if (check_ref) {
                        FILE*   ef = dict_foreign_err_file;

                        row_ins_set_detailed(trx, foreign);

                        mutex_enter(&dict_foreign_err_mutex);
                        rewind(ef);
                        ut_print_timestamp(ef);
                        fputs(" Transaction:\n", ef);
                        trx_print(ef, trx, 600);
                        fputs("Foreign key constraint fails for table ", ef);
                        ut_print_name(ef, trx, TRUE,
                                        foreign->foreign_table_name);
                        fputs(":\n", ef);
                        dict_print_info_on_foreign_key_in_create_format(ef,
                                        trx, foreign, TRUE);
                        fputs("\nTrying to add to index ", ef);
                        ut_print_name(ef, trx, FALSE,
                                        foreign->foreign_index->name);
                        fputs(" tuple:\n", ef);
                        dtuple_print(ef, entry);
                        fputs("\nBut the parent table ", ef);
                        ut_print_name(ef, trx, TRUE,
                                        foreign->referenced_table_name);
                fputs("\nor its .ibd file does not currently exist!\n", ef);
                        mutex_exit(&dict_foreign_err_mutex);

                        err = DB_NO_REFERENCED_ROW;
                }

                goto exit_func;
        }

        ut_a(check_table && check_index);

        if (check_table != table) {
                /* We already have a LOCK_IX on table, but not necessarily
                on check_table */

                err = lock_table(0, check_table, LOCK_IS, thr);

                if (err != DB_SUCCESS) {

                        goto do_possible_lock_wait;
                }
        }

        mtr_start(&mtr);

        /* Store old value on n_fields_cmp */

        n_fields_cmp = dtuple_get_n_fields_cmp(entry);

        dtuple_set_n_fields_cmp(entry, foreign->n_fields);

        btr_pcur_open(check_index, entry, PAGE_CUR_GE,
                                        BTR_SEARCH_LEAF, &pcur, &mtr);

        /* Scan index records and check if there is a matching record */

        for (;;) {
                page_t* page;
                rec = btr_pcur_get_rec(&pcur);
                page = buf_frame_align(rec);

                if (rec == page_get_infimum_rec(page)) {

                        goto next_rec;
                }

                offsets = rec_get_offsets(rec, check_index,
                                        offsets, ULINT_UNDEFINED, &heap);

                if (rec == page_get_supremum_rec(page)) {

                        err = row_ins_set_shared_rec_lock(LOCK_ORDINARY, rec,
                                                check_index, offsets, thr);
                        if (err != DB_SUCCESS) {

                                break;
                        }

                        goto next_rec;
                }

                cmp = cmp_dtuple_rec(entry, rec, offsets);

                if (cmp == 0) {
                        if (rec_get_deleted_flag(rec,
                                                rec_offs_comp(offsets))) {
                                err = row_ins_set_shared_rec_lock(
                                                LOCK_ORDINARY, rec,
                                                check_index, offsets, thr);
                                if (err != DB_SUCCESS) {

                                        break;
                                }
                        } else {
                                /* Found a matching record. Lock only
                                a record because we can allow inserts
                                into gaps */

                                err = row_ins_set_shared_rec_lock(
                                                LOCK_REC_NOT_GAP, rec,
                                                check_index, offsets, thr);

                                if (err != DB_SUCCESS) {

                                        break;
                                }

                                if (check_ref) {
                                        err = DB_SUCCESS;

                                        break;
                                } else if (foreign->type != 0) {
                                        /* There is an ON UPDATE or ON DELETE
                                        condition: check them in a separate
                                        function */

                                        err =
                                          row_ins_foreign_check_on_constraint(
                                                thr, foreign, &pcur, entry,
                                                                        &mtr);
                                        if (err != DB_SUCCESS) {
                                                /* Since reporting a plain
                                                "duplicate key" error
                                                message to the user in
                                                cases where a long CASCADE
                                                operation would lead to a
                                                duplicate key in some
                                                other table is very
                                                confusing, map duplicate
                                                key errors resulting from
                                                FK constraints to a
                                                separate error code. */

                                                if (err == DB_DUPLICATE_KEY) {
                                                        err = DB_FOREIGN_DUPLICATE_KEY;
                                                }

                                                break;
                                        }
                                } else {
                                        row_ins_foreign_report_err(
                                                "Trying to delete or update",
                                                thr, foreign, rec, entry);

                                        err = DB_ROW_IS_REFERENCED;
                                        break;
                                }
                        }
                }

                if (cmp < 0) {
                        err = row_ins_set_shared_rec_lock(LOCK_GAP,
                                        rec, check_index, offsets, thr);
                        if (err != DB_SUCCESS) {

                                break;
                        }

                        if (check_ref) {
                                err = DB_NO_REFERENCED_ROW;
                                row_ins_foreign_report_add_err(
                                        trx, foreign, rec, entry);
                        } else {
                                err = DB_SUCCESS;
                        }

                        break;
                }

                ut_a(cmp == 0);
next_rec:
                moved = btr_pcur_move_to_next(&pcur, &mtr);

                if (!moved) {
                        if (check_ref) {
                                rec = btr_pcur_get_rec(&pcur);
                                row_ins_foreign_report_add_err(
                                        trx, foreign, rec, entry);
                                err = DB_NO_REFERENCED_ROW;
                        } else {
                                err = DB_SUCCESS;
                        }

                        break;
                }
        }

        btr_pcur_close(&pcur);

        mtr_commit(&mtr);

        /* Restore old value */
        dtuple_set_n_fields_cmp(entry, n_fields_cmp);

do_possible_lock_wait:
        if (err == DB_LOCK_WAIT) {
                trx->error_state = err;

                que_thr_stop_for_mysql(thr);

                srv_suspend_mysql_thread(thr);

                if (trx->error_state == DB_SUCCESS) {

                        goto run_again;
                }

                err = trx->error_state;
        }

exit_func:
        if (UNIV_LIKELY_NULL(heap)) {
                mem_heap_free(heap);
        }
        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint row_ins_index_entry	(	dict_index_t *	index,
		dtuple_t *	entry,
		ulint *	ext_vec,
		ulint	n_ext_vec,
		que_thr_t *	thr
	)

Definition at line 2152 of file row0ins.c.

References BTR_MODIFY_LEAF, BTR_MODIFY_TREE, DB_FAIL, DB_SUCCESS, err, index(), row_ins_check_foreign_constraints(), row_ins_index_entry_low(), and UT_LIST_GET_FIRST.

Referenced by row_ins_index_entry_step(), row_upd_clust_rec_by_insert(), and row_upd_sec_index_entry().

                                      : DB_SUCCESS, DB_LOCK_WAIT,
                                DB_DUPLICATE_KEY, or some other error code */
        dict_index_t*   index,  /* in: index */
        dtuple_t*       entry,  /* in: index entry to insert */
        ulint*          ext_vec,/* in: array containing field numbers of
                                externally stored fields in entry, or NULL */
        ulint           n_ext_vec,/* in: number of fields in ext_vec */
        que_thr_t*      thr)    /* in: query thread */
{
        ulint   err;

        if (UT_LIST_GET_FIRST(index->table->foreign_list)) {
                err = row_ins_check_foreign_constraints(index->table, index,
                                                                entry, thr);
                if (err != DB_SUCCESS) {

                        return(err);
                }
        }

        /* Try first optimistic descent to the B-tree */

        err = row_ins_index_entry_low(BTR_MODIFY_LEAF, index, entry,
                                                ext_vec, n_ext_vec, thr);
        if (err != DB_FAIL) {

                return(err);
        }

        /* Try then pessimistic descent to the B-tree */

        err = row_ins_index_entry_low(BTR_MODIFY_TREE, index, entry,
                                                ext_vec, n_ext_vec, thr);
        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint row_ins_index_entry_low	(	ulint	mode,
		dict_index_t *	index,
		dtuple_t *	entry,
		ulint *	ext_vec,
		ulint	n_ext_vec,
		que_thr_t *	thr
	)

Definition at line 1959 of file row0ins.c.

References btr_cur_get_page(), btr_cur_get_rec(), BTR_CUR_INSERT_TO_IBUF, btr_cur_optimistic_insert(), btr_cur_pessimistic_insert(), btr_cur_position(), btr_cur_search_to_nth_level(), BTR_IGNORE_SEC_UNIQUE, BTR_INSERT, BTR_MODIFY_LEAF, BTR_MODIFY_TREE, btr_store_big_rec_extern_fields(), buf_LRU_buf_pool_running_out(), DB_LOCK_TABLE_FULL, DB_SUCCESS, DICT_CLUSTERED, dict_index_get_n_unique(), DICT_UNIQUE, dtuple_big_rec_free(), dtuple_convert_back_big_rec(), dtuple_get_n_fields(), err, btr_cur_struct::flag, index(), log_free_check(), btr_cur_struct::low_match, mem_heap_free, mtr_commit(), mtr_start(), NULL, page, PAGE_CUR_LE, page_get_infimum_rec(), page_get_supremum_rec(), page_rec_get_next(), page_t, rec_get_n_fields(), rec_get_offsets, REC_OFFS_NORMAL_SIZE, rec_set_field_extern_bits(), row_ins_clust_index_entry_by_modify(), row_ins_duplicate_error_in_clust(), row_ins_must_modify(), ROW_INS_NEXT, row_ins_scan_sec_index_for_duplicate(), row_ins_sec_index_entry_by_modify(), btr_cur_struct::thr, thr_get_trx(), btr_cur_struct::up_match, and ut_a.

Referenced by row_ins_index_entry().

                                      : DB_SUCCESS, DB_LOCK_WAIT, DB_FAIL
                                if pessimistic retry needed, or error code */
        ulint           mode,   /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
                                depending on whether we wish optimistic or
                                pessimistic descent down the index tree */
        dict_index_t*   index,  /* in: index */
        dtuple_t*       entry,  /* in: index entry to insert */
        ulint*          ext_vec,/* in: array containing field numbers of
                                externally stored fields in entry, or NULL */
        ulint           n_ext_vec,/* in: number of fields in ext_vec */
        que_thr_t*      thr)    /* in: query thread */
{
        btr_cur_t       cursor;
        ulint           ignore_sec_unique       = 0;
        ulint           modify = 0; /* remove warning */
        rec_t*          insert_rec;
        rec_t*          rec;
        ulint           err;
        ulint           n_unique;
        big_rec_t*      big_rec                 = NULL;
        mtr_t           mtr;
        mem_heap_t*     heap                    = NULL;
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
        ulint*          offsets                 = offsets_;
        *offsets_ = (sizeof offsets_) / sizeof *offsets_;

        log_free_check();

        mtr_start(&mtr);

        cursor.thr = thr;

        /* Note that we use PAGE_CUR_LE as the search mode, because then
        the function will return in both low_match and up_match of the
        cursor sensible values */

        if (!(thr_get_trx(thr)->check_unique_secondary)) {
                ignore_sec_unique = BTR_IGNORE_SEC_UNIQUE;
        }

        btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
                                mode | BTR_INSERT | ignore_sec_unique,
                                &cursor, 0, &mtr);

        if (cursor.flag == BTR_CUR_INSERT_TO_IBUF) {
                /* The insertion was made to the insert buffer already during
                the search: we are done */

                err = DB_SUCCESS;

                goto function_exit;
        }

#ifdef UNIV_DEBUG
        {
                page_t* page = btr_cur_get_page(&cursor);
                rec_t*  first_rec = page_rec_get_next(
                                page_get_infimum_rec(page));

                if (UNIV_LIKELY(first_rec != page_get_supremum_rec(page))) {
                        ut_a(rec_get_n_fields(first_rec, index)
                        == dtuple_get_n_fields(entry));
                }
        }
#endif

        n_unique = dict_index_get_n_unique(index);

        if (index->type & DICT_UNIQUE && (cursor.up_match >= n_unique
                                         || cursor.low_match >= n_unique)) {

                if (index->type & DICT_CLUSTERED) {
                        /* Note that the following may return also
                        DB_LOCK_WAIT */

                        err = row_ins_duplicate_error_in_clust(&cursor,
                                                        entry, thr, &mtr);
                        if (err != DB_SUCCESS) {

                                goto function_exit;
                        }
                } else {
                        mtr_commit(&mtr);
                        err = row_ins_scan_sec_index_for_duplicate(index,
                                                                entry, thr);
                        mtr_start(&mtr);

                        if (err != DB_SUCCESS) {

                                goto function_exit;
                        }

                        /* We did not find a duplicate and we have now
                        locked with s-locks the necessary records to
                        prevent any insertion of a duplicate by another
                        transaction. Let us now reposition the cursor and
                        continue the insertion. */

                        btr_cur_search_to_nth_level(index, 0, entry,
                                        PAGE_CUR_LE, mode | BTR_INSERT,
                                        &cursor, 0, &mtr);
                }
        }

        modify = row_ins_must_modify(&cursor);

        if (modify != 0) {
                /* There is already an index entry with a long enough common
                prefix, we must convert the insert into a modify of an
                existing record */

                if (modify == ROW_INS_NEXT) {
                        rec = page_rec_get_next(btr_cur_get_rec(&cursor));

                        btr_cur_position(index, rec, &cursor);
                }

                if (index->type & DICT_CLUSTERED) {
                        err = row_ins_clust_index_entry_by_modify(mode,
                                                        &cursor, &big_rec,
                                                        entry,
                                                        ext_vec, n_ext_vec,
                                                        thr, &mtr);
                } else {
                        err = row_ins_sec_index_entry_by_modify(mode, &cursor,
                                                                entry,
                                                                thr, &mtr);
                }

        } else {
                if (mode == BTR_MODIFY_LEAF) {
                        err = btr_cur_optimistic_insert(0, &cursor, entry,
                                        &insert_rec, &big_rec, thr, &mtr);
                } else {
                        ut_a(mode == BTR_MODIFY_TREE);
                        if (buf_LRU_buf_pool_running_out()) {

                                err = DB_LOCK_TABLE_FULL;

                                goto function_exit;
                        }
                        err = btr_cur_pessimistic_insert(0, &cursor, entry,
                                        &insert_rec, &big_rec, thr, &mtr);
                }

                if (err == DB_SUCCESS) {
                        if (ext_vec) {
                                rec_set_field_extern_bits(insert_rec, index,
                                                ext_vec, n_ext_vec, &mtr);
                        }
                }
        }

function_exit:
        mtr_commit(&mtr);

        if (big_rec) {
                rec_t*          rec;
                mtr_start(&mtr);

                btr_cur_search_to_nth_level(index, 0, entry, PAGE_CUR_LE,
                                        BTR_MODIFY_TREE, &cursor, 0, &mtr);
                rec = btr_cur_get_rec(&cursor);
                offsets = rec_get_offsets(rec, index, offsets,
                                        ULINT_UNDEFINED, &heap);

                err = btr_store_big_rec_extern_fields(index, rec,
                                                offsets, big_rec, &mtr);

                if (modify) {
                        dtuple_big_rec_free(big_rec);
                } else {
                        dtuple_convert_back_big_rec(index, entry, big_rec);
                }

                mtr_commit(&mtr);
        }

        if (UNIV_LIKELY_NULL(heap)) {
                mem_heap_free(heap);
        }
        return(err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

que_thr_t* row_ins_step

(

que_thr_t *

thr

)

Definition at line 2410 of file row0ins.c.

References DB_SUCCESS, err, trx_struct::error_state, trx_struct::id, INS_NODE_ALLOC_ROW_ID, INS_NODE_SET_IX_LOCK, INS_SEARCHED, ins_node_struct::ins_type, LOCK_IX, lock_table(), NULL, que_thr_struct::prev_node, que_node_get_parent(), que_node_get_type(), QUE_NODE_INSERT, row_ins(), que_thr_struct::run_node, SEL_NODE_FETCH, SEL_NODE_NO_MORE_ROWS, SEL_NODE_OPEN, ins_node_struct::select, ins_node_struct::state, sel_node_struct::state, ins_node_struct::table, thr_get_trx(), ins_node_struct::trx_id, ins_node_struct::trx_id_buf, trx_start_if_not_started(), trx_write_trx_id(), ut_ad, and UT_DULINT_EQ.

Referenced by que_thr_step(), and row_insert_for_mysql().

                                      : query thread to run next or NULL */
        que_thr_t*      thr)    /* in: query thread */
{
        ins_node_t*     node;
        que_node_t*     parent;
        sel_node_t*     sel_node;
        trx_t*          trx;
        ulint           err;

        ut_ad(thr);

        trx = thr_get_trx(thr);

        trx_start_if_not_started(trx);

        node = thr->run_node;

        ut_ad(que_node_get_type(node) == QUE_NODE_INSERT);

        parent = que_node_get_parent(node);
        sel_node = node->select;

        if (thr->prev_node == parent) {
                node->state = INS_NODE_SET_IX_LOCK;
        }

        /* If this is the first time this node is executed (or when
        execution resumes after wait for the table IX lock), set an
        IX lock on the table and reset the possible select node. MySQL's
        partitioned table code may also call an insert within the same
        SQL statement AFTER it has used this table handle to do a search.
        This happens, for example, when a row update moves it to another
        partition. In that case, we have already set the IX lock on the
        table during the search operation, and there is no need to set
        it again here. But we must write trx->id to node->trx_id_buf. */

        trx_write_trx_id(node->trx_id_buf, trx->id);

        if (node->state == INS_NODE_SET_IX_LOCK) {

                /* It may be that the current session has not yet started
                its transaction, or it has been committed: */

                if (UT_DULINT_EQ(trx->id, node->trx_id)) {
                        /* No need to do IX-locking */

                        goto same_trx;
                }

                err = lock_table(0, node->table, LOCK_IX, thr);

                if (err != DB_SUCCESS) {

                        goto error_handling;
                }

                node->trx_id = trx->id;
        same_trx:
                node->state = INS_NODE_ALLOC_ROW_ID;

                if (node->ins_type == INS_SEARCHED) {
                        /* Reset the cursor */
                        sel_node->state = SEL_NODE_OPEN;

                        /* Fetch a row to insert */

                        thr->run_node = sel_node;

                        return(thr);
                }
        }

        if ((node->ins_type == INS_SEARCHED)
                                && (sel_node->state != SEL_NODE_FETCH)) {

                ut_ad(sel_node->state == SEL_NODE_NO_MORE_ROWS);

                /* No more rows to insert */
                thr->run_node = parent;

                return(thr);
        }

        /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */

        err = row_ins(node, thr);

error_handling:
        trx->error_state = err;

        if (err != DB_SUCCESS) {
                /* err == DB_LOCK_WAIT or SQL error detected */
                return(NULL);
        }

        /* DO THE TRIGGER ACTIONS HERE */

        if (node->ins_type == INS_SEARCHED) {
                /* Fetch a row to insert */

                thr->run_node = sel_node;
        } else {
                thr->run_node = que_node_get_parent(node);
        }

        return(thr);
}

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.