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/dict/dict0crea.c File Reference

#include "dict0crea.h"
#include "btr0pcur.h"
#include "btr0btr.h"
#include "page0page.h"
#include "mach0data.h"
#include "dict0boot.h"
#include "dict0dict.h"
#include "que0que.h"
#include "row0ins.h"
#include "row0mysql.h"
#include "pars0pars.h"
#include "trx0roll.h"
#include "usr0sess.h"
#include "ut0vec.h"

Include dependency graph for dict0crea.c:

Go to the source code of this file.

Functions
static dtuple_t *	dict_create_sys_tables_tuple (dict_table_t *table, mem_heap_t *heap)
static dtuple_t *	dict_create_sys_columns_tuple (dict_table_t *table, ulint i, mem_heap_t *heap)
static ulint	dict_build_table_def_step (que_thr_t *thr, tab_node_t *node)
static ulint	dict_build_col_def_step (tab_node_t *node)
static dtuple_t *	dict_create_sys_indexes_tuple (dict_index_t *index, mem_heap_t *heap)
static dtuple_t *	dict_create_sys_fields_tuple (dict_index_t *index, ulint i, mem_heap_t *heap)
static dtuple_t *	dict_create_search_tuple (dtuple_t *tuple, mem_heap_t *heap)
static ulint	dict_build_index_def_step (que_thr_t *thr, ind_node_t *node)
static ulint	dict_build_field_def_step (ind_node_t *node)
static ulint	dict_create_index_tree_step (ind_node_t *node)
void	dict_drop_index_tree (rec_t *rec, mtr_t *mtr)
ulint	dict_truncate_index_tree (dict_table_t *table, rec_t *rec, mtr_t *mtr)
tab_node_t *	tab_create_graph_create (dict_table_t *table, mem_heap_t *heap)
ind_node_t *	ind_create_graph_create (dict_index_t *index, mem_heap_t *heap)
que_thr_t *	dict_create_table_step (que_thr_t *thr)
que_thr_t *	dict_create_index_step (que_thr_t *thr)
ulint	dict_create_or_check_foreign_constraint_tables (void)
ulint	dict_foreign_eval_sql (pars_info_t *info, const char *sql, dict_table_t *table, dict_foreign_t *foreign, trx_t *trx)
static ulint	dict_create_add_foreign_field_to_dictionary (ulint field_nr, dict_table_t *table, dict_foreign_t *foreign, trx_t *trx)
static ulint	dict_create_add_foreign_to_dictionary (ulint *id_nr, dict_table_t *table, dict_foreign_t *foreign, trx_t *trx)
ulint	dict_create_add_foreigns_to_dictionary (ulint start_id, dict_table_t *table, trx_t *trx)

---

Function Documentation

static ulint dict_build_col_def_step

(

tab_node_t *

node

)

[static]

Definition at line 280 of file dict0crea.c.

References tab_node_struct::col_def, tab_node_struct::col_no, DB_SUCCESS, dict_create_sys_columns_tuple(), tab_node_struct::heap, ins_node_set_new_row(), and tab_node_struct::table.

Referenced by dict_create_table_step().

                                      : DB_SUCCESS */
        tab_node_t*     node)   /* in: table create node */
{
        dtuple_t*       row;

        row = dict_create_sys_columns_tuple(node->table, node->col_no,
                                                                node->heap);
        ins_node_set_new_row(node->col_def, row);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint dict_build_field_def_step

(

ind_node_t *

node

)

[static]

Definition at line 552 of file dict0crea.c.

References DB_SUCCESS, dict_create_sys_fields_tuple(), ind_node_struct::field_def, ind_node_struct::field_no, ind_node_struct::heap, ind_node_struct::index, index(), and ins_node_set_new_row().

Referenced by dict_create_index_step().

                                      : DB_SUCCESS */
        ind_node_t*     node)   /* in: index create node */
{
        dict_index_t*   index;
        dtuple_t*       row;

        index = node->index;

        row = dict_create_sys_fields_tuple(index, node->field_no, node->heap);

        ins_node_set_new_row(node->field_def, row);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint dict_build_index_def_step	(	que_thr_t *	thr,
		ind_node_t *	node
	)			[static]

Definition at line 501 of file dict0crea.c.

References DB_SUCCESS, DB_TABLE_NOT_FOUND, DICT_CLUSTERED, dict_create_sys_indexes_tuple(), dict_hdr_get_new_id(), DICT_HDR_INDEX_ID, dict_sys, dict_table_get_low(), FIL_NULL, ind_node_struct::heap, dict_table_struct::id, ind_node_struct::ind_def, ind_node_struct::ind_row, ind_node_struct::index, index(), dict_table_struct::indexes, ins_node_set_new_row(), dict_sys_struct::mutex, NULL, ind_node_struct::page_no, dict_table_struct::space, ind_node_struct::table, trx_struct::table_id, thr_get_trx(), ut_ad, and UT_LIST_GET_LEN.

Referenced by dict_create_index_step().

                                      : DB_SUCCESS or error code */
        que_thr_t*      thr,    /* in: query thread */
        ind_node_t*     node)   /* in: index create node */
{
        dict_table_t*   table;
        dict_index_t*   index;
        dtuple_t*       row;
        trx_t*          trx;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        trx = thr_get_trx(thr);

        index = node->index;

        table = dict_table_get_low(index->table_name);

        if (table == NULL) {
                return(DB_TABLE_NOT_FOUND);
        }

        trx->table_id = table->id;

        node->table = table;

        ut_ad((UT_LIST_GET_LEN(table->indexes) > 0)
                || (index->type & DICT_CLUSTERED));

        index->id = dict_hdr_get_new_id(DICT_HDR_INDEX_ID);

        /* Inherit the space id from the table; we store all indexes of a
        table in the same tablespace */

        index->space = table->space;
        node->page_no = FIL_NULL;
        row = dict_create_sys_indexes_tuple(index, node->heap);
        node->ind_row = row;

        ins_node_set_new_row(node->ind_def, row);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint dict_build_table_def_step	(	que_thr_t *	thr,
		tab_node_t *	node
	)			[static]

Definition at line 198 of file dict0crea.c.

References BTR_PAGE_MAX_REC_SIZE, dict_table_struct::cols, DB_SUCCESS, DB_TOO_BIG_RECORD, dict_col_get_type(), dict_hdr_get_new_id(), DICT_HDR_TABLE_ID, dict_sys, dict_table_struct::dir_path_of_temp_table, dtype_get_min_size(), error, FALSE, fil_create_new_single_table_tablespace(), FIL_IBD_FILE_INITIAL_SIZE, fsp_header_init(), dict_table_struct::id, mtr_commit(), mtr_start(), dict_sys_struct::mutex, dict_table_struct::n_def, dict_table_struct::name, dict_table_struct::space, srv_file_per_table, tab_node_struct::table, trx_struct::table_id, thr_get_trx(), TRUE, and ut_ad.

Referenced by dict_create_table_step().

                                      : DB_SUCCESS or error code */
        que_thr_t*      thr,    /* in: query thread */
        tab_node_t*     node)   /* in: table create node */
{
        dict_table_t*   table;
        dtuple_t*       row;
        ulint           error;
        const char*     path_or_name;
        ibool           is_path;
        mtr_t           mtr;
        ulint           i;
        ulint           row_len;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        table = node->table;

        table->id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);

        thr_get_trx(thr)->table_id = table->id;

        row_len = 0;
        for (i = 0; i < table->n_def; i++) {
                row_len += dtype_get_min_size(dict_col_get_type(
                                                &table->cols[i]));
        }
        if (row_len > BTR_PAGE_MAX_REC_SIZE) {
                return(DB_TOO_BIG_RECORD);
        }

        if (srv_file_per_table) {
                /* We create a new single-table tablespace for the table.
                We initially let it be 4 pages:
                - page 0 is the fsp header and an extent descriptor page,
                - page 1 is an ibuf bitmap page,
                - page 2 is the first inode page,
                - page 3 will contain the root of the clustered index of the
                  table we create here. */

                table->space = 0;       /* reset to zero for the call below */

                if (table->dir_path_of_temp_table) {
                        /* We place tables created with CREATE TEMPORARY
                        TABLE in the tmp dir of mysqld server */

                        path_or_name = table->dir_path_of_temp_table;
                        is_path = TRUE;
                } else {
                        path_or_name = table->name;
                        is_path = FALSE;
                }

                error = fil_create_new_single_table_tablespace(
                                        &(table->space), path_or_name, is_path,
                                        FIL_IBD_FILE_INITIAL_SIZE);
                if (error != DB_SUCCESS) {

                        return(error);
                }

                mtr_start(&mtr);

                fsp_header_init(table->space, FIL_IBD_FILE_INITIAL_SIZE, &mtr);

                mtr_commit(&mtr);
        }

        row = dict_create_sys_tables_tuple(table, node->heap);

        ins_node_set_new_row(node->tab_def, row);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint dict_create_add_foreign_field_to_dictionary	(	ulint	field_nr,
		dict_table_t *	table,
		dict_foreign_t *	foreign,
		trx_t *	trx
	)			[static]

Definition at line 1299 of file dict0crea.c.

References dict_foreign_eval_sql(), dict_foreign_struct::foreign_col_names, dict_foreign_struct::id, info, pars_info_add_int4_literal(), pars_info_add_str_literal(), pars_info_create(), and dict_foreign_struct::referenced_col_names.

Referenced by dict_create_add_foreign_to_dictionary().

                                              : error code or DB_SUCCESS */
        ulint           field_nr,       /* in: foreign field number */
        dict_table_t*   table,          /* in: table */
        dict_foreign_t* foreign,        /* in: foreign */
        trx_t*          trx)            /* in: transaction */
{
        pars_info_t*    info = pars_info_create();

        pars_info_add_str_literal(info, "id", foreign->id);

        pars_info_add_int4_literal(info, "pos", field_nr);

        pars_info_add_str_literal(info, "for_col_name",
                foreign->foreign_col_names[field_nr]);

        pars_info_add_str_literal(info, "ref_col_name",
                foreign->referenced_col_names[field_nr]);

        return dict_foreign_eval_sql(info,
                "PROCEDURE P () IS\n"
                "BEGIN\n"
                "INSERT INTO SYS_FOREIGN_COLS VALUES"
                "(:id, :pos, :for_col_name, :ref_col_name);\n"
                "END;\n"
                , table, foreign, trx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ulint dict_create_add_foreign_to_dictionary	(	ulint *	id_nr,
		dict_table_t *	table,
		dict_foreign_t *	foreign,
		trx_t *	trx
	)			[static]

Definition at line 1337 of file dict0crea.c.

References DB_SUCCESS, dict_create_add_foreign_field_to_dictionary(), dict_foreign_eval_sql(), error, dict_foreign_struct::heap, dict_foreign_struct::id, info, mem_heap_alloc(), dict_foreign_struct::n_fields, dict_table_struct::name, NULL, pars_info_add_int4_literal(), pars_info_add_str_literal(), pars_info_create(), dict_foreign_struct::referenced_table_name, strlen(), and dict_foreign_struct::type.

Referenced by dict_create_add_foreigns_to_dictionary().

                                      : error code or DB_SUCCESS */
        ulint*          id_nr,  /* in/out: number to use in id generation;
                                incremented if used */
        dict_table_t*   table,  /* in: table */
        dict_foreign_t* foreign,/* in: foreign */
        trx_t*          trx)    /* in: transaction */
{
        ulint           error;
        ulint           i;

        pars_info_t*    info = pars_info_create();

        if (foreign->id == NULL) {
                /* Generate a new constraint id */
                ulint   namelen = strlen(table->name);
                char*   id      = mem_heap_alloc(foreign->heap, namelen + 20);
                /* no overflow if number < 1e13 */
                sprintf(id, "%s_ibfk_%lu", table->name, (ulong) (*id_nr)++);
                foreign->id = id;
        }

        pars_info_add_str_literal(info, "id", foreign->id);

        pars_info_add_str_literal(info, "for_name", table->name);

        pars_info_add_str_literal(info, "ref_name",
                foreign->referenced_table_name);

        pars_info_add_int4_literal(info, "n_cols",
                foreign->n_fields + (foreign->type << 24));

        error = dict_foreign_eval_sql(info,
                "PROCEDURE P () IS\n"
                "BEGIN\n"
                "INSERT INTO SYS_FOREIGN VALUES"
                "(:id, :for_name, :ref_name, :n_cols);\n"
                "END;\n"
                , table, foreign, trx);

        if (error != DB_SUCCESS) {

                return(error);
        }

        for (i = 0; i < foreign->n_fields; i++) {
                error = dict_create_add_foreign_field_to_dictionary(i,
                        table, foreign, trx);

                if (error != DB_SUCCESS) {

                        return(error);
                }
        }

        error = dict_foreign_eval_sql(NULL,
                "PROCEDURE P () IS\n"
                "BEGIN\n"
                "COMMIT WORK;\n"
                "END;\n"
                , table, foreign, trx);

        return(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint dict_create_add_foreigns_to_dictionary	(	ulint	start_id,
		dict_table_t *	table,
		trx_t *	trx
	)

Definition at line 1407 of file dict0crea.c.

References DB_ERROR, DB_SUCCESS, dict_create_add_foreign_to_dictionary(), dict_sys, dict_table_get_low(), error, dict_table_struct::foreign_list, dict_sys_struct::mutex, NULL, ut_ad, UT_LIST_GET_FIRST, and UT_LIST_GET_NEXT.

Referenced by dict_create_foreign_constraints_low().

                                      : error code or DB_SUCCESS */
        ulint           start_id,/* in: if we are actually doing ALTER TABLE
                                ADD CONSTRAINT, we want to generate constraint
                                numbers which are bigger than in the table so
                                far; we number the constraints from
                                start_id + 1 up; start_id should be set to 0 if
                                we are creating a new table, or if the table
                                so far has no constraints for which the name
                                was generated here */
        dict_table_t*   table,  /* in: table */
        trx_t*          trx)    /* in: transaction */
{
        dict_foreign_t* foreign;
        ulint           number  = start_id + 1;
        ulint           error;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        if (NULL == dict_table_get_low("SYS_FOREIGN")) {
                fprintf(stderr,
"InnoDB: table SYS_FOREIGN not found from internal data dictionary\n");

                return(DB_ERROR);
        }

        for (foreign = UT_LIST_GET_FIRST(table->foreign_list);
             foreign;
             foreign = UT_LIST_GET_NEXT(foreign_list, foreign)) {

                error = dict_create_add_foreign_to_dictionary(&number,
                        table, foreign, trx);

                if (error != DB_SUCCESS) {

                        return(error);
                }
        }

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

que_thr_t* dict_create_index_step

(

que_thr_t *

thr

)

Definition at line 1000 of file dict0crea.c.

References DB_ERROR, DB_LOCK_WAIT, DB_SUCCESS, dict_build_field_def_step(), dict_build_index_def_step(), dict_create_index_tree_step(), dict_index_add_to_cache(), dict_sys, err, trx_struct::error_state, ind_node_struct::field_def, ind_node_struct::field_no, ind_node_struct::ind_def, ind_node_struct::index, INDEX_ADD_TO_CACHE, INDEX_BUILD_FIELD_DEF, INDEX_BUILD_INDEX_DEF, INDEX_COMMIT_WORK, INDEX_CREATE_INDEX_TREE, dict_sys_struct::mutex, NULL, ind_node_struct::page_no, que_thr_struct::prev_node, QUE_NODE_CREATE_INDEX, que_node_get_parent(), que_node_get_type(), que_thr_struct::run_node, ind_node_struct::state, ind_node_struct::table, thr_get_trx(), ut_a, and ut_ad.

Referenced by que_thr_step().

                                      : query thread to run next or NULL */
        que_thr_t*      thr)    /* in: query thread */
{
        ind_node_t*     node;
        ibool           success;
        ulint           err     = DB_ERROR;
        trx_t*          trx;

        ut_ad(thr);
#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        trx = thr_get_trx(thr);

        node = thr->run_node;

        ut_ad(que_node_get_type(node) == QUE_NODE_CREATE_INDEX);

        if (thr->prev_node == que_node_get_parent(node)) {
                node->state = INDEX_BUILD_INDEX_DEF;
        }

        if (node->state == INDEX_BUILD_INDEX_DEF) {
                /* DO THE CHECKS OF THE CONSISTENCY CONSTRAINTS HERE */
                err = dict_build_index_def_step(thr, node);

                if (err != DB_SUCCESS) {

                        goto function_exit;
                }

                node->state = INDEX_BUILD_FIELD_DEF;
                node->field_no = 0;

                thr->run_node = node->ind_def;

                return(thr);
        }

        if (node->state == INDEX_BUILD_FIELD_DEF) {

                if (node->field_no < (node->index)->n_fields) {

                        err = dict_build_field_def_step(node);

                        if (err != DB_SUCCESS) {

                                goto function_exit;
                        }

                        node->field_no++;

                        thr->run_node = node->field_def;

                        return(thr);
                } else {
                        node->state = INDEX_CREATE_INDEX_TREE;
                }
        }

        if (node->state == INDEX_CREATE_INDEX_TREE) {

                err = dict_create_index_tree_step(node);

                if (err != DB_SUCCESS) {

                        goto function_exit;
                }

                node->state = INDEX_COMMIT_WORK;
        }

        if (node->state == INDEX_COMMIT_WORK) {

                /* Index was correctly defined: do NOT commit the transaction
                (CREATE INDEX does NOT currently do an implicit commit of
                the current transaction) */

                node->state = INDEX_ADD_TO_CACHE;

                /* thr->run_node = node->commit_node;

                return(thr); */
        }

        if (node->state == INDEX_ADD_TO_CACHE) {

                success = dict_index_add_to_cache(node->table, node->index,
                                node->page_no);

                ut_a(success);

                err = DB_SUCCESS;
        }

function_exit:
        trx->error_state = err;

        if (err == DB_SUCCESS) {
                /* Ok: do nothing */

        } else if (err == DB_LOCK_WAIT) {

                return(NULL);
        } else {
                /* SQL error detected */

                return(NULL);
        }

        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:

static ulint dict_create_index_tree_step

(

ind_node_t *

node

)

[static]

Definition at line 573 of file dict0crea.c.

References btr_create(), BTR_MODIFY_LEAF, btr_pcur_close(), btr_pcur_get_rec(), btr_pcur_move_to_next_user_rec(), btr_pcur_open(), DB_OUT_OF_FILE_SPACE, DB_SUCCESS, dict_create_search_tuple(), dict_sys, DICT_SYS_INDEXES_PAGE_NO_FIELD, dict_table_is_comp(), FIL_NULL, ind_node_struct::heap, ind_node_struct::ind_row, ind_node_struct::index, index(), dict_table_struct::indexes, mtr_commit(), mtr_start(), dict_sys_struct::mutex, PAGE_CUR_L, ind_node_struct::page_no, page_rec_write_index_page_no(), dict_sys_struct::sys_indexes, ind_node_struct::table, ut_ad, and UT_LIST_GET_FIRST.

Referenced by dict_create_index_step().

                                      : DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
        ind_node_t*     node)   /* in: index create node */
{
        dict_index_t*   index;
        dict_table_t*   sys_indexes;
        dict_table_t*   table;
        dtuple_t*       search_tuple;
        btr_pcur_t      pcur;
        mtr_t           mtr;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        index = node->index;
        table = node->table;

        sys_indexes = dict_sys->sys_indexes;

        /* Run a mini-transaction in which the index tree is allocated for
        the index and its root address is written to the index entry in
        sys_indexes */

        mtr_start(&mtr);

        search_tuple = dict_create_search_tuple(node->ind_row, node->heap);

        btr_pcur_open(UT_LIST_GET_FIRST(sys_indexes->indexes),
                                search_tuple, PAGE_CUR_L, BTR_MODIFY_LEAF,
                                &pcur, &mtr);

        btr_pcur_move_to_next_user_rec(&pcur, &mtr);

        node->page_no = btr_create(index->type, index->space, index->id,
                dict_table_is_comp(table), &mtr);
        /* printf("Created a new index tree in space %lu root page %lu\n",
                                        index->space, index->page_no); */

        page_rec_write_index_page_no(btr_pcur_get_rec(&pcur),
                                        DICT_SYS_INDEXES_PAGE_NO_FIELD,
                                        node->page_no, &mtr);
        btr_pcur_close(&pcur);
        mtr_commit(&mtr);

        if (node->page_no == FIL_NULL) {

                return(DB_OUT_OF_FILE_SPACE);
        }

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint dict_create_or_check_foreign_constraint_tables

(

void

)

Definition at line 1124 of file dict0crea.c.

References DB_MUST_GET_MORE_FILE_SPACE, DB_OUT_OF_FILE_SPACE, DB_SUCCESS, dict_sys, dict_table_get_low(), error, FALSE, dict_table_struct::indexes, dict_sys_struct::mutex, mutex_enter, mutex_exit(), NULL, trx_struct::op_info, que_eval_sql(), row_drop_table_for_mysql(), row_mysql_lock_data_dictionary(), row_mysql_unlock_data_dictionary(), table2, TRUE, trx_allocate_for_mysql(), trx_free_for_mysql(), ut_a, and UT_LIST_GET_LEN.

Referenced by innobase_start_or_create_for_mysql().

                                      : DB_SUCCESS or error code */
{
        dict_table_t*   table1;
        dict_table_t*   table2;
        ulint           error;
        trx_t*          trx;

        mutex_enter(&(dict_sys->mutex));

        table1 = dict_table_get_low("SYS_FOREIGN");
        table2 = dict_table_get_low("SYS_FOREIGN_COLS");

        if (table1 && table2
                && UT_LIST_GET_LEN(table1->indexes) == 3
                && UT_LIST_GET_LEN(table2->indexes) == 1) {

                /* Foreign constraint system tables have already been
                created, and they are ok */

                mutex_exit(&(dict_sys->mutex));

                return(DB_SUCCESS);
        }

        mutex_exit(&(dict_sys->mutex));

        trx = trx_allocate_for_mysql();

        trx->op_info = "creating foreign key sys tables";

        row_mysql_lock_data_dictionary(trx);

        if (table1) {
                fprintf(stderr,
                "InnoDB: dropping incompletely created SYS_FOREIGN table\n");
                row_drop_table_for_mysql("SYS_FOREIGN", trx, TRUE);
        }

        if (table2) {
                fprintf(stderr,
        "InnoDB: dropping incompletely created SYS_FOREIGN_COLS table\n");
                row_drop_table_for_mysql("SYS_FOREIGN_COLS", trx, TRUE);
        }

        fprintf(stderr,
                "InnoDB: Creating foreign key constraint system tables\n");

        /* NOTE: in dict_load_foreigns we use the fact that
        there are 2 secondary indexes on SYS_FOREIGN, and they
        are defined just like below */

        /* NOTE: when designing InnoDB's foreign key support in 2001, we made
        an error and made the table names and the foreign key id of type
        'CHAR' (internally, really a VARCHAR). We should have made the type
        VARBINARY, like in other InnoDB system tables, to get a clean
        design. */

        error = que_eval_sql(NULL,
        "PROCEDURE CREATE_FOREIGN_SYS_TABLES_PROC () IS\n"
        "BEGIN\n"
        "CREATE TABLE\n"
        "SYS_FOREIGN(ID CHAR, FOR_NAME CHAR, REF_NAME CHAR, N_COLS INT);\n"
        "CREATE UNIQUE CLUSTERED INDEX ID_IND ON SYS_FOREIGN (ID);\n"
        "CREATE INDEX FOR_IND ON SYS_FOREIGN (FOR_NAME);\n"
        "CREATE INDEX REF_IND ON SYS_FOREIGN (REF_NAME);\n"
        "CREATE TABLE\n"
  "SYS_FOREIGN_COLS(ID CHAR, POS INT, FOR_COL_NAME CHAR, REF_COL_NAME CHAR);\n"
        "CREATE UNIQUE CLUSTERED INDEX ID_IND ON SYS_FOREIGN_COLS (ID, POS);\n"
        "COMMIT WORK;\n"
        "END;\n"
                , FALSE, trx);

        if (error != DB_SUCCESS) {
                fprintf(stderr, "InnoDB: error %lu in creation\n",
                        (ulong) error);

                ut_a(error == DB_OUT_OF_FILE_SPACE);

                fprintf(stderr, "InnoDB: creation failed\n");
                fprintf(stderr, "InnoDB: tablespace is full\n");
                fprintf(stderr,
                "InnoDB: dropping incompletely created SYS_FOREIGN tables\n");

                row_drop_table_for_mysql("SYS_FOREIGN", trx, TRUE);
                row_drop_table_for_mysql("SYS_FOREIGN_COLS", trx, TRUE);

                error = DB_MUST_GET_MORE_FILE_SPACE;
        }

        trx->op_info = "";

        row_mysql_unlock_data_dictionary(trx);

        trx_free_for_mysql(trx);

        if (error == DB_SUCCESS) {
                fprintf(stderr,
                "InnoDB: Foreign key constraint system tables created\n");
        }

        return(error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static dtuple_t* dict_create_search_tuple	(	dtuple_t *	tuple,
		mem_heap_t *	heap
	)			[static]

Definition at line 466 of file dict0crea.c.

References dfield_copy(), dtuple_create(), dtuple_get_nth_field(), and ut_ad.

Referenced by dict_create_index_tree_step().

                                      : the tuple for search */
        dtuple_t*       tuple,  /* in: the tuple inserted in the SYS_INDEXES
                                table */
        mem_heap_t*     heap)   /* in: memory heap from which the memory for
                                the built tuple is allocated */
{
        dtuple_t*       search_tuple;
        dfield_t*       field1;
        dfield_t*       field2;

        ut_ad(tuple && heap);

        search_tuple = dtuple_create(heap, 2);

        field1 = dtuple_get_nth_field(tuple, 0);
        field2 = dtuple_get_nth_field(search_tuple, 0);

        dfield_copy(field2, field1);

        field1 = dtuple_get_nth_field(tuple, 1);
        field2 = dtuple_get_nth_field(search_tuple, 1);

        dfield_copy(field2, field1);

        ut_ad(dtuple_validate(search_tuple));

        return(search_tuple);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static dtuple_t* dict_create_sys_columns_tuple	(	dict_table_t *	table,
		ulint	i,
		mem_heap_t *	heap
	)			[static]

Definition at line 119 of file dict0crea.c.

References DATA_N_SYS_COLS, dfield_set_data(), dict_sys, dict_table_copy_types(), dict_table_get_nth_col(), dtuple_create(), dtuple_get_nth_field(), dict_table_struct::id, mach_write_to_4(), mach_write_to_8(), mem_heap_alloc(), dict_col_struct::name, dict_sys_struct::sys_columns, dict_col_struct::type, ut_ad, and ut_strlen().

Referenced by dict_build_col_def_step().

                                      : the tuple which should be inserted */
        dict_table_t*   table,  /* in: table */
        ulint           i,      /* in: column number */
        mem_heap_t*     heap)   /* in: memory heap from which the memory for
                                the built tuple is allocated */
{
        dict_table_t*   sys_columns;
        dtuple_t*       entry;
        dict_col_t*     column;
        dfield_t*       dfield;
        byte*           ptr;

        ut_ad(table && heap);

        column = dict_table_get_nth_col(table, i);

        sys_columns = dict_sys->sys_columns;

        entry = dtuple_create(heap, 7 + DATA_N_SYS_COLS);

        /* 0: TABLE_ID -----------------------*/
        dfield = dtuple_get_nth_field(entry, 0);

        ptr = mem_heap_alloc(heap, 8);
        mach_write_to_8(ptr, table->id);

        dfield_set_data(dfield, ptr, 8);
        /* 1: POS ----------------------------*/
        dfield = dtuple_get_nth_field(entry, 1);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, i);

        dfield_set_data(dfield, ptr, 4);
        /* 4: NAME ---------------------------*/
        dfield = dtuple_get_nth_field(entry, 2);

        dfield_set_data(dfield, column->name, ut_strlen(column->name));
        /* 5: MTYPE --------------------------*/
        dfield = dtuple_get_nth_field(entry, 3);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, (column->type).mtype);

        dfield_set_data(dfield, ptr, 4);
        /* 6: PRTYPE -------------------------*/
        dfield = dtuple_get_nth_field(entry, 4);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, (column->type).prtype);

        dfield_set_data(dfield, ptr, 4);
        /* 7: LEN ----------------------------*/
        dfield = dtuple_get_nth_field(entry, 5);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, (column->type).len);

        dfield_set_data(dfield, ptr, 4);
        /* 8: PREC ---------------------------*/
        dfield = dtuple_get_nth_field(entry, 6);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, (column->type).prec);

        dfield_set_data(dfield, ptr, 4);
        /*---------------------------------*/

        dict_table_copy_types(entry, sys_columns);

        return(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static dtuple_t* dict_create_sys_fields_tuple	(	dict_index_t *	index,
		ulint	i,
		mem_heap_t *	heap
	)			[static]

Definition at line 391 of file dict0crea.c.

References DATA_N_SYS_COLS, dfield_set_data(), dict_index_get_nth_field(), dict_sys, dict_table_copy_types(), dtuple_create(), dtuple_get_nth_field(), FALSE, index(), mach_write_to_4(), mach_write_to_8(), mem_heap_alloc(), dict_field_struct::name, dict_field_struct::prefix_len, dict_sys_struct::sys_fields, TRUE, ut_ad, and ut_strlen().

Referenced by dict_build_field_def_step().

                                      : the tuple which should be inserted */
        dict_index_t*   index,  /* in: index */
        ulint           i,      /* in: field number */
        mem_heap_t*     heap)   /* in: memory heap from which the memory for
                                the built tuple is allocated */
{
        dict_table_t*   sys_fields;
        dtuple_t*       entry;
        dict_field_t*   field;
        dfield_t*       dfield;
        byte*           ptr;
        ibool           index_contains_column_prefix_field      = FALSE;
        ulint           j;

        ut_ad(index && heap);

        for (j = 0; j < index->n_fields; j++) {
                if (dict_index_get_nth_field(index, j)->prefix_len > 0) {
                        index_contains_column_prefix_field = TRUE;
                }
        }

        field = dict_index_get_nth_field(index, i);

        sys_fields = dict_sys->sys_fields;

        entry = dtuple_create(heap, 3 + DATA_N_SYS_COLS);

        /* 0: INDEX_ID -----------------------*/
        dfield = dtuple_get_nth_field(entry, 0);

        ptr = mem_heap_alloc(heap, 8);
        mach_write_to_8(ptr, index->id);

        dfield_set_data(dfield, ptr, 8);
        /* 1: POS + PREFIX LENGTH ----------------------------*/

        dfield = dtuple_get_nth_field(entry, 1);

        ptr = mem_heap_alloc(heap, 4);

        if (index_contains_column_prefix_field) {
                /* If there are column prefix fields in the index, then
                we store the number of the field to the 2 HIGH bytes
                and the prefix length to the 2 low bytes, */

                mach_write_to_4(ptr, (i << 16) + field->prefix_len);
        } else {
                /* Else we store the number of the field to the 2 LOW bytes.
                This is to keep the storage format compatible with
                InnoDB versions < 4.0.14. */

                mach_write_to_4(ptr, i);
        }

        dfield_set_data(dfield, ptr, 4);
        /* 4: COL_NAME -------------------------*/
        dfield = dtuple_get_nth_field(entry, 2);

        dfield_set_data(dfield, field->name,
                                ut_strlen(field->name));
        /*---------------------------------*/

        dict_table_copy_types(entry, sys_fields);

        return(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static dtuple_t* dict_create_sys_indexes_tuple	(	dict_index_t *	index,
		mem_heap_t *	heap
	)			[static]

Definition at line 299 of file dict0crea.c.

References DATA_N_SYS_COLS, dfield_set_data(), dict_sys, dict_table_copy_types(), dict_table_get_low(), dtuple_create(), dtuple_get_nth_field(), FIL_NULL, dict_table_struct::id, index(), mach_write_to_4(), mach_write_to_8(), mem_heap_alloc(), dict_sys_struct::mutex, dict_sys_struct::sys_indexes, ut_ad, and ut_strlen().

Referenced by dict_build_index_def_step().

                                      : the tuple which should be inserted */
        dict_index_t*   index,  /* in: index */
        mem_heap_t*     heap)   /* in: memory heap from which the memory for
                                the built tuple is allocated */
{
        dict_table_t*   sys_indexes;
        dict_table_t*   table;
        dtuple_t*       entry;
        dfield_t*       dfield;
        byte*           ptr;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */
        ut_ad(index && heap);

        sys_indexes = dict_sys->sys_indexes;

        table = dict_table_get_low(index->table_name);

        entry = dtuple_create(heap, 7 + DATA_N_SYS_COLS);

        /* 0: TABLE_ID -----------------------*/
        dfield = dtuple_get_nth_field(entry, 0);

        ptr = mem_heap_alloc(heap, 8);
        mach_write_to_8(ptr, table->id);

        dfield_set_data(dfield, ptr, 8);
        /* 1: ID ----------------------------*/
        dfield = dtuple_get_nth_field(entry, 1);

        ptr = mem_heap_alloc(heap, 8);
        mach_write_to_8(ptr, index->id);

        dfield_set_data(dfield, ptr, 8);
        /* 4: NAME --------------------------*/
        dfield = dtuple_get_nth_field(entry, 2);

        dfield_set_data(dfield, index->name, ut_strlen(index->name));
        /* 5: N_FIELDS ----------------------*/
        dfield = dtuple_get_nth_field(entry, 3);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, index->n_fields);

        dfield_set_data(dfield, ptr, 4);
        /* 6: TYPE --------------------------*/
        dfield = dtuple_get_nth_field(entry, 4);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, index->type);

        dfield_set_data(dfield, ptr, 4);
        /* 7: SPACE --------------------------*/

#if DICT_SYS_INDEXES_SPACE_NO_FIELD != 7
#error "DICT_SYS_INDEXES_SPACE_NO_FIELD != 7"
#endif

        dfield = dtuple_get_nth_field(entry, 5);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, index->space);

        dfield_set_data(dfield, ptr, 4);
        /* 8: PAGE_NO --------------------------*/

#if DICT_SYS_INDEXES_PAGE_NO_FIELD != 8
#error "DICT_SYS_INDEXES_PAGE_NO_FIELD != 8"
#endif

        dfield = dtuple_get_nth_field(entry, 6);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, FIL_NULL);

        dfield_set_data(dfield, ptr, 4);
        /*--------------------------------*/

        dict_table_copy_types(entry, sys_indexes);

        return(entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static dtuple_t* dict_create_sys_tables_tuple	(	dict_table_t *	table,
		mem_heap_t *	heap
	)			[static]

Definition at line 34 of file dict0crea.c.

References DATA_N_SYS_COLS, dfield_set_data(), dict_sys, dict_table_copy_types(), DICT_TABLE_ORDINARY, DICT_TF_COMPACT, dtuple_create(), dtuple_get_nth_field(), dict_table_struct::flags, dict_table_struct::id, mach_write_to_4(), mach_write_to_8(), mem_heap_alloc(), memset, dict_table_struct::n_def, dict_table_struct::name, NULL, dict_table_struct::space, dict_sys_struct::sys_tables, ut_ad, and ut_strlen().

                                      : the tuple which should be inserted */
        dict_table_t*   table,  /* in: table */
        mem_heap_t*     heap)   /* in: memory heap from which the memory for
                                the built tuple is allocated */
{
        dict_table_t*   sys_tables;
        dtuple_t*       entry;
        dfield_t*       dfield;
        byte*           ptr;

        ut_ad(table && heap);

        sys_tables = dict_sys->sys_tables;

        entry = dtuple_create(heap, 8 + DATA_N_SYS_COLS);

        /* 0: NAME -----------------------------*/
        dfield = dtuple_get_nth_field(entry, 0);

        dfield_set_data(dfield, table->name, ut_strlen(table->name));
        /* 3: ID -------------------------------*/
        dfield = dtuple_get_nth_field(entry, 1);

        ptr = mem_heap_alloc(heap, 8);
        mach_write_to_8(ptr, table->id);

        dfield_set_data(dfield, ptr, 8);
        /* 4: N_COLS ---------------------------*/
        dfield = dtuple_get_nth_field(entry, 2);

#if DICT_TF_COMPACT != 1
#error
#endif

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, table->n_def
                | ((table->flags & DICT_TF_COMPACT) << 31));
        dfield_set_data(dfield, ptr, 4);
        /* 5: TYPE -----------------------------*/
        dfield = dtuple_get_nth_field(entry, 3);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, DICT_TABLE_ORDINARY);

        dfield_set_data(dfield, ptr, 4);
        /* 6: MIX_ID ---------------------------*/
        dfield = dtuple_get_nth_field(entry, 4);

        ptr = mem_heap_alloc(heap, 8);
        memset(ptr, 0, 8);

        dfield_set_data(dfield, ptr, 8);
        /* 7: MIX_LEN --------------------------*/

        dfield = dtuple_get_nth_field(entry, 5);

        ptr = mem_heap_alloc(heap, 4);
        memset(ptr, 0, 4);

        dfield_set_data(dfield, ptr, 4);
        /* 8: CLUSTER_NAME ---------------------*/
        dfield = dtuple_get_nth_field(entry, 6);
        dfield_set_data(dfield, NULL, UNIV_SQL_NULL); /* not supported */

        /* 9: SPACE ----------------------------*/
        dfield = dtuple_get_nth_field(entry, 7);

        ptr = mem_heap_alloc(heap, 4);
        mach_write_to_4(ptr, table->space);

        dfield_set_data(dfield, ptr, 4);
        /*----------------------------------*/

        dict_table_copy_types(entry, sys_tables);

        return(entry);
}

Here is the call graph for this function:

que_thr_t* dict_create_table_step

(

que_thr_t *

thr

)

Definition at line 891 of file dict0crea.c.

References tab_node_struct::col_def, tab_node_struct::col_no, DB_ERROR, DB_LOCK_WAIT, DB_SUCCESS, dict_build_col_def_step(), dict_build_table_def_step(), dict_sys, dict_table_add_to_cache(), err, trx_struct::error_state, dict_sys_struct::mutex, NULL, que_thr_struct::prev_node, QUE_NODE_CREATE_TABLE, que_node_get_parent(), que_node_get_type(), que_thr_struct::run_node, tab_node_struct::state, tab_node_struct::tab_def, tab_node_struct::table, TABLE_ADD_TO_CACHE, TABLE_BUILD_COL_DEF, TABLE_BUILD_TABLE_DEF, TABLE_COMMIT_WORK, thr_get_trx(), and ut_ad.

Referenced by que_thr_step().

                                      : query thread to run next or NULL */
        que_thr_t*      thr)    /* in: query thread */
{
        tab_node_t*     node;
        ulint           err     = DB_ERROR;
        trx_t*          trx;

        ut_ad(thr);
#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        trx = thr_get_trx(thr);

        node = thr->run_node;

        ut_ad(que_node_get_type(node) == QUE_NODE_CREATE_TABLE);

        if (thr->prev_node == que_node_get_parent(node)) {
                node->state = TABLE_BUILD_TABLE_DEF;
        }

        if (node->state == TABLE_BUILD_TABLE_DEF) {

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

                err = dict_build_table_def_step(thr, node);

                if (err != DB_SUCCESS) {

                        goto function_exit;
                }

                node->state = TABLE_BUILD_COL_DEF;
                node->col_no = 0;

                thr->run_node = node->tab_def;

                return(thr);
        }

        if (node->state == TABLE_BUILD_COL_DEF) {

                if (node->col_no < (node->table)->n_def) {

                        err = dict_build_col_def_step(node);

                        if (err != DB_SUCCESS) {

                                goto function_exit;
                        }

                        node->col_no++;

                        thr->run_node = node->col_def;

                        return(thr);
                } else {
                        node->state = TABLE_COMMIT_WORK;
                }
        }

        if (node->state == TABLE_COMMIT_WORK) {

                /* Table was correctly defined: do NOT commit the transaction
                (CREATE TABLE does NOT do an implicit commit of the current
                transaction) */

                node->state = TABLE_ADD_TO_CACHE;

                /* thr->run_node = node->commit_node;

                return(thr); */
        }

        if (node->state == TABLE_ADD_TO_CACHE) {

                dict_table_add_to_cache(node->table);

                err = DB_SUCCESS;
        }

function_exit:
        trx->error_state = err;

        if (err == DB_SUCCESS) {
                /* Ok: do nothing */

        } else if (err == DB_LOCK_WAIT) {

                return(NULL);
        } else {
                /* SQL error detected */

                return(NULL);
        }

        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:

void dict_drop_index_tree	(	rec_t *	rec,
		mtr_t *	mtr
	)

Definition at line 631 of file dict0crea.c.

References btr_free_but_not_root(), btr_free_root(), dict_sys, DICT_SYS_INDEXES_PAGE_NO_FIELD, DICT_SYS_INDEXES_SPACE_NO_FIELD, dict_table_is_comp(), FIL_NULL, fil_tablespace_exists_in_mem(), MLOG_4BYTES, mtr_read_ulint(), dict_sys_struct::mutex, page_rec_write_index_page_no(), rec_get_nth_field_old(), dict_sys_struct::sys_indexes, ut_a, and ut_ad.

Referenced by row_undo_ins_remove_clust_rec(), and row_upd_clust_step().

                             : record in the clustered index of SYS_INDEXES
                        table */
        mtr_t*  mtr)    /* in: mtr having the latch on the record page */
{
        ulint   root_page_no;
        ulint   space;
        byte*   ptr;
        ulint   len;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        ut_a(!dict_table_is_comp(dict_sys->sys_indexes));
        ptr = rec_get_nth_field_old(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD, &len);

        ut_ad(len == 4);

        root_page_no = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);

        if (root_page_no == FIL_NULL) {
                /* The tree has already been freed */

                return;
        }

        ptr = rec_get_nth_field_old(rec,
                                DICT_SYS_INDEXES_SPACE_NO_FIELD, &len);

        ut_ad(len == 4);

        space = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);

        if (!fil_tablespace_exists_in_mem(space)) {
                /* It is a single table tablespace and the .ibd file is
                missing: do nothing */

                return;
        }

        /* We free all the pages but the root page first; this operation
        may span several mini-transactions */

        btr_free_but_not_root(space, root_page_no);

        /* Then we free the root page in the same mini-transaction where
        we write FIL_NULL to the appropriate field in the SYS_INDEXES
        record: this mini-transaction marks the B-tree totally freed */

        /* printf("Dropping index tree in space %lu root page %lu\n", space,
                                                         root_page_no); */
        btr_free_root(space, root_page_no, mtr);

        page_rec_write_index_page_no(rec,
                                DICT_SYS_INDEXES_PAGE_NO_FIELD, FIL_NULL, mtr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint dict_foreign_eval_sql	(	pars_info_t *	info,
		const char *	sql,
		dict_table_t *	table,
		dict_foreign_t *	foreign,
		trx_t *	trx
	)

Definition at line 1233 of file dict0crea.c.

References DB_DUPLICATE_KEY, DB_SUCCESS, dict_foreign_err_file, dict_foreign_err_mutex, error, FALSE, dict_foreign_struct::id, mutex_enter, mutex_exit(), dict_table_struct::name, que_eval_sql(), TRUE, ut_print_name(), and ut_print_timestamp().

Referenced by dict_create_add_foreign_field_to_dictionary(), and dict_create_add_foreign_to_dictionary().

                                      : error code or DB_SUCCESS */
        pars_info_t*    info,   /* in: info struct, or NULL */
        const char*     sql,    /* in: SQL string to evaluate */
        dict_table_t*   table,  /* in: table */
        dict_foreign_t* foreign,/* in: foreign */
        trx_t*          trx)    /* in: transaction */
{
        ulint           error;
        FILE*           ef      = dict_foreign_err_file;

        error = que_eval_sql(info, sql, FALSE, trx);

        if (error == DB_DUPLICATE_KEY) {
                mutex_enter(&dict_foreign_err_mutex);
                rewind(ef);
                ut_print_timestamp(ef);
                fputs(" Error in foreign key constraint creation for table ",
                        ef);
                ut_print_name(ef, trx, TRUE, table->name);
                fputs(".\nA foreign key constraint of name ", ef);
                ut_print_name(ef, trx, FALSE, foreign->id);
                fputs("\nalready exists."
                        " (Note that internally InnoDB adds 'databasename/'\n"
                        "in front of the user-defined constraint name).\n",
                        ef);
                fputs("Note that InnoDB's FOREIGN KEY system tables store\n"
                        "constraint names as case-insensitive, with the\n"
                        "MySQL standard latin1_swedish_ci collation. If you\n"
                        "create tables or databases whose names differ only in\n"
                        "the character case, then collisions in constraint\n"
                        "names can occur. Workaround: name your constraints\n"
                        "explicitly with unique names.\n",
                        ef);

                mutex_exit(&dict_foreign_err_mutex);

                return(error);
        }

        if (error != DB_SUCCESS) {
                fprintf(stderr,
                        "InnoDB: Foreign key constraint creation failed:\n"
                        "InnoDB: internal error number %lu\n", (ulong) error);

                mutex_enter(&dict_foreign_err_mutex);
                ut_print_timestamp(ef);
                fputs(" Internal error in foreign key constraint creation"
                        " for table ", ef);
                ut_print_name(ef, trx, TRUE, table->name);
                fputs(".\n"
        "See the MySQL .err log in the datadir for more information.\n", ef);
                mutex_exit(&dict_foreign_err_mutex);

                return(error);
        }

        return(DB_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint dict_truncate_index_tree	(	dict_table_t *	table,
		rec_t *	rec,
		mtr_t *	mtr
	)

Definition at line 694 of file dict0crea.c.

References btr_create(), btr_free_but_not_root(), btr_free_root(), btr_page_get(), dict_sys, DICT_SYS_INDEXES_PAGE_NO_FIELD, DICT_SYS_INDEXES_SPACE_NO_FIELD, DICT_SYS_INDEXES_TYPE_FIELD, dict_table_is_comp(), FIL_NULL, fil_tablespace_exists_in_mem(), index(), dict_table_struct::indexes, mach_read_from_4(), mach_read_from_8(), MLOG_4BYTES, mtr_commit(), mtr_read_ulint(), mtr_start(), dict_sys_struct::mutex, dict_table_struct::name, NULL, page_is_comp(), page_rec_write_index_page_no(), rec_get_nth_field_old(), RW_X_LATCH, dict_sys_struct::sys_indexes, ut_a, ut_ad, ut_dulint_cmp(), ut_dulint_get_high(), ut_dulint_get_low(), UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, and ut_print_timestamp().

Referenced by row_truncate_table_for_mysql().

                                      : new root page number, or
                                FIL_NULL on failure */
        dict_table_t*   table,  /* in: the table the index belongs to */
        rec_t*          rec,    /* in: record in the clustered index of
                                SYS_INDEXES table */
        mtr_t*          mtr)    /* in: mtr having the latch
                                on the record page. The mtr may be
                                committed and restarted in this call. */
{
        ulint           root_page_no;
        ulint           space;
        ulint           type;
        dulint          index_id;
        byte*           ptr;
        ulint           len;
        ulint           comp;
        dict_index_t*   index;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        ut_a(!dict_table_is_comp(dict_sys->sys_indexes));
        ptr = rec_get_nth_field_old(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD, &len);

        ut_ad(len == 4);

        root_page_no = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);

        if (root_page_no == FIL_NULL) {
                /* The tree has been freed. */

                ut_print_timestamp(stderr);
                fprintf(stderr, "  InnoDB: Trying to TRUNCATE"
                        " a missing index of table %s!\n", table->name);
                return(FIL_NULL);
        }

        ptr = rec_get_nth_field_old(rec,
                                DICT_SYS_INDEXES_SPACE_NO_FIELD, &len);

        ut_ad(len == 4);

        space = mtr_read_ulint(ptr, MLOG_4BYTES, mtr);

        if (!fil_tablespace_exists_in_mem(space)) {
                /* It is a single table tablespace and the .ibd file is
                missing: do nothing */

                ut_print_timestamp(stderr);
                fprintf(stderr, "  InnoDB: Trying to TRUNCATE"
                        " a missing .ibd file of table %s!\n", table->name);
                return(FIL_NULL);
        }

        ptr = rec_get_nth_field_old(rec,
                                DICT_SYS_INDEXES_TYPE_FIELD, &len);
        ut_ad(len == 4);
        type = mach_read_from_4(ptr);

        ptr = rec_get_nth_field_old(rec, 1, &len);
        ut_ad(len == 8);
        index_id = mach_read_from_8(ptr);

        /* We free all the pages but the root page first; this operation
        may span several mini-transactions */

        btr_free_but_not_root(space, root_page_no);

        /* Then we free the root page in the same mini-transaction where
        we create the b-tree and write its new root page number to the
        appropriate field in the SYS_INDEXES record: this mini-transaction
        marks the B-tree totally truncated */

        comp = page_is_comp(btr_page_get(
                                space, root_page_no, RW_X_LATCH, mtr));

        btr_free_root(space, root_page_no, mtr);
        /* We will temporarily write FIL_NULL to the PAGE_NO field
        in SYS_INDEXES, so that the database will not get into an
        inconsistent state in case it crashes between the mtr_commit()
        below and the following mtr_commit() call. */
        page_rec_write_index_page_no(rec, DICT_SYS_INDEXES_PAGE_NO_FIELD,
                                                        FIL_NULL, mtr);

        /* We will need to commit the mini-transaction in order to avoid
        deadlocks in the btr_create() call, because otherwise we would
        be freeing and allocating pages in the same mini-transaction. */
        mtr_commit(mtr);
        /* mtr_commit() will invalidate rec. */
        rec = NULL;
        mtr_start(mtr);

        /* Find the index corresponding to this SYS_INDEXES record. */
        for (index = UT_LIST_GET_FIRST(table->indexes);
                        index;
                        index = UT_LIST_GET_NEXT(indexes, index)) {
                if (!ut_dulint_cmp(index->id, index_id)) {
                        break;
                }
        }

        root_page_no = btr_create(type, space, index_id, comp, mtr);
        if (index) {
                index->tree->page = root_page_no;
        } else {
                ut_print_timestamp(stderr);
                fprintf(stderr,
                        "  InnoDB: Index %lu %lu of table %s is missing\n"
                        "InnoDB: from the data dictionary during TRUNCATE!\n",
                        ut_dulint_get_high(index_id),
                        ut_dulint_get_low(index_id),
                        table->name);
        }

        return(root_page_no);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ind_node_t* ind_create_graph_create	(	dict_index_t *	index,
		mem_heap_t *	heap
	)

Definition at line 854 of file dict0crea.c.

References ind_node_struct::commit_node, commit_node_create(), ind_node_struct::common, ins_node_struct::common, commit_node_struct::common, dict_sys, ind_node_struct::field_def, FIL_NULL, ind_node_struct::heap, ind_node_struct::ind_def, ind_node_struct::index, index(), INDEX_BUILD_INDEX_DEF, INS_DIRECT, ins_node_create(), mem_heap_alloc(), mem_heap_create, ind_node_struct::page_no, que_common_struct::parent, QUE_NODE_CREATE_INDEX, ind_node_struct::state, dict_sys_struct::sys_fields, dict_sys_struct::sys_indexes, and que_common_struct::type.

Referenced by pars_create_index(), and row_create_index_for_mysql().

                                           : index create node */
        dict_index_t*   index,  /* in: index to create, built as a memory data
                                structure */
        mem_heap_t*     heap)   /* in: heap where created */
{
        ind_node_t*     node;

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

        node->common.type = QUE_NODE_CREATE_INDEX;

        node->index = index;

        node->state = INDEX_BUILD_INDEX_DEF;
        node->page_no = FIL_NULL;
        node->heap = mem_heap_create(256);

        node->ind_def = ins_node_create(INS_DIRECT,
                                                dict_sys->sys_indexes, heap);
        node->ind_def->common.parent = node;

        node->field_def = ins_node_create(INS_DIRECT,
                                                dict_sys->sys_fields, heap);
        node->field_def->common.parent = node;

        node->commit_node = commit_node_create(heap);
        node->commit_node->common.parent = node;

        return(node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tab_node_t* tab_create_graph_create	(	dict_table_t *	table,
		mem_heap_t *	heap
	)

Definition at line 818 of file dict0crea.c.

References tab_node_struct::col_def, tab_node_struct::commit_node, commit_node_create(), tab_node_struct::common, ins_node_struct::common, commit_node_struct::common, dict_sys, tab_node_struct::heap, INS_DIRECT, ins_node_create(), mem_heap_alloc(), mem_heap_create, que_common_struct::parent, QUE_NODE_CREATE_TABLE, tab_node_struct::state, dict_sys_struct::sys_columns, dict_sys_struct::sys_tables, tab_node_struct::tab_def, tab_node_struct::table, TABLE_BUILD_TABLE_DEF, and que_common_struct::type.

Referenced by pars_create_table(), and row_create_table_for_mysql().

                                           : table create node */
        dict_table_t*   table,  /* in: table to create, built as a memory data
                                structure */
        mem_heap_t*     heap)   /* in: heap where created */
{
        tab_node_t*     node;

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

        node->common.type = QUE_NODE_CREATE_TABLE;

        node->table = table;

        node->state = TABLE_BUILD_TABLE_DEF;
        node->heap = mem_heap_create(256);

        node->tab_def = ins_node_create(INS_DIRECT, dict_sys->sys_tables,
                                                                        heap);
        node->tab_def->common.parent = node;

        node->col_def = ins_node_create(INS_DIRECT, dict_sys->sys_columns,
                                                                        heap);
        node->col_def->common.parent = node;

        node->commit_node = commit_node_create(heap);
        node->commit_node->common.parent = node;

        return(node);
}

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.