Merge tsmith@bk-internal.mysql.com:/home/bk/mysql-5.1-maint

into  siva.hindu.god:/usr/home/tim/m/bk/inno/51-t


mysql-test/mysql-test-run.pl:
  Auto merged

sql/sql_yacc.yy

@@ -1354,7 +1354,7 @@ event_tail:
             Lex->sql_command= SQLCOM_CREATE_EVENT;
             Lex->expr_allows_subselect= TRUE;
           }
-
+      ;
 
 ev_schedule_time: EVERY_SYM expr interval
 	  {

storage/innobase/btr/btr0pcur.c

@@ -76,20 +76,20 @@ btr_pcur_store_position(
 {
 	page_cur_t*	page_cursor;
 	rec_t*		rec;
-	dict_tree_t*	tree;
+	dict_index_t*	index;
 	page_t*		page;
 	ulint		offs;
 
 	ut_a(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 	ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
-	tree = btr_cur_get_tree(btr_pcur_get_btr_cur(cursor));
+	index = btr_cur_get_index(btr_pcur_get_btr_cur(cursor));
 
 	page_cursor = btr_pcur_get_page_cur(cursor);
 
 	rec = page_cur_get_rec(page_cursor);
-	page = ut_align_down(rec, UNIV_PAGE_SIZE);
-	offs = ut_align_offset(rec, UNIV_PAGE_SIZE);
+	page = page_align(rec);
+	offs = page_offset(rec);
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
 				MTR_MEMO_PAGE_S_FIX)
@@ -133,13 +133,13 @@ btr_pcur_store_position(
 	}
 
 	cursor->old_stored = BTR_PCUR_OLD_STORED;
-	cursor->old_rec = dict_tree_copy_rec_order_prefix
-		(tree, rec, &cursor->old_n_fields,
+	cursor->old_rec = dict_index_copy_rec_order_prefix(
+		index, rec, &cursor->old_n_fields,
 		&cursor->old_rec_buf, &cursor->buf_size);
 
 	cursor->block_when_stored = buf_block_align(page);
-	cursor->modify_clock = buf_block_get_modify_clock
-		(cursor->block_when_stored);
+	cursor->modify_clock = buf_block_get_modify_clock(
+		cursor->block_when_stored);
 }
 
 /******************************************************************
@@ -197,13 +197,15 @@ btr_pcur_restore_position(
 	btr_pcur_t*	cursor,		/* in: detached persistent cursor */
 	mtr_t*		mtr)		/* in: mtr */
 {
-	dict_tree_t*	tree;
+	dict_index_t*	index;
 	page_t*		page;
 	dtuple_t*	tuple;
 	ulint		mode;
 	ulint		old_mode;
 	mem_heap_t*	heap;
 
+	index = btr_cur_get_index(btr_pcur_get_btr_cur(cursor));
+
 	if (UNIV_UNLIKELY(cursor->old_stored != BTR_PCUR_OLD_STORED)
 	    || UNIV_UNLIKELY(cursor->pos_state != BTR_PCUR_WAS_POSITIONED
 			     && cursor->pos_state != BTR_PCUR_IS_POSITIONED)) {
@@ -215,17 +217,16 @@ btr_pcur_restore_position(
 		ut_error;
 	}
 
-	if (UNIV_UNLIKELY
-	    (cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
+	if (UNIV_UNLIKELY(
+		    cursor->rel_pos == BTR_PCUR_AFTER_LAST_IN_TREE
 		    || cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE)) {
 
 		/* In these cases we do not try an optimistic restoration,
 		but always do a search */
 
-		btr_cur_open_at_index_side
-			(cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
-			 btr_pcur_get_btr_cur(cursor)->index, latch_mode,
-			 btr_pcur_get_btr_cur(cursor), mtr);
+		btr_cur_open_at_index_side(
+			cursor->rel_pos == BTR_PCUR_BEFORE_FIRST_IN_TREE,
+			index, latch_mode, btr_pcur_get_btr_cur(cursor), mtr);
 
 		cursor->block_when_stored
 			= buf_block_align(btr_pcur_get_page(cursor));
@@ -242,8 +243,8 @@ btr_pcur_restore_position(
 	    || UNIV_LIKELY(latch_mode == BTR_MODIFY_LEAF)) {
 		/* Try optimistic restoration */
 
-		if (UNIV_LIKELY
-		    (buf_page_optimistic_get(latch_mode,
+		if (UNIV_LIKELY(buf_page_optimistic_get(
+					latch_mode,
 					cursor->block_when_stored, page,
 					cursor->modify_clock, mtr))) {
 			cursor->pos_state = BTR_PCUR_IS_POSITIONED;
@@ -255,19 +256,17 @@ btr_pcur_restore_position(
 				rec_t*		rec;
 				ulint*		offsets1;
 				ulint*		offsets2;
-				dict_index_t*	index;
 #endif /* UNIV_DEBUG */
 				cursor->latch_mode = latch_mode;
 #ifdef UNIV_DEBUG
 				rec = btr_pcur_get_rec(cursor);
-				index = btr_pcur_get_btr_cur(cursor)->index;
 
 				heap = mem_heap_create(256);
-				offsets1 = rec_get_offsets
-					(cursor->old_rec, index, NULL,
+				offsets1 = rec_get_offsets(
+					cursor->old_rec, index, NULL,
 					cursor->old_n_fields, &heap);
-				offsets2 = rec_get_offsets
-					(rec, index, NULL,
+				offsets2 = rec_get_offsets(
+					rec, index, NULL,
 					cursor->old_n_fields, &heap);
 
 				ut_ad(!cmp_rec_rec(cursor->old_rec,
@@ -286,8 +285,7 @@ btr_pcur_restore_position(
 
 	heap = mem_heap_create(256);
 
-	tree = btr_cur_get_tree(btr_pcur_get_btr_cur(cursor));
-	tuple = dict_tree_build_data_tuple(tree, cursor->old_rec,
+	tuple = dict_index_build_data_tuple(index, cursor->old_rec,
 					    cursor->old_n_fields, heap);
 
 	/* Save the old search mode of the cursor */
@@ -302,8 +300,8 @@ btr_pcur_restore_position(
 		mode = PAGE_CUR_L;
 	}
 
-	btr_pcur_open_with_no_init(btr_pcur_get_btr_cur(cursor)->index, tuple,
-				   mode, latch_mode, cursor, 0, mtr);
+	btr_pcur_open_with_no_init(index, tuple, mode, latch_mode,
+				   cursor, 0, mtr);
 
 	/* Restore the old search mode */
 	cursor->search_mode = old_mode;
@@ -311,19 +309,18 @@ btr_pcur_restore_position(
 	if (cursor->rel_pos == BTR_PCUR_ON
 	    && btr_pcur_is_on_user_rec(cursor, mtr)
 	    && 0 == cmp_dtuple_rec(tuple, btr_pcur_get_rec(cursor),
-				   rec_get_offsets
-				   (btr_pcur_get_rec(cursor),
-				    btr_pcur_get_btr_cur(cursor)->index,
+				   rec_get_offsets(
+					   btr_pcur_get_rec(cursor), index,
 					   NULL, ULINT_UNDEFINED, &heap))) {
 
 		/* We have to store the NEW value for the modify clock, since
 		the cursor can now be on a different page! But we can retain
 		the value of old_rec */
 
-		cursor->block_when_stored = buf_block_align
-			(btr_pcur_get_page(cursor));
-		cursor->modify_clock = buf_block_get_modify_clock
-			(cursor->block_when_stored);
+		cursor->block_when_stored = buf_block_align(
+			btr_pcur_get_page(cursor));
+		cursor->modify_clock = buf_block_get_modify_clock(
+			cursor->block_when_stored);
 		cursor->old_stored = BTR_PCUR_OLD_STORED;
 
 		mem_heap_free(heap);

storage/innobase/buf/buf0buf.c

@@ -350,8 +350,8 @@ buf_page_is_corrupted(
 	if (srv_use_checksums) {
 		old_checksum = buf_calc_page_old_checksum(read_buf);
 
-		old_checksum_field = mach_read_from_4
-			(read_buf + UNIV_PAGE_SIZE
+		old_checksum_field = mach_read_from_4(
+			read_buf + UNIV_PAGE_SIZE
 			- FIL_PAGE_END_LSN_OLD_CHKSUM);
 
 		/* There are 2 valid formulas for old_checksum_field:
@@ -459,8 +459,8 @@ buf_page_print(
 
 		if (dict_sys != NULL) {
 
-			index = dict_index_find_on_id_low
-				(btr_page_get_index_id(read_buf));
+			index = dict_index_find_on_id_low(
+				btr_page_get_index_id(read_buf));
 			if (index) {
 				fputs("InnoDB: (", stderr);
 				dict_index_name_print(stderr, NULL, index);
@@ -598,8 +598,8 @@ buf_pool_init(
 		/* Allocate the virtual address space window, i.e., the
 		buffer pool frames */
 
-		buf_pool->frame_mem = os_awe_allocate_virtual_mem_window
-			(UNIV_PAGE_SIZE * (n_frames + 1));
+		buf_pool->frame_mem = os_awe_allocate_virtual_mem_window(
+			UNIV_PAGE_SIZE * (n_frames + 1));
 
 		/* Allocate the physical memory for AWE and the AWE info array
 		for buf_pool */
@@ -625,8 +625,8 @@ buf_pool_init(
 		}
 		/*----------------------------------------*/
 	} else {
-		buf_pool->frame_mem = os_mem_alloc_large
-			(UNIV_PAGE_SIZE * (n_frames + 1), TRUE, FALSE);
+		buf_pool->frame_mem = os_mem_alloc_large(
+			UNIV_PAGE_SIZE * (n_frames + 1), TRUE, FALSE);
 	}
 
 	if (buf_pool->frame_mem == NULL) {
@@ -821,8 +821,8 @@ buf_awe_map_page_to_frame(
 		} else {
 			/* We can map block to the frame of bck */
 
-			os_awe_map_physical_mem_to_window
-				(bck->frame,
+			os_awe_map_physical_mem_to_window(
+				bck->frame,
 				UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE,
 				block->awe_info);
 
@@ -840,8 +840,8 @@ buf_awe_map_page_to_frame(
 				       bck);
 
 			if (add_to_mapped_list) {
-				UT_LIST_ADD_FIRST
-					(awe_LRU_free_mapped,
+				UT_LIST_ADD_FIRST(
+					awe_LRU_free_mapped,
 					buf_pool->awe_LRU_free_mapped,
 					block);
 			}
@@ -1583,7 +1583,7 @@ buf_page_init_for_backup_restore(
 	block->is_hashed	= FALSE;
 	block->n_fields		= 1;
 	block->n_bytes		= 0;
-	block->side		= BTR_SEARCH_LEFT_SIDE;
+	block->left_side	= TRUE;
 
 	block->file_page_was_freed = FALSE;
 }
@@ -1650,7 +1650,7 @@ buf_page_init(
 	block->is_hashed	= FALSE;
 	block->n_fields		= 1;
 	block->n_bytes		= 0;
-	block->side		= BTR_SEARCH_LEFT_SIDE;
+	block->left_side	= TRUE;
 
 	block->file_page_was_freed = FALSE;
 }
@@ -1710,8 +1710,8 @@ buf_page_init_for_read(
 
 	mutex_enter(&(buf_pool->mutex));
 
-	if (fil_tablespace_deleted_or_being_deleted_in_mem
-	    (space, tablespace_version)) {
+	if (fil_tablespace_deleted_or_being_deleted_in_mem(
+		    space, tablespace_version)) {
 		*err = DB_TABLESPACE_DELETED;
 	}
 
@@ -1891,10 +1891,10 @@ buf_page_io_complete(
 		/* If this page is not uninitialized and not in the
 		doublewrite buffer, then the page number and space id
 		should be the same as in block. */
-		ulint	read_page_no = mach_read_from_4
-			(block->frame + FIL_PAGE_OFFSET);
-		ulint	read_space_id = mach_read_from_4
-			(block->frame + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
+		ulint	read_page_no = mach_read_from_4(
+			block->frame + FIL_PAGE_OFFSET);
+		ulint	read_space_id = mach_read_from_4(
+			block->frame + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 
 		if (!block->space
 		    && trx_doublewrite_page_inside(block->offset)) {
@@ -1980,9 +1980,9 @@ buf_page_io_complete(
 		}
 
 		if (!recv_no_ibuf_operations) {
-			ibuf_merge_or_delete_for_page
-				(block->frame, block->space,
-				 block->offset, TRUE);
+			ibuf_merge_or_delete_for_page(
+				block->frame, block->space, block->offset,
+				TRUE);
 		}
 	}
 
@@ -2110,8 +2110,9 @@ buf_validate(void)
 
 				if (block->flush_type == BUF_FLUSH_LRU) {
 					n_lru_flush++;
-					ut_a(rw_lock_is_locked
-					     (&block->lock, RW_LOCK_SHARED));
+					ut_a(rw_lock_is_locked(
+						     &block->lock,
+						     RW_LOCK_SHARED));
 				} else if (block->flush_type
 					   == BUF_FLUSH_LIST) {
 					n_list_flush++;

storage/innobase/buf/buf0flu.c

@@ -890,8 +890,8 @@ buf_flush_batch(
 				old_page_count = page_count;
 
 				/* Try to flush also all the neighbors */
-				page_count += buf_flush_try_neighbors
-					(space, offset, flush_type);
+				page_count += buf_flush_try_neighbors(
+					space, offset, flush_type);
 				/* fprintf(stderr,
 				"Flush type %lu, page no %lu, neighb %lu\n",
 				flush_type, offset,

storage/innobase/buf/buf0lru.c

@@ -542,16 +542,16 @@ buf_LRU_old_adjust_len(void)
 
 		if (old_len < new_len - BUF_LRU_OLD_TOLERANCE) {
 
-			buf_pool->LRU_old = UT_LIST_GET_PREV
-				(LRU, buf_pool->LRU_old);
+			buf_pool->LRU_old = UT_LIST_GET_PREV(
+				LRU, buf_pool->LRU_old);
 			(buf_pool->LRU_old)->old = TRUE;
 			buf_pool->LRU_old_len++;
 
 		} else if (old_len > new_len + BUF_LRU_OLD_TOLERANCE) {
 
 			(buf_pool->LRU_old)->old = FALSE;
-			buf_pool->LRU_old = UT_LIST_GET_NEXT
-				(LRU, buf_pool->LRU_old);
+			buf_pool->LRU_old = UT_LIST_GET_NEXT(
+				LRU, buf_pool->LRU_old);
 			buf_pool->LRU_old_len--;
 		} else {
 			ut_a(buf_pool->LRU_old); /* Check that we did not

storage/innobase/buf/buf0rea.c

@@ -257,8 +257,8 @@ buf_read_ahead_random(
 		mode: hence FALSE as the first parameter */
 
 		if (!ibuf_bitmap_page(i)) {
-			count += buf_read_page_low
-				(&err, FALSE,
+			count += buf_read_page_low(
+				&err, FALSE,
 				ibuf_mode | OS_AIO_SIMULATED_WAKE_LATER,
 				space, tablespace_version, i);
 			if (err == DB_TABLESPACE_DELETED) {
@@ -549,8 +549,8 @@ buf_read_ahead_linear(
 		aio mode: hence FALSE as the first parameter */
 
 		if (!ibuf_bitmap_page(i)) {
-			count += buf_read_page_low
-				(&err, FALSE,
+			count += buf_read_page_low(
+				&err, FALSE,
 				ibuf_mode | OS_AIO_SIMULATED_WAKE_LATER,
 				space, tablespace_version, i);
 			if (err == DB_TABLESPACE_DELETED) {

storage/innobase/data/data0data.c

@@ -540,8 +540,8 @@ dtuple_convert_big_rec(
 	n_fields = 0;
 
 	while (rec_get_converted_size(index, entry)
-	       >= ut_min(page_get_free_space_of_empty
-			 (dict_table_is_comp(index->table)) / 2,
+	       >= ut_min(page_get_free_space_of_empty(
+				 dict_table_is_comp(index->table)) / 2,
 			 REC_MAX_DATA_SIZE)) {
 
 		longest = 0;
@@ -610,8 +610,8 @@ dtuple_convert_big_rec(
 		vector->fields[n_fields].len = dfield->len
 			- DICT_MAX_INDEX_COL_LEN;
 
-		vector->fields[n_fields].data = mem_heap_alloc
-			(heap, vector->fields[n_fields].len);
+		vector->fields[n_fields].data = mem_heap_alloc(
+			heap, vector->fields[n_fields].len);
 
 		/* Copy data (from the end of field) to big rec vector */
 

storage/innobase/data/data0type.c

@@ -40,9 +40,6 @@ charset-collation code for them. */
 
 ulint	data_mysql_default_charset_coll		= 99999999;
 
-dtype_t		dtype_binary_val = {DATA_BINARY, 0, 0, 0, 0, 0};
-dtype_t*	dtype_binary	= &dtype_binary_val;
-
 /*************************************************************************
 Determine how many bytes the first n characters of the given string occupy.
 If the string is shorter than n characters, returns the number of bytes
@@ -53,7 +50,11 @@ dtype_get_at_most_n_mbchars(
 /*========================*/
 					/* out: length of the prefix,
 					in bytes */
-	const dtype_t*	dtype,		/* in: data type */
+	ulint		prtype,		/* in: precise type */
+	ulint		mbminlen,	/* in: minimum length of a
+					multi-byte character */
+	ulint		mbmaxlen,	/* in: maximum length of a
+					multi-byte character */
 	ulint		prefix_len,	/* in: length of the requested
 					prefix, in characters, multiplied by
 					dtype_get_mbmaxlen(dtype) */
@@ -63,12 +64,12 @@ dtype_get_at_most_n_mbchars(
 {
 #ifndef UNIV_HOTBACKUP
 	ut_a(data_len != UNIV_SQL_NULL);
-	ut_ad(!dtype->mbmaxlen || !(prefix_len % dtype->mbmaxlen));
+	ut_ad(!mbmaxlen || !(prefix_len % mbmaxlen));
 
-	if (dtype->mbminlen != dtype->mbmaxlen) {
-		ut_a(!(prefix_len % dtype->mbmaxlen));
-		return(innobase_get_at_most_n_mbchars
-		       (dtype_get_charset_coll(dtype->prtype),
+	if (mbminlen != mbmaxlen) {
+		ut_a(!(prefix_len % mbmaxlen));
+		return(innobase_get_at_most_n_mbchars(
+			dtype_get_charset_coll(prtype),
 			prefix_len, data_len, str));
 	}
 
@@ -270,8 +271,6 @@ dtype_print(
 		} else if (prtype == DATA_TRX_ID) {
 			fputs("DATA_TRX_ID", stderr);
 			len = DATA_TRX_ID_LEN;
-		} else if (prtype == DATA_MIX_ID) {
-			fputs("DATA_MIX_ID", stderr);
 		} else if (prtype == DATA_ENGLISH) {
 			fputs("DATA_ENGLISH", stderr);
 		} else {
@@ -291,38 +290,5 @@ dtype_print(
 		}
 	}
 
-	fprintf(stderr, " len %lu prec %lu", (ulong) len, (ulong) type->prec);
-}
-
-/***************************************************************************
-Returns the maximum size of a data type. Note: types in system tables may be
-incomplete and return incorrect information. */
-
-ulint
-dtype_get_max_size(
-/*===============*/
-				/* out: maximum size (ULINT_MAX for
-				unbounded types) */
-	const dtype_t*	type)	/* in: type */
-{
-	switch (type->mtype) {
-	case DATA_SYS:
-	case DATA_CHAR:
-	case DATA_FIXBINARY:
-	case DATA_INT:
-	case DATA_FLOAT:
-	case DATA_DOUBLE:
-	case DATA_MYSQL:
-	case DATA_VARCHAR:
-	case DATA_BINARY:
-	case DATA_DECIMAL:
-	case DATA_VARMYSQL:
-		return(type->len);
-	case DATA_BLOB:
-		return(ULINT_MAX);
-	default:
-		ut_error;
-	}
-
-	return(ULINT_MAX);
+	fprintf(stderr, " len %lu", (ulong) len);
 }

storage/innobase/dict/dict0boot.c

@@ -58,8 +58,7 @@ dict_hdr_get_new_id(
 	dulint		id;
 	mtr_t		mtr;
 
-	ut_ad((type == DICT_HDR_TABLE_ID) || (type == DICT_HDR_INDEX_ID)
-	      || (type == DICT_HDR_MIX_ID));
+	ut_ad((type == DICT_HDR_TABLE_ID) || (type == DICT_HDR_INDEX_ID));
 
 	mtr_start(&mtr);
 
@@ -141,6 +140,7 @@ dict_hdr_create(
 	mlog_write_dulint(dict_header + DICT_HDR_INDEX_ID,
 			  ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
+	/* Obsolete, but we must initialize it to 0 anyway. */
 	mlog_write_dulint(dict_header + DICT_HDR_MIX_ID,
 			  ut_dulint_create(0, DICT_HDR_FIRST_ID), mtr);
 
@@ -214,7 +214,6 @@ dict_boot(void)
 	dict_index_t*	index;
 	dict_hdr_t*	dict_hdr;
 	mtr_t		mtr;
-	ibool		success;
 
 	mtr_start(&mtr);
 
@@ -236,9 +235,9 @@ dict_boot(void)
 	..._MARGIN, it will immediately be updated to the disk-based
 	header. */
 
-	dict_sys->row_id = ut_dulint_add
-		(ut_dulint_align_up(mtr_read_dulint
-				    (dict_hdr + DICT_HDR_ROW_ID, &mtr),
+	dict_sys->row_id = ut_dulint_add(
+		ut_dulint_align_up(mtr_read_dulint(dict_hdr + DICT_HDR_ROW_ID,
+						   &mtr),
 				   DICT_HDR_ROW_ID_WRITE_MARGIN),
 		DICT_HDR_ROW_ID_WRITE_MARGIN);
 
@@ -247,14 +246,14 @@ dict_boot(void)
 	/*-------------------------*/
 	table = dict_mem_table_create("SYS_TABLES", DICT_HDR_SPACE, 8, 0);
 
-	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "ID", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "N_COLS", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "TYPE", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "MIX_ID", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "MIX_LEN", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "CLUSTER_NAME", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "SPACE", DATA_INT, 0, 4, 0);
+	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "N_COLS", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "TYPE", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "MIX_ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "MIX_LEN", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "CLUSTER_NAME", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "SPACE", DATA_INT, 0, 4);
 
 	table->id = DICT_TABLES_ID;
 
@@ -269,31 +268,30 @@ dict_boot(void)
 
 	index->id = DICT_TABLES_ID;
 
-	success = dict_index_add_to_cache(table, index, mtr_read_ulint
-					  (dict_hdr + DICT_HDR_TABLES,
+	dict_index_add_to_cache(table, index,
+				mtr_read_ulint(dict_hdr + DICT_HDR_TABLES,
 					       MLOG_4BYTES, &mtr));
-	ut_a(success);
+
 	/*-------------------------*/
 	index = dict_mem_index_create("SYS_TABLES", "ID_IND",
 				      DICT_HDR_SPACE, DICT_UNIQUE, 1);
 	dict_mem_index_add_field(index, "ID", 0);
 
 	index->id = DICT_TABLE_IDS_ID;
-	success = dict_index_add_to_cache(table, index,
-					  mtr_read_ulint
-					  (dict_hdr + DICT_HDR_TABLE_IDS,
+	dict_index_add_to_cache(table, index,
+				mtr_read_ulint(dict_hdr + DICT_HDR_TABLE_IDS,
 					       MLOG_4BYTES, &mtr));
-	ut_a(success);
+
 	/*-------------------------*/
 	table = dict_mem_table_create("SYS_COLUMNS", DICT_HDR_SPACE, 7, 0);
 
-	dict_mem_table_add_col(table, "TABLE_ID", DATA_BINARY,0,0,0);
-	dict_mem_table_add_col(table, "POS", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "MTYPE", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "PRTYPE", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "LEN", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "PREC", DATA_INT, 0, 4, 0);
+	dict_mem_table_add_col(table, "TABLE_ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "POS", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "MTYPE", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "PRTYPE", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "LEN", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "PREC", DATA_INT, 0, 4);
 
 	table->id = DICT_COLUMNS_ID;
 
@@ -308,20 +306,20 @@ dict_boot(void)
 	dict_mem_index_add_field(index, "POS", 0);
 
 	index->id = DICT_COLUMNS_ID;
-	success = dict_index_add_to_cache(table, index, mtr_read_ulint
-					  (dict_hdr + DICT_HDR_COLUMNS,
+	dict_index_add_to_cache(table, index,
+				mtr_read_ulint(dict_hdr + DICT_HDR_COLUMNS,
 					       MLOG_4BYTES, &mtr));
-	ut_a(success);
+
 	/*-------------------------*/
 	table = dict_mem_table_create("SYS_INDEXES", DICT_HDR_SPACE, 7, 0);
 
-	dict_mem_table_add_col(table, "TABLE_ID", DATA_BINARY, 0,0,0);
-	dict_mem_table_add_col(table, "ID", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0, 0);
-	dict_mem_table_add_col(table, "N_FIELDS", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "TYPE", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "SPACE", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "PAGE_NO", DATA_INT, 0, 4, 0);
+	dict_mem_table_add_col(table, "TABLE_ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "NAME", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "N_FIELDS", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "TYPE", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "SPACE", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "PAGE_NO", DATA_INT, 0, 4);
 
 	/* The '+ 2' below comes from the 2 system fields */
 #if DICT_SYS_INDEXES_PAGE_NO_FIELD != 6 + 2
@@ -346,16 +344,16 @@ dict_boot(void)
 	dict_mem_index_add_field(index, "ID", 0);
 
 	index->id = DICT_INDEXES_ID;
-	success = dict_index_add_to_cache(table, index, mtr_read_ulint
-					  (dict_hdr + DICT_HDR_INDEXES,
+	dict_index_add_to_cache(table, index,
+				mtr_read_ulint(dict_hdr + DICT_HDR_INDEXES,
 					       MLOG_4BYTES, &mtr));
-	ut_a(success);
+
 	/*-------------------------*/
 	table = dict_mem_table_create("SYS_FIELDS", DICT_HDR_SPACE, 3, 0);
 
-	dict_mem_table_add_col(table, "INDEX_ID", DATA_BINARY, 0,0,0);
-	dict_mem_table_add_col(table, "POS", DATA_INT, 0, 4, 0);
-	dict_mem_table_add_col(table, "COL_NAME", DATA_BINARY, 0,0,0);
+	dict_mem_table_add_col(table, "INDEX_ID", DATA_BINARY, 0, 0);
+	dict_mem_table_add_col(table, "POS", DATA_INT, 0, 4);
+	dict_mem_table_add_col(table, "COL_NAME", DATA_BINARY, 0, 0);
 
 	table->id = DICT_FIELDS_ID;
 	dict_table_add_to_cache(table);
@@ -369,10 +367,9 @@ dict_boot(void)
 	dict_mem_index_add_field(index, "POS", 0);
 
 	index->id = DICT_FIELDS_ID;
-	success = dict_index_add_to_cache(table, index, mtr_read_ulint
-					  (dict_hdr + DICT_HDR_FIELDS,
+	dict_index_add_to_cache(table, index,
+				mtr_read_ulint(dict_hdr + DICT_HDR_FIELDS,
 					       MLOG_4BYTES, &mtr));
-	ut_a(success);
 
 	mtr_commit(&mtr);
 	/*-------------------------*/

storage/innobase/dict/dict0crea.c

@@ -78,14 +78,14 @@ dict_create_sys_tables_tuple(
 	mach_write_to_4(ptr, DICT_TABLE_ORDINARY);
 
 	dfield_set_data(dfield, ptr, 4);
-	/* 6: MIX_ID ---------------------------*/
+	/* 6: MIX_ID (obsolete) ---------------------------*/
 	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 --------------------------*/
+	/* 7: MIX_LEN (obsolete) --------------------------*/
 
 	dfield = dtuple_get_nth_field(entry, 5);
 
@@ -126,9 +126,10 @@ dict_create_sys_columns_tuple(
 {
 	dict_table_t*		sys_columns;
 	dtuple_t*		entry;
-	dict_col_t*	column;
+	const dict_col_t*	column;
 	dfield_t*		dfield;
 	byte*			ptr;
+	const char*	col_name;
 
 	ut_ad(table && heap);
 
@@ -155,33 +156,34 @@ dict_create_sys_columns_tuple(
 	/* 4: NAME ---------------------------*/
 	dfield = dtuple_get_nth_field(entry, 2);
 
-	dfield_set_data(dfield, column->name, ut_strlen(column->name));
+	col_name = dict_table_get_col_name(table, i);
+	dfield_set_data(dfield, col_name, ut_strlen(col_name));
 	/* 5: MTYPE --------------------------*/
 	dfield = dtuple_get_nth_field(entry, 3);
 
 	ptr = mem_heap_alloc(heap, 4);
-	mach_write_to_4(ptr, (column->type).mtype);
+	mach_write_to_4(ptr, column->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);
+	mach_write_to_4(ptr, column->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);
+	mach_write_to_4(ptr, column->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);
+	mach_write_to_4(ptr, 0/* unused */);
 
 	dfield_set_data(dfield, ptr, 4);
 	/*---------------------------------*/
@@ -222,8 +224,7 @@ dict_build_table_def_step(
 
 	row_len = 0;
 	for (i = 0; i < table->n_def; i++) {
-		row_len += dtype_get_min_size(dict_col_get_type
-					      (&table->cols[i]));
+		row_len += dict_col_get_min_size(&table->cols[i]);
 	}
 	if (row_len > BTR_PAGE_MAX_REC_SIZE) {
 		return(DB_TOO_BIG_RECORD);
@@ -238,7 +239,7 @@ dict_build_table_def_step(
 		- 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 */
+		ulint	space = 0;	/* reset to zero for the call below */
 
 		if (table->dir_path_of_temp_table) {
 			/* We place tables created with CREATE TEMPORARY
@@ -251,9 +252,11 @@ dict_build_table_def_step(
 			is_path = FALSE;
 		}
 
-		error = fil_create_new_single_table_tablespace
-			(&table->space, path_or_name, is_path,
+		error = fil_create_new_single_table_tablespace(
+			&space, path_or_name, is_path,
 			FIL_IBD_FILE_INITIAL_SIZE);
+		table->space = space;
+
 		if (error != DB_SUCCESS) {
 
 			return(error);
@@ -768,8 +771,8 @@ dict_truncate_index_tree(
 	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));
+	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
@@ -798,7 +801,7 @@ dict_truncate_index_tree(
 
 	root_page_no = btr_create(type, space, index_id, comp, mtr);
 	if (index) {
-		index->tree->page = root_page_no;
+		index->page = root_page_no;
 	} else {
 		ut_print_timestamp(stderr);
 		fprintf(stderr,
@@ -1004,7 +1007,6 @@ dict_create_index_step(
 	que_thr_t*	thr)	/* in: query thread */
 {
 	ind_node_t*	node;
-	ibool		success;
 	ulint		err	= DB_ERROR;
 	trx_t*		trx;
 
@@ -1088,11 +1090,9 @@ dict_create_index_step(
 
 	if (node->state == INDEX_ADD_TO_CACHE) {
 
-		success = dict_index_add_to_cache(node->table, node->index,
+		dict_index_add_to_cache(node->table, node->index,
 					node->page_no);
 
-		ut_a(success);
-
 		err = DB_SUCCESS;
 	}
 
@@ -1328,8 +1328,9 @@ dict_create_add_foreign_field_to_dictionary(
 	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"
+	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"
@@ -1393,8 +1394,8 @@ dict_create_add_foreign_to_dictionary(
 	}
 
 	for (i = 0; i < foreign->n_fields; i++) {
-		error = dict_create_add_foreign_field_to_dictionary
-			(i, table, foreign, trx);
+		error = dict_create_add_foreign_field_to_dictionary(
+			i, table, foreign, trx);
 
 		if (error != DB_SUCCESS) {
 
@@ -1450,8 +1451,8 @@ dict_create_add_foreigns_to_dictionary(
 	     foreign;
 	     foreign = UT_LIST_GET_NEXT(foreign_list, foreign)) {
 
-		error = dict_create_add_foreign_to_dictionary
-			(&number, table, foreign, trx);
+		error = dict_create_add_foreign_to_dictionary(&number, table,
+							      foreign, trx);
 
 		if (error != DB_SUCCESS) {
 

storage/innobase/dict/dict0load.c

@@ -26,6 +26,25 @@ Created 4/24/1996 Heikki Tuuri
 #include "srv0start.h"
 #include "srv0srv.h"
 
+/********************************************************************
+Returns TRUE if index's i'th column's name is 'name' .*/
+static
+ibool
+name_of_col_is(
+/*===========*/
+				/* out: */
+	dict_table_t*	table,	/* in: table */
+	dict_index_t*	index,	/* in: index */
+	ulint		i,	/* in:  */
+	const char*	name)	/* in: name to compare to */
+{
+	ulint	tmp = dict_col_get_no(dict_field_get_col(
+					      dict_index_get_nth_field(
+						      index, i)));
+
+	return(strcmp(name, dict_table_get_col_name(table, tmp)) == 0);
+}
+
 /************************************************************************
 Finds the first table name in the given database. */
 
@@ -331,7 +350,6 @@ dict_load_columns(
 	ulint		mtype;
 	ulint		prtype;
 	ulint		col_len;
-	ulint		prec;
 	ulint		i;
 	mtr_t		mtr;
 
@@ -356,7 +374,7 @@ dict_load_columns(
 
 	btr_pcur_open_on_user_rec(sys_index, tuple, PAGE_CUR_GE,
 				  BTR_SEARCH_LEAF, &pcur, &mtr);
-	for (i = 0; i < table->n_cols - DATA_N_SYS_COLS; i++) {
+	for (i = 0; i + DATA_N_SYS_COLS < (ulint) table->n_cols; i++) {
 
 		rec = btr_pcur_get_rec(&pcur);
 
@@ -372,8 +390,7 @@ dict_load_columns(
 		ut_ad(len == 4);
 		ut_a(i == mach_read_from_4(field));
 
-		ut_a(!strcmp("NAME", dict_field_get_col
-			     (dict_index_get_nth_field(sys_index, 4))->name));
+		ut_a(name_of_col_is(sys_columns, sys_index, 4, "NAME"));
 
 		field = rec_get_nth_field_old(rec, 4, &len);
 		name = mem_heap_strdupl(heap, (char*) field, len);
@@ -392,15 +409,15 @@ dict_load_columns(
 				/* Use the binary collation for
 				string columns of binary type. */
 
-				prtype = dtype_form_prtype
-					(prtype,
+				prtype = dtype_form_prtype(
+					prtype,
 					DATA_MYSQL_BINARY_CHARSET_COLL);
 			} else {
 				/* Use the default charset for
 				other than binary columns. */
 
-				prtype = dtype_form_prtype
-					(prtype,
+				prtype = dtype_form_prtype(
+					prtype,
 					data_mysql_default_charset_coll);
 			}
 		}
@@ -408,14 +425,9 @@ dict_load_columns(
 		field = rec_get_nth_field_old(rec, 7, &len);
 		col_len = mach_read_from_4(field);
 
-		ut_a(!strcmp("PREC", dict_field_get_col
-			     (dict_index_get_nth_field(sys_index, 8))->name));
-
-		field = rec_get_nth_field_old(rec, 8, &len);
-		prec = mach_read_from_4(field);
+		ut_a(name_of_col_is(sys_columns, sys_index, 8, "PREC"));
 
-		dict_mem_table_add_col(table, name, mtype, prtype, col_len,
-				       prec);
+		dict_mem_table_add_col(table, name, mtype, prtype, col_len);
 		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
 	}
 
@@ -526,13 +538,13 @@ dict_load_fields(
 			prefix_len = 0;
 		}
 
-		ut_a(!strcmp("COL_NAME", dict_field_get_col
-			     (dict_index_get_nth_field(sys_index, 4))->name));
+		ut_a(name_of_col_is(sys_fields, sys_index, 4, "COL_NAME"));
 
 		field = rec_get_nth_field_old(rec, 4, &len);
 
-		dict_mem_index_add_field(index, mem_heap_strdupl
-					 (heap, (char*) field, len),
+		dict_mem_index_add_field(index,
+					 mem_heap_strdupl(heap,
+							  (char*) field, len),
 					 prefix_len);
 
 		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
@@ -631,8 +643,7 @@ dict_load_indexes(
 		ut_ad(len == 8);
 		id = mach_read_from_8(field);
 
-		ut_a(!strcmp("NAME", dict_field_get_col
-			     (dict_index_get_nth_field(sys_index, 4))->name));
+		ut_a(name_of_col_is(sys_indexes, sys_index, 4, "NAME"));
 
 		field = rec_get_nth_field_old(rec, 4, &name_len);
 		name_buf = mem_heap_strdupl(heap, (char*) field, name_len);
@@ -646,8 +657,7 @@ dict_load_indexes(
 		field = rec_get_nth_field_old(rec, 7, &len);
 		space = mach_read_from_4(field);
 
-		ut_a(!strcmp("PAGE_NO", dict_field_get_col
-			     (dict_index_get_nth_field(sys_index, 8))->name));
+		ut_a(name_of_col_is(sys_indexes, sys_index, 8, "PAGE_NO"));
 
 		field = rec_get_nth_field_old(rec, 8, &len);
 		page_no = mach_read_from_4(field);
@@ -785,8 +795,7 @@ dict_load_table(
 		goto err_exit;
 	}
 
-	ut_a(!strcmp("SPACE", dict_field_get_col
-		     (dict_index_get_nth_field(sys_index, 9))->name));
+	ut_a(name_of_col_is(sys_tables, sys_index, 9, "SPACE"));
 
 	field = rec_get_nth_field_old(rec, 9, &len);
 	space = mach_read_from_4(field);
@@ -819,8 +828,7 @@ dict_load_table(
 		}
 	}
 
-	ut_a(!strcmp("N_COLS", dict_field_get_col
-		     (dict_index_get_nth_field(sys_index, 4))->name));
+	ut_a(name_of_col_is(sys_tables, sys_index, 4, "N_COLS"));
 
 	field = rec_get_nth_field_old(rec, 4, &len);
 	n_cols = mach_read_from_4(field);
@@ -837,8 +845,7 @@ dict_load_table(
 
 	table->ibd_file_missing = ibd_file_missing;
 
-	ut_a(!strcmp("ID", dict_field_get_col
-		     (dict_index_get_nth_field(sys_index, 3))->name));
+	ut_a(name_of_col_is(sys_tables, sys_index, 3, "ID"));
 
 	field = rec_get_nth_field_old(rec, 3, &len);
 	table->id = mach_read_from_8(field);
@@ -925,8 +932,8 @@ dict_load_table_on_id(
 	/*---------------------------------------------------*/
 	/* 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));
+	sys_table_ids = dict_table_get_next_index(
+		dict_table_get_first_index(sys_tables));
 	ut_a(!dict_table_is_comp(sys_tables));
 	heap = mem_heap_create(256);
 
@@ -1032,11 +1039,11 @@ dict_load_foreign_cols(
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 #endif /* UNIV_SYNC_DEBUG */
 
-	foreign->foreign_col_names = mem_heap_alloc
-		(foreign->heap, foreign->n_fields * sizeof(void*));
+	foreign->foreign_col_names = mem_heap_alloc(
+		foreign->heap, foreign->n_fields * sizeof(void*));
 
-	foreign->referenced_col_names = mem_heap_alloc
-		(foreign->heap, foreign->n_fields * sizeof(void*));
+	foreign->referenced_col_names = mem_heap_alloc(
+		foreign->heap, foreign->n_fields * sizeof(void*));
 	mtr_start(&mtr);
 
 	sys_foreign_cols = dict_table_get_low("SYS_FOREIGN_COLS");
@@ -1067,12 +1074,12 @@ dict_load_foreign_cols(
 		ut_a(i == mach_read_from_4(field));
 
 		field = rec_get_nth_field_old(rec, 4, &len);
-		foreign->foreign_col_names[i] = mem_heap_strdupl
-			(foreign->heap, (char*) field, len);
+		foreign->foreign_col_names[i] = mem_heap_strdupl(
+			foreign->heap, (char*) field, len);
 
 		field = rec_get_nth_field_old(rec, 5, &len);
-		foreign->referenced_col_names[i] = mem_heap_strdupl
-			(foreign->heap, (char*) field, len);
+		foreign->referenced_col_names[i] = mem_heap_strdupl(
+			foreign->heap, (char*) field, len);
 
 		btr_pcur_move_to_next_user_rec(&pcur, &mtr);
 	}
@@ -1165,8 +1172,8 @@ dict_load_foreign(
 
 	foreign = dict_mem_foreign_create();
 
-	foreign->n_fields = mach_read_from_4
-		(rec_get_nth_field_old(rec, 5, &len));
+	foreign->n_fields = mach_read_from_4(
+		rec_get_nth_field_old(rec, 5, &len));
 
 	ut_a(len == 4);
 
@@ -1178,12 +1185,12 @@ dict_load_foreign(
 	foreign->id = mem_heap_strdup(foreign->heap, id);
 
 	field = rec_get_nth_field_old(rec, 3, &len);
-	foreign->foreign_table_name = mem_heap_strdupl
-		(foreign->heap, (char*) field, len);
+	foreign->foreign_table_name = mem_heap_strdupl(
+		foreign->heap, (char*) field, len);
 
 	field = rec_get_nth_field_old(rec, 4, &len);
-	foreign->referenced_table_name = mem_heap_strdupl
-		(foreign->heap, (char*) field, len);
+	foreign->referenced_table_name = mem_heap_strdupl(
+		foreign->heap, (char*) field, len);
 
 	btr_pcur_close(&pcur);
 	mtr_commit(&mtr);
@@ -1257,8 +1264,8 @@ dict_load_foreigns(
 	/* Get the secondary index based on FOR_NAME from table
 	SYS_FOREIGN */
 
-	sec_index = dict_table_get_next_index
-		(dict_table_get_first_index(sys_foreign));
+	sec_index = dict_table_get_next_index(
+		dict_table_get_first_index(sys_foreign));
 start_load:
 	heap = mem_heap_create(256);
 
@@ -1289,7 +1296,8 @@ dict_load_foreigns(
 	following call does the comparison in the latin1_swedish_ci
 	charset-collation, in a case-insensitive way. */
 
-	if (0 != cmp_data_data(dfield_get_type(dfield),
+	if (0 != cmp_data_data(dfield_get_type(dfield)->mtype,
+			       dfield_get_type(dfield)->prtype,
 			       dfield_get_data(dfield), dfield_get_len(dfield),
 			       field, len)) {
 

storage/innobase/dict/dict0mem.c

@@ -66,6 +66,7 @@ dict_mem_table_create(
 
 	table->cols = mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
 				     * sizeof(dict_col_t));
+	table->col_names = NULL;
 	UT_LIST_INIT(table->indexes);
 
 	table->auto_inc_lock = mem_heap_alloc(heap, lock_get_size());
@@ -76,20 +77,22 @@ dict_mem_table_create(
 	UT_LIST_INIT(table->foreign_list);
 	UT_LIST_INIT(table->referenced_list);
 
+#ifdef UNIV_DEBUG
 	table->does_not_fit_in_memory = FALSE;
+#endif /* UNIV_DEBUG */
 
 	table->stat_initialized = FALSE;
 
 	table->stat_modified_counter = 0;
 
-	table->max_row_size = 0;
+	table->big_rows = 0;
 
 	mutex_create(&table->autoinc_mutex, SYNC_DICT_AUTOINC_MUTEX);
 
 	table->autoinc_inited = FALSE;
-
+#ifdef UNIV_DEBUG
 	table->magic_n = DICT_TABLE_MAGIC_N;
-
+#endif /* UNIV_DEBUG */
 	return(table);
 }
 
@@ -105,9 +108,74 @@ dict_mem_table_free(
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
 	mutex_free(&(table->autoinc_mutex));
+
+	if (table->col_names && (table->n_def < table->n_cols)) {
+		ut_free((void*)table->col_names);
+	}
+
 	mem_heap_free(table->heap);
 }
 
+/********************************************************************
+Add 'name' to end of the col_names array (see dict_table_t::col_names). Call
+ut_free on col_names (if not NULL), allocate new array (if heap, from it,
+otherwise with ut_malloc), and copy col_names + name to it. */
+static
+const char*
+dict_add_col_name(
+/*==============*/
+					/* out: new column names array */
+	const char*	col_names,	/* in: existing column names, or
+					NULL */
+	ulint		cols,		/* in: number of existing columns */
+	const char*	name,		/* in: new column name */
+	mem_heap_t*	heap)		/* in: heap, or NULL */
+{
+	ulint		i;
+	ulint		old_len;
+	ulint		new_len;
+	ulint		total_len;
+	const char*	s;
+	char*		res;
+
+	ut_a(((cols == 0) && !col_names) || ((cols > 0) && col_names));
+	ut_a(*name);
+
+	/* Find out length of existing array. */
+	if (col_names) {
+		s = col_names;
+
+		for (i = 0; i < cols; i++) {
+			s += strlen(s) + 1;
+		}
+
+		old_len = s - col_names;
+	} else {
+		old_len = 0;
+	}
+
+	new_len = strlen(name) + 1;
+	total_len = old_len + new_len;
+
+	if (heap) {
+		res = mem_heap_alloc(heap, total_len);
+	} else {
+		res = ut_malloc(total_len);
+	}
+
+	if (old_len > 0) {
+		memcpy(res, col_names, old_len);
+	}
+
+	memcpy(res + old_len, name, new_len);
+
+	if (col_names) {
+		ut_free((char*)col_names);
+	}
+
+	return(res);
+}
+
 /**************************************************************************
 Adds a column definition to a table. */
 
@@ -118,29 +186,36 @@ dict_mem_table_add_col(
 	const char*	name,	/* in: column name */
 	ulint		mtype,	/* in: main datatype */
 	ulint		prtype,	/* in: precise type */
-	ulint		len,	/* in: length */
-	ulint		prec)	/* in: precision */
+	ulint		len)	/* in: precision */
 {
 	dict_col_t*	col;
-	dtype_t*	type;
+	ulint		mbminlen;
+	ulint		mbmaxlen;
+	mem_heap_t*	heap;
 
 	ut_ad(table && name);
 	ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
 	table->n_def++;
 
-	col = dict_table_get_nth_col(table, table->n_def - 1);
+	heap = table->n_def < table->n_cols ? NULL : table->heap;
+	table->col_names = dict_add_col_name(table->col_names,
+					     table->n_def - 1,
+					     name, heap);
+
+	col = (dict_col_t*) dict_table_get_nth_col(table, table->n_def - 1);
 
 	col->ind = table->n_def - 1;
-	col->name = mem_heap_strdup(table->heap, name);
-	col->table = table;
 	col->ord_part = 0;
 
-	col->clust_pos = ULINT_UNDEFINED;
+	col->mtype = mtype;
+	col->prtype = prtype;
+	col->len = len;
 
-	type = dict_col_get_type(col);
+	dtype_get_mblen(mtype, prtype, &mbminlen, &mbmaxlen);
 
-	dtype_set(type, mtype, prtype, len, prec);
+	col->mbminlen = mbminlen;
+	col->mbmaxlen = mbmaxlen;
 }
 
 /**************************************************************************
@@ -171,6 +246,7 @@ dict_mem_index_create(
 
 	index->type = type;
 	index->space = space;
+	index->page = 0;
 	index->name = mem_heap_strdup(heap, index_name);
 	index->table_name = table_name;
 	index->table = NULL;
@@ -183,8 +259,10 @@ dict_mem_index_create(
 	index->stat_n_diff_key_vals = NULL;
 
 	index->cached = FALSE;
+	memset(&index->lock, 0, sizeof index->lock);
+#ifdef UNIV_DEBUG
 	index->magic_n = DICT_INDEX_MAGIC_N;
-
+#endif /* UNIV_DEBUG */
 	return(index);
 }
 

storage/innobase/eval/eval0proc.c

@@ -51,8 +51,8 @@ if_step(
 			for (;;) {
 				eval_exp(elsif_node->cond);
 
-				if (eval_node_get_ibool_val
-				    (elsif_node->cond)) {
+				if (eval_node_get_ibool_val(
+					    elsif_node->cond)) {
 
 					/* The condition evaluated to TRUE:
 					start execution from the first

storage/innobase/fil/fil0fil.c

@@ -529,9 +529,8 @@ fil_node_open_file(
 		os_file_read() in Windows to read from a file opened for
 		async I/O! */
 
-		node->handle = os_file_create_simple_no_error_handling
-			(node->name,
-			 OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
+		node->handle = os_file_create_simple_no_error_handling(
+			node->name, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
 		if (!success) {
 			/* The following call prints an error message */
 			os_file_get_last_error(TRUE);
@@ -1564,9 +1563,9 @@ fil_write_flushed_lsn_to_data_files(
 			while (node) {
 				mutex_exit(&(fil_system->mutex));
 
-				err = fil_write_lsn_and_arch_no_to_file
-					(space->id, sum_of_sizes,
-					 lsn, arch_log_no);
+				err = fil_write_lsn_and_arch_no_to_file(
+					space->id, sum_of_sizes, lsn,
+					arch_log_no);
 				if (err != DB_SUCCESS) {
 
 					return(err);
@@ -1936,8 +1935,8 @@ fil_op_log_parse_or_replay(
 
 			ut_a(space_id != 0);
 
-			if (fil_create_new_single_table_tablespace
-			    (&space_id, name, FALSE,
+			if (fil_create_new_single_table_tablespace(
+				    &space_id, name, FALSE,
 				    FIL_IBD_FILE_INITIAL_SIZE) != DB_SUCCESS) {
 				ut_error;
 			}
@@ -2580,8 +2579,8 @@ fil_reset_too_high_lsns(
 
 	filepath = fil_make_ibd_name(name, FALSE);
 
-	file = os_file_create_simple_no_error_handling
-		(filepath, OS_FILE_OPEN, OS_FILE_READ_WRITE, &success);
+	file = os_file_create_simple_no_error_handling(
+		filepath, OS_FILE_OPEN, OS_FILE_READ_WRITE, &success);
 	if (!success) {
 		/* The following call prints an error message */
 		os_file_get_last_error(TRUE);
@@ -2654,8 +2653,8 @@ fil_reset_too_high_lsns(
 		if (ut_dulint_cmp(mach_read_from_8(page + FIL_PAGE_LSN),
 				  current_lsn) > 0) {
 			/* We have to reset the lsn */
-			space_id = mach_read_from_4
-				(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
+			space_id = mach_read_from_4(
+				page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 			page_no = mach_read_from_4(page + FIL_PAGE_OFFSET);
 
 			buf_flush_init_for_writing(page, current_lsn, space_id,
@@ -2735,8 +2734,8 @@ fil_open_single_table_tablespace(
 
 	filepath = fil_make_ibd_name(name, FALSE);
 
-	file = os_file_create_simple_no_error_handling
-		(filepath, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
+	file = os_file_create_simple_no_error_handling(
+		filepath, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
 	if (!success) {
 		/* The following call prints an error message */
 		os_file_get_last_error(TRUE);
@@ -2887,8 +2886,8 @@ fil_load_single_table_tablespace(
 	dict_casedn_str(filepath);
 # endif /* !UNIV_HOTBACKUP */
 #endif
-	file = os_file_create_simple_no_error_handling
-		(filepath, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
+	file = os_file_create_simple_no_error_handling(
+		filepath, OS_FILE_OPEN, OS_FILE_READ_ONLY, &success);
 	if (!success) {
 		/* The following call prints an error message */
 		os_file_get_last_error(TRUE);
@@ -3242,8 +3241,8 @@ fil_load_single_table_tablespaces(void)
 						   ".ibd")) {
 					/* The name ends in .ibd; try opening
 					the file */
-					fil_load_single_table_tablespace
-						(dbinfo.name, fileinfo.name);
+					fil_load_single_table_tablespace(
+						dbinfo.name, fileinfo.name);
 				}
 next_file_item:
 				ret = fil_file_readdir_next_file(&err,
@@ -3736,8 +3735,8 @@ fil_extend_tablespaces_to_stored_len(void)
 
 		size_in_header = fsp_get_size_low(buf);
 
-		success = fil_extend_space_to_desired_size
-			(&actual_size, space->id, size_in_header);
+		success = fil_extend_space_to_desired_size(
+			&actual_size, space->id, size_in_header);
 		if (!success) {
 			fprintf(stderr,
 				"InnoDB: Error: could not extend the"
@@ -4082,9 +4081,9 @@ fil_io(
 
 	for (;;) {
 		if (node == NULL) {
-			fil_report_invalid_page_access
-				(block_offset, space_id,
-				 space->name, byte_offset, len, type);
+			fil_report_invalid_page_access(
+				block_offset, space_id, space->name,
+				byte_offset, len, type);
 
 			ut_error;
 		}
@@ -4113,9 +4112,9 @@ fil_io(
 	if (space->purpose == FIL_TABLESPACE && space->id != 0
 	    && node->size <= block_offset) {
 
-		fil_report_invalid_page_access
-			(block_offset, space_id,
-			 space->name, byte_offset, len, type);
+		fil_report_invalid_page_access(
+			block_offset, space_id, space->name, byte_offset,
+			len, type);
 
 		ut_error;
 	}
@@ -4384,8 +4383,8 @@ fil_flush(
 
 					space->is_in_unflushed_spaces = FALSE;
 
-					UT_LIST_REMOVE
-						(unflushed_spaces,
+					UT_LIST_REMOVE(
+						unflushed_spaces,
 						system->unflushed_spaces,
 						space);
 				}

storage/innobase/handler/ha_innodb.h

@@ -201,8 +201,6 @@ class ha_innobase: public handler
 	int cmp_ref(const byte *ref1, const byte *ref2);
 	bool check_if_incompatible_data(HA_CREATE_INFO *info,
 					uint table_changes);
-        void build_template(struct row_prebuilt_struct *prebuilt, THD *thd,
-                            TABLE *table, uint templ_type);
 };
 
 extern SHOW_VAR innodb_status_variables[];