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

#include "univ.i"
#include "dict0types.h"
#include "dict0dict.h"
#include "que0types.h"
#include "row0types.h"
#include "mtr0mtr.h"

Include dependency graph for dict0crea.h:

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

Go to the source code of this file.

Classes
struct	tab_node_struct
struct	ind_node_struct
Defines
#define	TABLE_BUILD_TABLE_DEF   1
#define	TABLE_BUILD_COL_DEF   2
#define	TABLE_COMMIT_WORK   3
#define	TABLE_ADD_TO_CACHE   4
#define	TABLE_COMPLETED   5
#define	INDEX_BUILD_INDEX_DEF   1
#define	INDEX_BUILD_FIELD_DEF   2
#define	INDEX_CREATE_INDEX_TREE   3
#define	INDEX_COMMIT_WORK   4
#define	INDEX_ADD_TO_CACHE   5
Functions
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_truncate_index_tree (dict_table_t *table, rec_t *rec, mtr_t *mtr)
void	dict_drop_index_tree (rec_t *rec, mtr_t *mtr)
ulint	dict_create_or_check_foreign_constraint_tables (void)
ulint	dict_create_add_foreigns_to_dictionary (ulint start_id, dict_table_t *table, trx_t *trx)

---

Define Documentation

#define INDEX_ADD_TO_CACHE   5

Definition at line 171 of file dict0crea.h.

Referenced by dict_create_index_step().

#define INDEX_BUILD_FIELD_DEF   2

Definition at line 168 of file dict0crea.h.

Referenced by dict_create_index_step().

#define INDEX_BUILD_INDEX_DEF   1

Definition at line 167 of file dict0crea.h.

Referenced by dict_create_index_step(), and ind_create_graph_create().

#define INDEX_COMMIT_WORK   4

Definition at line 170 of file dict0crea.h.

Referenced by dict_create_index_step().

#define INDEX_CREATE_INDEX_TREE   3

Definition at line 169 of file dict0crea.h.

Referenced by dict_create_index_step().

#define TABLE_ADD_TO_CACHE   4

Definition at line 138 of file dict0crea.h.

Referenced by dict_create_table_step().

#define TABLE_BUILD_COL_DEF   2

Definition at line 136 of file dict0crea.h.

Referenced by dict_create_table_step().

#define TABLE_BUILD_TABLE_DEF   1

Definition at line 135 of file dict0crea.h.

Referenced by dict_create_table_step(), and tab_create_graph_create().

#define TABLE_COMMIT_WORK   3

Definition at line 137 of file dict0crea.h.

Referenced by dict_create_table_step().

#define TABLE_COMPLETED   5

Definition at line 139 of file dict0crea.h.

---

Function Documentation

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:

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:

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_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(), commit_node_struct::common, ins_node_struct::common, ind_node_struct::common, dict_sys, ind_node_struct::field_def, FIL_NULL, ind_node_struct::heap, ind_node_struct::ind_def, index(), ind_node_struct::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(), commit_node_struct::common, ins_node_struct::common, tab_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.