Many files:

  Merge 3.23.52


innobase/btr/btr0btr.c:
  Merge 3.23.52
innobase/btr/btr0cur.c:
  Merge 3.23.52
innobase/btr/btr0sea.c:
  Merge 3.23.52
innobase/include/btr0btr.h:
  Merge 3.23.52
innobase/include/btr0cur.h:
  Merge 3.23.52
innobase/include/btr0sea.h:
  Merge 3.23.52
innobase/include/buf0buf.h:
  Merge 3.23.52
innobase/include/buf0rea.h:
  Merge 3.23.52
innobase/include/data0data.h:
  Merge 3.23.52
innobase/include/data0data.ic:
  Merge 3.23.52
innobase/include/log0log.h:
  Merge 3.23.52
innobase/include/log0log.ic:
  Merge 3.23.52
innobase/include/os0file.h:
  Merge 3.23.52
innobase/include/page0page.h:
  Merge 3.23.52
innobase/include/page0page.ic:
  Merge 3.23.52
innobase/include/row0mysql.h:
  Merge 3.23.52
innobase/include/trx0roll.h:
  Merge 3.23.52
innobase/include/trx0sys.h:
  Merge 3.23.52
innobase/include/trx0trx.h:
  Merge 3.23.52
innobase/include/ut0ut.h:
  Merge 3.23.52
innobase/include/univ.i:
  Merge 3.23.52
innobase/include/ut0ut.ic:
  Merge 3.23.52
innobase/buf/buf0buf.c:
  Merge 3.23.52
innobase/buf/buf0rea.c:
  Merge 3.23.52
innobase/data/data0data.c:
  Merge 3.23.52
innobase/dict/dict0crea.c:
  Merge 3.23.52
innobase/dict/dict0dict.c:
  Merge 3.23.52
innobase/dict/dict0load.c:
  Merge 3.23.52
innobase/dict/dict0mem.c:
  Merge 3.23.52
innobase/fsp/fsp0fsp.c:
  Merge 3.23.52
innobase/ibuf/ibuf0ibuf.c:
  Merge 3.23.52
innobase/lock/lock0lock.c:
  Merge 3.23.52
innobase/log/log0log.c:
  Merge 3.23.52
innobase/log/log0recv.c:
  Merge 3.23.52
innobase/mtr/mtr0log.c:
  Merge 3.23.52
innobase/mtr/mtr0mtr.c:
  Merge 3.23.52
innobase/os/os0file.c:
  Merge 3.23.52
innobase/page/page0cur.c:
  Merge 3.23.52
innobase/page/page0page.c:
  Merge 3.23.52
innobase/rem/rem0cmp.c:
  Merge 3.23.52
innobase/row/row0ins.c:
  Merge 3.23.52
innobase/row/row0mysql.c:
  Merge 3.23.52
innobase/row/row0purge.c:
  Merge 3.23.52
innobase/row/row0upd.c:
  Merge 3.23.52
innobase/srv/srv0srv.c:
  Merge 3.23.52
innobase/srv/srv0start.c:
  Merge 3.23.52
innobase/trx/trx0roll.c:
  Merge 3.23.52
innobase/trx/trx0sys.c:
  Merge 3.23.52
innobase/trx/trx0trx.c:
  Merge 3.23.52
innobase/trx/trx0undo.c:
  Merge 3.23.52
innobase/ut/ut0mem.c:
  Merge 3.23.52
innobase/ut/ut0ut.c:
  Merge 3.23.52

1 files changed, 357 insertions, 344 deletions

diff --git a/innobase/dict/dict0load.c b/innobase/dict/dict0load.c
index 4917359c748..6d48ddf4d95 100644
--- a/innobase/dict/dict0load.c
+++ b/innobase/dict/dict0load.c
@@ -21,33 +21,6 @@ Created 4/24/1996 Heikki Tuuri
 #include "dict0boot.h"
 
 /************************************************************************
-Loads definitions for table columns. */
-static
-void
-dict_load_columns(
-/*==============*/
-	dict_table_t*	table,	/* in: table */
-	mem_heap_t*	heap);	/* in: memory heap for temporary storage */
-/************************************************************************
-Loads definitions for table indexes. */
-static
-void
-dict_load_indexes(
-/*==============*/
-	dict_table_t*	table,	/* in: table */
-	mem_heap_t*	heap);	/* in: memory heap for temporary storage */
-/************************************************************************
-Loads definitions for index fields. */
-static
-void
-dict_load_fields(
-/*=============*/
-	dict_table_t*	table,	/* in: table */
-	dict_index_t*	index,	/* in: index whose fields to load */
-	mem_heap_t*	heap);	/* in: memory heap for temporary storage */
-
-
-/************************************************************************
 Finds the first table name in the given database. */
 
 char*
@@ -194,7 +167,12 @@ loop:
 			fprintf(stderr, "InnoDB: Failed to load table %s\n",
 								table_name);
 		} else {
-			dict_update_statistics_low(table, TRUE);
+			/* The table definition was corrupt if there
+			is no index */
+
+			if (dict_table_get_first_index(table)) {
+				dict_update_statistics_low(table, TRUE);
+			}
 
 			dict_table_print_low(table);
 		}
@@ -208,266 +186,6 @@ loop:
 }
 
 /************************************************************************
-Loads a table definition and also all its index definitions, and also
-the cluster definition if the table is a member in a cluster. Also loads
-all foreign key constraints where the foreign key is in the table or where
-a foreign key references columns in this table. Adds all these to the data
-dictionary cache. */
-
-dict_table_t*
-dict_load_table(
-/*============*/
-			/* out: table, NULL if does not exist */
-	char*	name)	/* in: table name */
-{
-	dict_table_t*	table;
-	dict_table_t*	sys_tables;
-	btr_pcur_t	pcur;
-	dict_index_t*	sys_index;
-	dtuple_t*	tuple;
-	mem_heap_t*	heap;
-	dfield_t*	dfield;
-	rec_t*		rec;
-	byte*		field;
-	ulint		len;
-	char*		buf;
-	ulint		space;
-	ulint		n_cols;
-	mtr_t		mtr;
-	
-	ut_ad(mutex_own(&(dict_sys->mutex)));
-
-	heap = mem_heap_create(1000);
-	
-	mtr_start(&mtr);
-
-	sys_tables = dict_table_get_low("SYS_TABLES");
-	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
-
-	tuple = dtuple_create(heap, 1);
-	dfield = dtuple_get_nth_field(tuple, 0);
-
-	dfield_set_data(dfield, name, ut_strlen(name));
-	dict_index_copy_types(tuple, sys_index, 1);
-
-	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
-					BTR_SEARCH_LEAF, &pcur, &mtr);
-	rec = btr_pcur_get_rec(&pcur);
-
-	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
-					|| rec_get_deleted_flag(rec)) {
-		/* Not found */
-
-		btr_pcur_close(&pcur);
-		mtr_commit(&mtr);
-		mem_heap_free(heap);
-		
-		return(NULL);
-	}	
-
-	field = rec_get_nth_field(rec, 0, &len);
-
-	/* Check if the table name in record is the searched one */
-	if (len != ut_strlen(name) || ut_memcmp(name, field, len) != 0) {
-
-		btr_pcur_close(&pcur);
-		mtr_commit(&mtr);
-		mem_heap_free(heap);
-		
-		return(NULL);
-	}
-
-	ut_a(0 == ut_strcmp("SPACE",
-		dict_field_get_col(
-		dict_index_get_nth_field(
-			dict_table_get_first_index(sys_tables), 9))->name));
-	
-	field = rec_get_nth_field(rec, 9, &len);
-	space = mach_read_from_4(field);
-
-	ut_a(0 == ut_strcmp("N_COLS",
-		dict_field_get_col(
-		dict_index_get_nth_field(
-			dict_table_get_first_index(sys_tables), 4))->name));
-
-	field = rec_get_nth_field(rec, 4, &len);
-	n_cols = mach_read_from_4(field);
-
-	table = dict_mem_table_create(name, space, n_cols);
-
-	ut_a(0 == ut_strcmp("ID",
-		dict_field_get_col(
-		dict_index_get_nth_field(
-			dict_table_get_first_index(sys_tables), 3))->name));
-
-	field = rec_get_nth_field(rec, 3, &len);
-	table->id = mach_read_from_8(field);
-
-	field = rec_get_nth_field(rec, 5, &len);
-	table->type = mach_read_from_4(field);
-
-	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
-		ut_a(0);
-	
-		field = rec_get_nth_field(rec, 6, &len);
-		table->mix_id = mach_read_from_8(field);
-
-		field = rec_get_nth_field(rec, 8, &len);
-		buf = mem_heap_alloc(heap, len);
-		ut_memcpy(buf, field, len);
-
-		table->cluster_name = buf;
-	}
-
-	if ((table->type == DICT_TABLE_CLUSTER)
-	    || (table->type == DICT_TABLE_CLUSTER_MEMBER)) {
-		
-		field = rec_get_nth_field(rec, 7, &len);
-		table->mix_len = mach_read_from_4(field);
-	}
-
-	btr_pcur_close(&pcur);
-	mtr_commit(&mtr);
-
-	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
-		/* Load the cluster table definition if not yet in
-		memory cache */
-		dict_table_get_low(table->cluster_name);
-	}
-
-	dict_load_columns(table, heap);
-
-	dict_table_add_to_cache(table);
-
-	dict_load_indexes(table, heap);
-	
-	ut_a(DB_SUCCESS == dict_load_foreigns(table->name));
-
-	mem_heap_free(heap);
-
-	return(table);
-}
-
-/***************************************************************************
-Loads a table object based on the table id. */
-
-dict_table_t*
-dict_load_table_on_id(
-/*==================*/
-				/* out: table; NULL if table does not exist */
-	dulint	table_id)	/* in: table id */	
-{
-	byte		id_buf[8];
-	btr_pcur_t	pcur;
-	mem_heap_t* 	heap;
-	dtuple_t*	tuple;
-	dfield_t*	dfield;
-	dict_index_t*	sys_table_ids;
-	dict_table_t*	sys_tables;
-	rec_t*		rec;
-	byte*		field;
-	ulint		len;	
-	dict_table_t*	table;
-	char*		name;
-	mtr_t		mtr;
-	
-	ut_ad(mutex_own(&(dict_sys->mutex)));
-
-	/* NOTE that the operation of this function is protected by
-	the dictionary mutex, and therefore no deadlocks can occur
-	with other dictionary operations. */
-
-	mtr_start(&mtr);	
-	/*---------------------------------------------------*/
-	/* Get the secondary index based on ID for table SYS_TABLES */	
-	sys_tables = dict_sys->sys_tables;
-	sys_table_ids = dict_table_get_next_index(
-				dict_table_get_first_index(sys_tables));
-	heap = mem_heap_create(256);
-
-	tuple  = dtuple_create(heap, 1);
-	dfield = dtuple_get_nth_field(tuple, 0);
-
-	/* Write the table id in byte format to id_buf */
-	mach_write_to_8(id_buf, table_id);
-	
-	dfield_set_data(dfield, id_buf, 8);
-	dict_index_copy_types(tuple, sys_table_ids, 1);
-
-	btr_pcur_open_on_user_rec(sys_table_ids, tuple, PAGE_CUR_GE,
-						BTR_SEARCH_LEAF, &pcur, &mtr);
-	rec = btr_pcur_get_rec(&pcur);
-	
-	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
-					|| rec_get_deleted_flag(rec)) {
-		/* Not found */
-
-		btr_pcur_close(&pcur);
-		mtr_commit(&mtr);
-		mem_heap_free(heap);
-		
-		return(NULL);
-	}
-
-	/*---------------------------------------------------*/
-	/* Now we have the record in the secondary index containing the
-	table ID and NAME */
-
-	rec = btr_pcur_get_rec(&pcur);
-	field = rec_get_nth_field(rec, 0, &len);
-	ut_ad(len == 8);
-
-	/* Check if the table id in record is the one searched for */
-	if (ut_dulint_cmp(table_id, mach_read_from_8(field)) != 0) {
-
-		btr_pcur_close(&pcur);
-		mtr_commit(&mtr);
-		mem_heap_free(heap);
-		
-		return(NULL);
-	}
-		
-	/* Now we get the table name from the record */
-	field = rec_get_nth_field(rec, 1, &len);
-
-	name = mem_heap_alloc(heap, len + 1);
-	ut_memcpy(name, field, len);
-	name[len] = '\0';
-	
-	/* Load the table definition to memory */
-	table = dict_load_table(name);
-
-	ut_a(table);
-	
-	btr_pcur_close(&pcur);
-	mtr_commit(&mtr);
-	mem_heap_free(heap);
-
-	return(table);
-}
-
-/************************************************************************
-This function is called when the database is booted. Loads system table
-index definitions except for the clustered index which is added to the
-dictionary cache at booting before calling this function. */
-
-void
-dict_load_sys_table(
-/*================*/
-	dict_table_t*	table)	/* in: system table */
-{
-	mem_heap_t*	heap;
-
-	ut_ad(mutex_own(&(dict_sys->mutex)));
-
-	heap = mem_heap_create(1000);
-
-	dict_load_indexes(table, heap);
-	
-	mem_heap_free(heap);
-}
-
-/************************************************************************
 Loads definitions for table columns. */
 static
 void
@@ -568,12 +286,97 @@ dict_load_columns(
 }
 
 /************************************************************************
-Loads definitions for table indexes. Adds them to the data dictionary cache.
-*/
+Loads definitions for index fields. */
 static
 void
+dict_load_fields(
+/*=============*/
+	dict_table_t*	table,	/* in: table */
+	dict_index_t*	index,	/* in: index whose fields to load */
+	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
+{
+	dict_table_t*	sys_fields;
+	dict_index_t*	sys_index;
+	btr_pcur_t	pcur;
+	dtuple_t*	tuple;
+	dfield_t*	dfield;
+	char*		col_name;
+	rec_t*		rec;
+	byte*		field;
+	ulint		len;
+	byte*		buf;
+	ulint		i;
+	mtr_t		mtr;
+	
+	ut_ad(mutex_own(&(dict_sys->mutex)));
+
+	UT_NOT_USED(table);
+
+	mtr_start(&mtr);
+
+	sys_fields = dict_table_get_low("SYS_FIELDS");
+	sys_index = UT_LIST_GET_FIRST(sys_fields->indexes);
+
+	tuple = dtuple_create(heap, 1);
+	dfield = dtuple_get_nth_field(tuple, 0);
+
+	buf = mem_heap_alloc(heap, 8);
+	mach_write_to_8(buf, index->id);
+
+	dfield_set_data(dfield, buf, 8);
+	dict_index_copy_types(tuple, sys_index, 1);
+
+	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
+						BTR_SEARCH_LEAF, &pcur, &mtr);
+   	for (i = 0; i < index->n_fields; i++) {
+
+		rec = btr_pcur_get_rec(&pcur);
+
+		ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
+		if (rec_get_deleted_flag(rec)) {
+			fprintf(stderr,
+"InnoDB: Error: data dictionary entry for table %s is corrupt!\n",
+"InnoDB: An index field is delete marked.\n",
+			table->name);
+		}
+		
+		field = rec_get_nth_field(rec, 0, &len);
+		ut_ad(len == 8);
+		ut_a(ut_memcmp(buf, field, len) == 0);
+
+		field = rec_get_nth_field(rec, 1, &len);
+		ut_ad(len == 4);
+		ut_a(i == mach_read_from_4(field));
+
+		ut_a(0 == ut_strcmp("COL_NAME",
+			dict_field_get_col(
+			dict_index_get_nth_field(
+			dict_table_get_first_index(sys_fields), 4))->name));
+
+		field = rec_get_nth_field(rec, 4, &len);
+
+		col_name = mem_heap_alloc(heap, len + 1);
+		ut_memcpy(col_name, field, len);
+		col_name[len] = '\0';
+		
+		dict_mem_index_add_field(index, col_name, 0);
+
+		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
+	} 
+
+	btr_pcur_close(&pcur);
+	mtr_commit(&mtr);
+}
+
+/************************************************************************
+Loads definitions for table indexes. Adds them to the data dictionary
+cache. */
+static
+ibool
 dict_load_indexes(
 /*==============*/
+				/* out: TRUE if ok, FALSE if corruption
+				of dictionary table */
 	dict_table_t*	table,	/* in: table */
 	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
 {
@@ -637,7 +440,17 @@ dict_load_indexes(
 			break;
 		}
 
-		ut_a(!rec_get_deleted_flag(rec));
+		if (rec_get_deleted_flag(rec)) {
+			fprintf(stderr,
+"InnoDB: Error: data dictionary entry for table %s is corrupt!\n"
+"InnoDB: An index is delete marked.\n",
+			table->name);
+
+			btr_pcur_close(&pcur);
+			mtr_commit(&mtr);
+
+			return(FALSE);
+		}
 
 		field = rec_get_nth_field(rec, 1, &len);
 		ut_ad(len == 8);
@@ -671,6 +484,33 @@ dict_load_indexes(
 		field = rec_get_nth_field(rec, 8, &len);
 		page_no = mach_read_from_4(field);
 
+		if (page_no == FIL_NULL) {
+
+			fprintf(stderr,
+	"InnoDB: Error: trying to load index %s for table %s\n"
+	"InnoDB: but the index tree has been freed!\n",
+				name_buf, table->name);
+ 
+			btr_pcur_close(&pcur);
+			mtr_commit(&mtr);
+
+			return(FALSE);
+		}
+
+		if ((type & DICT_CLUSTERED) == 0
+			    && NULL == dict_table_get_first_index(table)) {
+
+			fprintf(stderr,
+	"InnoDB: Error: trying to load index %s for table %s\n"
+	"InnoDB: but the first index was not clustered!\n",
+				name_buf, table->name);
+
+			btr_pcur_close(&pcur);
+			mtr_commit(&mtr);
+
+			return(FALSE);
+		}
+		
 		if (is_sys_table
 		    && ((type & DICT_CLUSTERED)
 		        || ((table == dict_sys->sys_tables)
@@ -688,16 +528,7 @@ dict_load_indexes(
 		
 			dict_load_fields(table, index, heap);
 
-			if (index->type & DICT_CLUSTERED == 0
-			    && NULL == dict_table_get_first_index(table)) {
-
-				fprintf(stderr,
-	"InnoDB: Error: trying to load index %s for table %s\n"
-	"InnoDB: but the first index was not clustered\n",
-				index->name, table->name);
-			} else {
-				dict_index_add_to_cache(table, index);
-			}
+			dict_index_add_to_cache(table, index);
 		}
 
 		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
@@ -705,84 +536,266 @@ dict_load_indexes(
 
 	btr_pcur_close(&pcur);
 	mtr_commit(&mtr);
+
+	return(TRUE);
 }
 
 /************************************************************************
-Loads definitions for index fields. */
-static
-void
-dict_load_fields(
-/*=============*/
-	dict_table_t*	table,	/* in: table */
-	dict_index_t*	index,	/* in: index whose fields to load */
-	mem_heap_t*	heap)	/* in: memory heap for temporary storage */
+Loads a table definition and also all its index definitions, and also
+the cluster definition if the table is a member in a cluster. Also loads
+all foreign key constraints where the foreign key is in the table or where
+a foreign key references columns in this table. Adds all these to the data
+dictionary cache. */
+
+dict_table_t*
+dict_load_table(
+/*============*/
+			/* out: table, NULL if does not exist */
+	char*	name)	/* in: table name */
 {
-	dict_table_t*	sys_fields;
-	dict_index_t*	sys_index;
+	dict_table_t*	table;
+	dict_table_t*	sys_tables;
 	btr_pcur_t	pcur;
+	dict_index_t*	sys_index;
 	dtuple_t*	tuple;
+	mem_heap_t*	heap;
 	dfield_t*	dfield;
-	char*		col_name;
 	rec_t*		rec;
 	byte*		field;
 	ulint		len;
-	byte*		buf;
-	ulint		i;
+	char*		buf;
+	ulint		space;
+	ulint		n_cols;
 	mtr_t		mtr;
 	
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 
-	UT_NOT_USED(table);
-
+	heap = mem_heap_create(1000);
+	
 	mtr_start(&mtr);
 
-	sys_fields = dict_table_get_low("SYS_FIELDS");
-	sys_index = UT_LIST_GET_FIRST(sys_fields->indexes);
+	sys_tables = dict_table_get_low("SYS_TABLES");
+	sys_index = UT_LIST_GET_FIRST(sys_tables->indexes);
 
 	tuple = dtuple_create(heap, 1);
 	dfield = dtuple_get_nth_field(tuple, 0);
 
-	buf = mem_heap_alloc(heap, 8);
-	mach_write_to_8(buf, index->id);
-
-	dfield_set_data(dfield, buf, 8);
+	dfield_set_data(dfield, name, ut_strlen(name));
 	dict_index_copy_types(tuple, sys_index, 1);
 
 	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
-						BTR_SEARCH_LEAF, &pcur, &mtr);
-   	for (i = 0; i < index->n_fields; i++) {
+					BTR_SEARCH_LEAF, &pcur, &mtr);
+	rec = btr_pcur_get_rec(&pcur);
 
-		rec = btr_pcur_get_rec(&pcur);
+	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
+					|| rec_get_deleted_flag(rec)) {
+		/* Not found */
 
-		ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
-		ut_a(!rec_get_deleted_flag(rec));
+		btr_pcur_close(&pcur);
+		mtr_commit(&mtr);
+		mem_heap_free(heap);
 		
-		field = rec_get_nth_field(rec, 0, &len);
-		ut_ad(len == 8);
-		ut_a(ut_memcmp(buf, field, len) == 0);
+		return(NULL);
+	}	
 
-		field = rec_get_nth_field(rec, 1, &len);
-		ut_ad(len == 4);
-		ut_a(i == mach_read_from_4(field));
+	field = rec_get_nth_field(rec, 0, &len);
 
-		ut_a(0 == ut_strcmp("COL_NAME",
-			dict_field_get_col(
-			dict_index_get_nth_field(
-			dict_table_get_first_index(sys_fields), 4))->name));
+	/* Check if the table name in record is the searched one */
+	if (len != ut_strlen(name) || ut_memcmp(name, field, len) != 0) {
 
-		field = rec_get_nth_field(rec, 4, &len);
+		btr_pcur_close(&pcur);
+		mtr_commit(&mtr);
+		mem_heap_free(heap);
+		
+		return(NULL);
+	}
 
-		col_name = mem_heap_alloc(heap, len + 1);
-		ut_memcpy(col_name, field, len);
-		col_name[len] = '\0';
+	ut_a(0 == ut_strcmp("SPACE",
+		dict_field_get_col(
+		dict_index_get_nth_field(
+			dict_table_get_first_index(sys_tables), 9))->name));
+	
+	field = rec_get_nth_field(rec, 9, &len);
+	space = mach_read_from_4(field);
+
+	ut_a(0 == ut_strcmp("N_COLS",
+		dict_field_get_col(
+		dict_index_get_nth_field(
+			dict_table_get_first_index(sys_tables), 4))->name));
+
+	field = rec_get_nth_field(rec, 4, &len);
+	n_cols = mach_read_from_4(field);
+
+	table = dict_mem_table_create(name, space, n_cols);
+
+	ut_a(0 == ut_strcmp("ID",
+		dict_field_get_col(
+		dict_index_get_nth_field(
+			dict_table_get_first_index(sys_tables), 3))->name));
+
+	field = rec_get_nth_field(rec, 3, &len);
+	table->id = mach_read_from_8(field);
+
+	field = rec_get_nth_field(rec, 5, &len);
+	table->type = mach_read_from_4(field);
+
+	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
+		ut_a(0);
+	
+		field = rec_get_nth_field(rec, 6, &len);
+		table->mix_id = mach_read_from_8(field);
+
+		field = rec_get_nth_field(rec, 8, &len);
+		buf = mem_heap_alloc(heap, len);
+		ut_memcpy(buf, field, len);
+
+		table->cluster_name = buf;
+	}
+
+	if ((table->type == DICT_TABLE_CLUSTER)
+	    || (table->type == DICT_TABLE_CLUSTER_MEMBER)) {
 		
-		dict_mem_index_add_field(index, col_name, 0);
+		field = rec_get_nth_field(rec, 7, &len);
+		table->mix_len = mach_read_from_4(field);
+	}
 
-		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
-	} 
+	btr_pcur_close(&pcur);
+	mtr_commit(&mtr);
+
+	if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
+		/* Load the cluster table definition if not yet in
+		memory cache */
+		dict_table_get_low(table->cluster_name);
+	}
+
+	dict_load_columns(table, heap);
+
+	dict_table_add_to_cache(table);
+	
+	dict_load_indexes(table, heap);
+	
+	ut_a(DB_SUCCESS == dict_load_foreigns(table->name));
+
+	mem_heap_free(heap);
+
+	return(table);
+}
+
+/***************************************************************************
+Loads a table object based on the table id. */
+
+dict_table_t*
+dict_load_table_on_id(
+/*==================*/
+				/* out: table; NULL if table does not exist */
+	dulint	table_id)	/* in: table id */	
+{
+	byte		id_buf[8];
+	btr_pcur_t	pcur;
+	mem_heap_t* 	heap;
+	dtuple_t*	tuple;
+	dfield_t*	dfield;
+	dict_index_t*	sys_table_ids;
+	dict_table_t*	sys_tables;
+	rec_t*		rec;
+	byte*		field;
+	ulint		len;	
+	dict_table_t*	table;
+	char*		name;
+	mtr_t		mtr;
+	
+	ut_ad(mutex_own(&(dict_sys->mutex)));
+
+	/* NOTE that the operation of this function is protected by
+	the dictionary mutex, and therefore no deadlocks can occur
+	with other dictionary operations. */
+
+	mtr_start(&mtr);	
+	/*---------------------------------------------------*/
+	/* Get the secondary index based on ID for table SYS_TABLES */	
+	sys_tables = dict_sys->sys_tables;
+	sys_table_ids = dict_table_get_next_index(
+				dict_table_get_first_index(sys_tables));
+	heap = mem_heap_create(256);
 
+	tuple  = dtuple_create(heap, 1);
+	dfield = dtuple_get_nth_field(tuple, 0);
+
+	/* Write the table id in byte format to id_buf */
+	mach_write_to_8(id_buf, table_id);
+	
+	dfield_set_data(dfield, id_buf, 8);
+	dict_index_copy_types(tuple, sys_table_ids, 1);
+
+	btr_pcur_open_on_user_rec(sys_table_ids, tuple, PAGE_CUR_GE,
+						BTR_SEARCH_LEAF, &pcur, &mtr);
+	rec = btr_pcur_get_rec(&pcur);
+	
+	if (!btr_pcur_is_on_user_rec(&pcur, &mtr)
+					|| rec_get_deleted_flag(rec)) {
+		/* Not found */
+
+		btr_pcur_close(&pcur);
+		mtr_commit(&mtr);
+		mem_heap_free(heap);
+		
+		return(NULL);
+	}
+
+	/*---------------------------------------------------*/
+	/* Now we have the record in the secondary index containing the
+	table ID and NAME */
+
+	rec = btr_pcur_get_rec(&pcur);
+	field = rec_get_nth_field(rec, 0, &len);
+	ut_ad(len == 8);
+
+	/* Check if the table id in record is the one searched for */
+	if (ut_dulint_cmp(table_id, mach_read_from_8(field)) != 0) {
+
+		btr_pcur_close(&pcur);
+		mtr_commit(&mtr);
+		mem_heap_free(heap);
+		
+		return(NULL);
+	}
+		
+	/* Now we get the table name from the record */
+	field = rec_get_nth_field(rec, 1, &len);
+
+	name = mem_heap_alloc(heap, len + 1);
+	ut_memcpy(name, field, len);
+	name[len] = '\0';
+	
+	/* Load the table definition to memory */
+	table = dict_load_table(name);
+	
 	btr_pcur_close(&pcur);
 	mtr_commit(&mtr);
+	mem_heap_free(heap);
+
+	return(table);
+}
+
+/************************************************************************
+This function is called when the database is booted. Loads system table
+index definitions except for the clustered index which is added to the
+dictionary cache at booting before calling this function. */
+
+void
+dict_load_sys_table(
+/*================*/
+	dict_table_t*	table)	/* in: system table */
+{
+	mem_heap_t*	heap;
+
+	ut_ad(mutex_own(&(dict_sys->mutex)));
+
+	heap = mem_heap_create(1000);
+
+	dict_load_indexes(table, heap);
+	
+	mem_heap_free(heap);
 }
 
 /************************************************************************