Merge with 4.0

innobase/dict/dict0boot.c:
  Auto merged
innobase/dict/dict0load.c:
  Auto merged
innobase/dict/dict0mem.c:
  Auto merged
innobase/fut/fut0lst.c:
  Auto merged
innobase/include/buf0lru.h:
  Auto merged
innobase/include/dict0mem.h:
  Auto merged
innobase/include/fsp0fsp.h:
  Auto merged
innobase/include/ha0ha.h:
  Auto merged
innobase/include/ibuf0ibuf.h:
  Auto merged
innobase/include/lock0lock.h:
  Auto merged
innobase/include/log0log.h:
  Auto merged
innobase/include/mem0pool.h:
  Auto merged
innobase/include/mtr0mtr.h:
  Auto merged
innobase/include/os0file.h:
  Auto merged
innobase/include/rem0rec.h:
  Auto merged
innobase/include/rem0rec.ic:
  Auto merged
innobase/include/srv0srv.h:
  Auto merged
innobase/include/sync0sync.h:
  Auto merged
innobase/include/trx0sys.h:
  Auto merged
innobase/include/ut0byte.h:
  Auto merged
innobase/include/ut0ut.h:
  Auto merged
innobase/mem/mem0pool.c:
  Auto merged
innobase/mtr/mtr0mtr.c:
  Auto merged
innobase/os/os0proc.c:
  Auto merged
innobase/pars/lexyy.c:
  Auto merged
innobase/pars/pars0opt.c:
  Auto merged
innobase/row/row0ins.c:
  Auto merged
innobase/row/row0purge.c:
  Auto merged
innobase/row/row0uins.c:
  Auto merged
innobase/row/row0umod.c:
  Auto merged
innobase/row/row0undo.c:
  Auto merged
innobase/row/row0upd.c:
  Auto merged
innobase/trx/trx0purge.c:
  Auto merged
innobase/trx/trx0roll.c:
  Auto merged
innobase/trx/trx0sys.c:
  Auto merged
innobase/trx/trx0undo.c:
  Auto merged
innobase/ut/ut0byte.c:
  Auto merged
pstack/bucomm.h:
  Auto merged
pstack/budbg.h:
  Auto merged
sql/item_sum.h:
  Auto merged
sql/slave.cc:
  Auto merged
sql/sql_db.cc:
  Auto merged
support-files/mysql.spec.sh:
  Auto merged
tests/insert_test.c:
  Auto merged
mysql-test/t/func_group.test:
  Merge with 4.0
  Put 4.1 tests lasts
sql/ha_innodb.cc:
  Merge with 4.0
  Added checking of results from my_malloc()
BitKeeper/etc/logging_ok:
  Logging to logging@openlogging.org accepted

3 files changed, 226 insertions, 211 deletions

diff --git a/innobase/btr/btr0btr.c b/innobase/btr/btr0btr.c
index 77bb4231404..8388009dc9c 100644
--- a/innobase/btr/btr0btr.c
+++ b/innobase/btr/btr0btr.c
@@ -589,28 +589,29 @@ btr_page_get_father_for_rec(
 
 	if (btr_node_ptr_get_child_page_no(node_ptr) !=
                                                 buf_frame_get_page_no(page)) {
-		fprintf(stderr,
-"InnoDB: Dump of the child page:\n");
+		fputs("InnoDB: Dump of the child page:\n", stderr);
 		buf_page_print(buf_frame_align(page));
-		fprintf(stderr,
-"InnoDB: Dump of the parent page:\n");
+		fputs("InnoDB: Dump of the parent page:\n", stderr);
 		buf_page_print(buf_frame_align(node_ptr));
 
-      		fprintf(stderr,
-"InnoDB: Corruption of an index tree: table %s, index %s,\n"
+		fputs("InnoDB: Corruption of an index tree: table ", stderr);
+		ut_print_name(stderr,
+			UT_LIST_GET_FIRST(tree->tree_indexes)->table_name);
+		fputs(", index ", stderr);
+		ut_print_name(stderr,
+			UT_LIST_GET_FIRST(tree->tree_indexes)->name);
+		fprintf(stderr, ",\n"
 "InnoDB: father ptr page no %lu, child page no %lu\n",
-                    (UT_LIST_GET_FIRST(tree->tree_indexes))->table_name,
-                    (UT_LIST_GET_FIRST(tree->tree_indexes))->name,
-                    (unsigned long) btr_node_ptr_get_child_page_no(node_ptr),
-                    (unsigned long) buf_frame_get_page_no(page));
+			(ulong) btr_node_ptr_get_child_page_no(node_ptr),
+			(ulong) buf_frame_get_page_no(page));
      		page_rec_print(page_rec_get_next(page_get_infimum_rec(page)));
      		page_rec_print(node_ptr);
 
-      		fprintf(stderr,
+		fputs(
 "InnoDB: You should dump + drop + reimport the table to fix the\n"
 "InnoDB: corruption. If the crash happens at the database startup, see\n"
-"InnoDB: section 6.1 of http://www.innodb.com/ibman.html about forcing\n"
-"InnoDB: recovery. Then dump + drop + reimport.\n");
+"InnoDB: section 6.1 of http://www.innodb.com/ibman.php about forcing\n"
+"InnoDB: recovery. Then dump + drop + reimport.\n", stderr);
 	}
 
 	ut_a(btr_node_ptr_get_child_page_no(node_ptr) ==
@@ -1053,7 +1054,7 @@ btr_root_raise_and_insert(
 
 	/* We play safe and reset the free bits for the new page */
 
-/*	printf("Root raise new page no %lu\n",
+/*	fprintf(stderr, "Root raise new page no %lu\n",
 					buf_frame_get_page_no(new_page)); */
 
 	ibuf_reset_free_bits(UT_LIST_GET_FIRST(tree->tree_indexes),
@@ -1602,7 +1603,7 @@ func_start:
 
 	/* 5. Move then the records to the new page */
 	if (direction == FSP_DOWN) {
-/*		printf("Split left\n"); */
+/*		fputs("Split left\n", stderr); */
 
 		page_move_rec_list_start(new_page, page, move_limit, mtr);
 		left_page = new_page;
@@ -1610,7 +1611,7 @@ func_start:
 
 		lock_update_split_left(right_page, left_page);
 	} else {
-/*		printf("Split right\n"); */
+/*		fputs("Split right\n", stderr); */
 
 		page_move_rec_list_end(new_page, page, move_limit, mtr);
 		left_page = page;
@@ -1646,7 +1647,7 @@ func_start:
 		ibuf_update_free_bits_for_two_pages_low(cursor->index,
 							left_page,
 							right_page, mtr);
-		/* printf("Split and insert done %lu %lu\n",
+		/* fprintf(stderr, "Split and insert done %lu %lu\n",
 				buf_frame_get_page_no(left_page),
 				buf_frame_get_page_no(right_page)); */
 		return(rec);
@@ -1666,7 +1667,7 @@ func_start:
 		/* We play safe and reset the free bits for new_page */
 		ibuf_reset_free_bits(cursor->index, new_page);
 
-		/* printf("Split second round %lu\n",
+		/* fprintf(stderr, "Split second round %lu\n",
 					buf_frame_get_page_no(page)); */
 		n_iterations++;
 		ut_ad(n_iterations < 2);
@@ -1680,7 +1681,7 @@ func_start:
 
 	ibuf_update_free_bits_for_two_pages_low(cursor->index, left_page,
 							right_page, mtr);
-	/* printf("Split and insert done %lu %lu\n",
+	/* fprintf(stderr, "Split and insert done %lu %lu\n",
 				buf_frame_get_page_no(left_page),
 				buf_frame_get_page_no(right_page)); */
 
@@ -1927,7 +1928,7 @@ btr_compress(
 	left_page_no = btr_page_get_prev(page, mtr);
 	right_page_no = btr_page_get_next(page, mtr);
 
-/*	printf("Merge left page %lu right %lu \n", left_page_no,
+/*	fprintf(stderr, "Merge left page %lu right %lu \n", left_page_no,
 							right_page_no); */
 
 	node_ptr = btr_page_get_father_node_ptr(tree, page, mtr);
@@ -2164,6 +2165,7 @@ btr_discard_page(
 	ut_ad(btr_check_node_ptr(tree, merge_page, mtr));
 }	
 
+#ifdef UNIV_DEBUG
 /*****************************************************************
 Prints size info of a B-tree. */
 
@@ -2177,8 +2179,9 @@ btr_print_size(
 	mtr_t		mtr;
 
 	if (tree->type & DICT_IBUF) {
-		printf(
-	"Sorry, cannot print info of an ibuf tree: use ibuf functions\n");
+		fputs(
+	"Sorry, cannot print info of an ibuf tree: use ibuf functions\n",
+			stderr);
 
 		return;
 	}
@@ -2189,14 +2192,14 @@ btr_print_size(
 
 	seg = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
 
-	printf("INFO OF THE NON-LEAF PAGE SEGMENT\n");
+	fputs("INFO OF THE NON-LEAF PAGE SEGMENT\n", stderr);
 	fseg_print(seg, &mtr);
 
 	if (!(tree->type & DICT_UNIVERSAL)) {
 
 		seg = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
 
-		printf("INFO OF THE LEAF PAGE SEGMENT\n");
+		fputs("INFO OF THE LEAF PAGE SEGMENT\n", stderr);
 		fseg_print(seg, &mtr);
 	}
 
@@ -2224,7 +2227,7 @@ btr_print_recursive(
 	
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
 							MTR_MEMO_PAGE_X_FIX));
-	printf("NODE ON LEVEL %lu page number %lu\n",
+	fprintf(stderr, "NODE ON LEVEL %lu page number %lu\n",
 	       (ulong) btr_page_get_level(page, mtr),
 	       (ulong) buf_frame_get_page_no(page));
 	
@@ -2271,8 +2274,8 @@ btr_print_tree(
 	mtr_t	mtr;
 	page_t*	root;
 
-	printf("--------------------------\n");
-	printf("INDEX TREE PRINT\n");
+	fputs("--------------------------\n"
+		"INDEX TREE PRINT\n", stderr);
 
 	mtr_start(&mtr);
 
@@ -2284,6 +2287,7 @@ btr_print_tree(
 
 	btr_validate_tree(tree);
 }
+#endif /* UNIV_DEBUG */
 
 /****************************************************************
 Checks that the node pointer to a page is appropriate. */
@@ -2329,6 +2333,22 @@ btr_check_node_ptr(
 }
 
 /****************************************************************
+Display identification information for a record. */
+static
+void
+btr_index_rec_validate_report(
+/*==========================*/
+	page_t*		page,	/* in: index page */
+	rec_t*		rec,	/* in: index record */
+	dict_index_t*	index)	/* in: index */
+{
+	fputs("InnoDB: Record in ", stderr);
+	dict_index_name_print(stderr, index);
+	fprintf(stderr, ", page %lu, at offset %lu\n",
+		buf_frame_get_page_no(page), (ulint)(rec - page));
+}
+
+/****************************************************************
 Checks the size and number of fields in a record based on the definition of
 the index. */
 
@@ -2342,13 +2362,10 @@ btr_index_rec_validate(
 					should print hex dump of record
 					and page on error */
 {
-	dtype_t* type;
-	byte*	data;
 	ulint	len;
 	ulint	n;
 	ulint	i;
 	page_t*	page;
-	char	err_buf[1000];
 
 	page = buf_frame_align(rec);
 	
@@ -2363,14 +2380,9 @@ btr_index_rec_validate(
 	n = dict_index_get_n_fields(index);
 
 	if (rec_get_n_fields(rec) != n) {
-		fprintf(stderr,
-"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"
-"InnoDB: has %lu fields, should have %lu\n",
-			index->name, index->table_name,
-			(unsigned long) buf_frame_get_page_no(page),
-			(unsigned long) (rec - page),
-			(unsigned long) rec_get_n_fields(rec),
-			(unsigned long) n);
+		btr_index_rec_validate_report(page, rec, index);
+		fprintf(stderr, "InnoDB: has %lu fields, should have %lu\n",
+			(ulong) rec_get_n_fields(rec), (ulong) n);
 
 		if (!dump_on_error) {
 
@@ -2379,16 +2391,17 @@ btr_index_rec_validate(
 
 		buf_page_print(page);
 
-		rec_sprintf(err_buf, 900, rec);
-	  	fprintf(stderr, "InnoDB: corrupt record %s\n", err_buf);
+		fputs("InnoDB: corrupt record ", stderr);
+		rec_print(stderr, rec);
+		putc('\n', stderr);
 
 		return(FALSE);
 	}
 
 	for (i = 0; i < n; i++) {
-		data = rec_get_nth_field(rec, i, &len);
+		dtype_t*	type = dict_index_get_nth_type(index, i);
 
-		type = dict_index_get_nth_type(index, i);
+		rec_get_nth_field(rec, i, &len);
 		
 		if ((dict_index_get_nth_field(index, i)->prefix_len == 0
 		    && len != UNIV_SQL_NULL && dtype_is_fixed_size(type)
@@ -2399,15 +2412,10 @@ btr_index_rec_validate(
 		    && len !=
 			   dict_index_get_nth_field(index, i)->prefix_len)) {
 
+			btr_index_rec_validate_report(page, rec, index);
 			fprintf(stderr,
-"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"
 "InnoDB: field %lu len is %lu, should be %lu\n",
-				index->name, index->table_name,
-				(unsigned long) buf_frame_get_page_no(page),
-				(unsigned long) (rec - page),
-				(unsigned long) i,
-				(unsigned long) len,
-				(unsigned long) dtype_get_fixed_size(type));
+				(ulong) i, (ulong) len, (ulong) dtype_get_fixed_size(type));
 
 			if (!dump_on_error) {
 	
@@ -2416,9 +2424,9 @@ btr_index_rec_validate(
 
 			buf_page_print(page);
 
-			rec_sprintf(err_buf, 900, rec);
-	  		fprintf(stderr,
-                             "InnoDB: corrupt record %s\n", err_buf);
+			fputs("InnoDB: corrupt record ", stderr);
+			rec_print(stderr, rec);
+			putc('\n', stderr);
 
 			return(FALSE);
 		}
@@ -2438,7 +2446,6 @@ btr_index_page_validate(
 	page_t*		page,	/* in: index page */
 	dict_index_t*	index)	/* in: index */
 {
-	rec_t*		rec;
 	page_cur_t 	cur;
 	ibool		ret	= TRUE;
 	
@@ -2446,14 +2453,12 @@ btr_index_page_validate(
 	page_cur_move_to_next(&cur);
 
 	for (;;) {
-		rec = (&cur)->rec;
-
 		if (page_cur_is_after_last(&cur)) {
 
 			break;
 		}
 
-		if (!btr_index_rec_validate(rec, index, TRUE)) {
+		if (!btr_index_rec_validate(cur.rec, index, TRUE)) {
 
 			return(FALSE);
 		}
@@ -2465,6 +2470,46 @@ btr_index_page_validate(
 }
 
 /****************************************************************
+Report an error on one page of an index tree. */
+static
+void
+btr_validate_report1(
+				/* out: TRUE if ok */
+	dict_index_t*	index,	/* in: index */
+	ulint		level,	/* in: B-tree level */
+	page_t*		page)	/* in: index page */
+{
+	fprintf(stderr, "InnoDB: Error in page %lu of ",
+		buf_frame_get_page_no(page));
+	dict_index_name_print(stderr, index);
+	if (level) {
+		fprintf(stderr, ", index tree level %lu", level);
+	}
+	putc('\n', stderr);
+}
+
+/****************************************************************
+Report an error on two pages of an index tree. */
+static
+void
+btr_validate_report2(
+				/* out: TRUE if ok */
+	dict_index_t*	index,	/* in: index */
+	ulint		level,	/* in: B-tree level */
+	page_t*		page1,	/* in: first index page */
+	page_t*		page2)	/* in: second index page */
+{
+	fprintf(stderr, "InnoDB: Error in pages %lu and %lu of ",
+		buf_frame_get_page_no(page1),
+		buf_frame_get_page_no(page2));
+	dict_index_name_print(stderr, index);
+	if (level) {
+		fprintf(stderr, ", index tree level %lu", level);
+	}
+	putc('\n', stderr);
+}
+
+/****************************************************************
 Validates index tree level. */
 static
 ibool
@@ -2489,7 +2534,6 @@ btr_validate_level(
 	ibool		ret	= TRUE;
 	dict_index_t*	index;
 	mtr_t		mtr;
-	char		err_buf[1000];
 	
 	mtr_start(&mtr);
 
@@ -2520,10 +2564,7 @@ loop:
 	/* Check ordering etc. of records */
 
 	if (!page_validate(page, index)) {
-		fprintf(stderr,
-"InnoDB: Error in page %lu in index %s table %s, index tree level %lu\n",
-			(ulong) buf_frame_get_page_no(page), index->name,
-			index->table_name, (ulong) level);
+		btr_validate_report1(index, level, page);
 
 		ret = FALSE;
 	} else if (level == 0) {
@@ -2553,25 +2594,22 @@ loop:
 			page_rec_get_next(page_get_infimum_rec(right_page)),
 			UT_LIST_GET_FIRST(tree->tree_indexes)) >= 0) {
 
- 			fprintf(stderr,
-		"InnoDB: Error on pages %lu and %lu in index %s table %s\n",
-				(ulong) buf_frame_get_page_no(page),
-				(ulong) right_page_no,
-				index->name, index->table_name);
+			btr_validate_report2(index, level, page, right_page);
 
-			fprintf(stderr,
-			"InnoDB: records in wrong order on adjacent pages\n");
+			fputs("InnoDB: records in wrong order"
+				" on adjacent pages\n", stderr);
 
 			buf_page_print(page);
 			buf_page_print(right_page);
 
-			rec_sprintf(err_buf, 900,
-				page_rec_get_prev(page_get_supremum_rec(page)));
-	  		fprintf(stderr, "InnoDB: record %s\n", err_buf);
-
-			rec_sprintf(err_buf, 900,
-			page_rec_get_next(page_get_infimum_rec(right_page)));
-	  		fprintf(stderr, "InnoDB: record %s\n", err_buf);
+			fputs("InnoDB: record ", stderr);
+			rec_print(stderr, page_rec_get_prev(
+				page_get_supremum_rec(page)));
+			putc('\n', stderr);
+			fputs("InnoDB: record ", stderr);
+			rec_print(stderr, page_rec_get_next(
+				page_get_infimum_rec(right_page)));
+			putc('\n', stderr);
 
 	  		ret = FALSE;
 	  	}
@@ -2594,32 +2632,27 @@ loop:
 		   || node_ptr != btr_page_get_father_for_rec(tree, page,
 		   	page_rec_get_prev(page_get_supremum_rec(page)),
 								&mtr)) {
- 			fprintf(stderr,
-			"InnoDB: Error on page %lu in index %s table %s\n",
-				(unsigned long) buf_frame_get_page_no(page),
-				index->name, index->table_name);
+			btr_validate_report1(index, level, page);
 
-			fprintf(stderr,
-			"InnoDB: node pointer to the page is wrong\n");
+			fputs("InnoDB: node pointer to the page is wrong\n",
+				stderr);
 
 			buf_page_print(father_page);
 			buf_page_print(page);
 
-			rec_sprintf(err_buf, 900, node_ptr);
-				
-	  		fprintf(stderr, "InnoDB: node ptr %s\n", err_buf);
+			fputs("InnoDB: node ptr ", stderr);
+			rec_print(stderr, node_ptr);
 
-			fprintf(stderr,
+			fprintf(stderr, "\n"
 				"InnoDB: node ptr child page n:o %lu\n",
 				(unsigned long) btr_node_ptr_get_child_page_no(node_ptr));
 
-			rec_sprintf(err_buf, 900,
+			fputs("InnoDB: record on page ", stderr);
+			rec_print(stderr,
 			 	btr_page_get_father_for_rec(tree, page,
 		   	 	page_rec_get_prev(page_get_supremum_rec(page)),
 					&mtr));
-
-	  		fprintf(stderr, "InnoDB: record on page %s\n",
-								err_buf);
+			putc('\n', stderr);
 		   	ret = FALSE;
 
 		   	goto node_ptr_fails;
@@ -2637,27 +2670,19 @@ loop:
 
 			if (cmp_dtuple_rec(node_ptr_tuple, node_ptr) != 0) {
 
-	 			fprintf(stderr,
-			"InnoDB: Error on page %lu in index %s table %s\n",
-					(ulong) buf_frame_get_page_no(page),
-					index->name, index->table_name);
+				btr_validate_report1(index, level, page);
 
 				buf_page_print(father_page);
 				buf_page_print(page);
 
-	  			fprintf(stderr,
-                	"InnoDB: Error: node ptrs differ on levels > 0\n");
-							
-				rec_sprintf(err_buf, 900, node_ptr);
-				
-	  			fprintf(stderr, "InnoDB: node ptr %s\n",
-								err_buf);
-				rec_sprintf(err_buf, 900,
-				  page_rec_get_next(
+				fputs("InnoDB: Error: node ptrs differ"
+					" on levels > 0\n"
+					"InnoDB: node ptr ", stderr);
+				rec_print(stderr, node_ptr);
+				fputs("InnoDB: first rec ", stderr);
+				rec_print(stderr, page_rec_get_next(
 					page_get_infimum_rec(page)));
-				
-	  			fprintf(stderr, "InnoDB: first rec %s\n",
-								err_buf);
+				putc('\n', stderr);
 		   		ret = FALSE;
 				mem_heap_free(heap);
 
@@ -2689,13 +2714,12 @@ loop:
 				if (right_node_ptr !=
 						page_rec_get_next(node_ptr)) {
 					ret = FALSE;
-					fprintf(stderr,
-			"InnoDB: node pointer to the right page is wrong\n");
+					fputs(
+			"InnoDB: node pointer to the right page is wrong\n",
+					stderr);
 
-	 				fprintf(stderr,
-			"InnoDB: Error on page %lu in index %s table %s\n",
-					(unsigned long) buf_frame_get_page_no(page),
-					index->name, index->table_name);
+					btr_validate_report1(index, level,
+						page);
 
 					buf_page_print(father_page);
 					buf_page_print(page);
@@ -2709,13 +2733,12 @@ loop:
 					   		page_get_infimum_rec(
 							right_father_page))) {
 					ret = FALSE;
-					fprintf(stderr,
-			"InnoDB: node pointer 2 to the right page is wrong\n");
+					fputs(
+			"InnoDB: node pointer 2 to the right page is wrong\n",
+					stderr);
 
-	 				fprintf(stderr,
-			"InnoDB: Error on page %lu in index %s table %s\n",
-					(unsigned long) buf_frame_get_page_no(page),
-					index->name, index->table_name);
+					btr_validate_report1(index, level,
+						page);
 
 					buf_page_print(father_page);
 					buf_page_print(right_father_page);
@@ -2727,13 +2750,12 @@ loop:
 				   != btr_page_get_next(father_page, &mtr)) {
 
 					ret = FALSE;
-					fprintf(stderr,
-			"InnoDB: node pointer 3 to the right page is wrong\n");
+					fputs(
+			"InnoDB: node pointer 3 to the right page is wrong\n",
+					stderr);
 
-	 				fprintf(stderr,
-			"InnoDB: Error on page %lu in index %s table %s\n",
-					(unsigned long) buf_frame_get_page_no(page),
-					index->name, index->table_name);
+					btr_validate_report1(index, level,
+						page);
 
 					buf_page_print(father_page);
 					buf_page_print(right_father_page);
diff --git a/innobase/btr/btr0cur.c b/innobase/btr/btr0cur.c
index fdc8343e190..e67d1d76113 100644
--- a/innobase/btr/btr0cur.c
+++ b/innobase/btr/btr0cur.c
@@ -120,7 +120,6 @@ static
 void
 btr_cur_latch_leaves(
 /*=================*/
-	dict_tree_t*	tree __attribute__((unused)),	/* in: index tree */
 	page_t*		page,		/* in: leaf page where the search
 					converged */
 	ulint		space,		/* in: space id */
@@ -133,7 +132,7 @@ btr_cur_latch_leaves(
 	ulint	right_page_no;
 	page_t*	get_page;
 	
-	ut_ad(tree && page && mtr);
+	ut_ad(page && mtr);
 
 	if (latch_mode == BTR_SEARCH_LEAF) {
 	
@@ -366,17 +365,19 @@ btr_cur_search_to_nth_level(
 	B-tree. These let us end up in the right B-tree leaf. In that leaf
 	we use the original search mode. */
 
-	if (mode == PAGE_CUR_GE) {
+	switch (mode) {
+	case PAGE_CUR_GE:
 		page_mode = PAGE_CUR_L;
-	} else if (mode == PAGE_CUR_G) {
+		break;
+	case PAGE_CUR_G:
 		page_mode = PAGE_CUR_LE;
-	} else if (mode == PAGE_CUR_LE) {
-		page_mode = PAGE_CUR_LE;
-	} else if (mode == PAGE_CUR_LE_OR_EXTENDS) {
-		page_mode = PAGE_CUR_LE_OR_EXTENDS;
-	} else {
-		ut_ad(mode == PAGE_CUR_L);
-		page_mode = PAGE_CUR_L;
+		break;
+	default:
+		ut_ad(mode == PAGE_CUR_L
+			|| mode == PAGE_CUR_LE
+			|| mode == PAGE_CUR_LE_OR_EXTENDS);
+		page_mode = mode;
+		break;
 	}
 			
 	/* Loop and search until we arrive at the desired level */
@@ -451,7 +452,7 @@ retry_page_get:
 		if (height == 0) {
 			if (rw_latch == RW_NO_LATCH) {
 
-				btr_cur_latch_leaves(tree, page, space,
+				btr_cur_latch_leaves(page, space,
 						page_no, latch_mode, cursor,
 						mtr);
 			}
@@ -478,6 +479,9 @@ retry_page_get:
 
 		/* If this is the desired level, leave the loop */
 
+		ut_ad(height
+		== btr_page_get_level(page_cur_get_page(page_cursor), mtr));
+
 		if (level == height) {
 
 			if (level > 0) {
@@ -591,7 +595,7 @@ btr_cur_open_at_index_side(
 		}
 
 		if (height == 0) {
-			btr_cur_latch_leaves(tree, page, space, page_no,
+			btr_cur_latch_leaves(page, space, page_no,
 						latch_mode, cursor, mtr);
 
 			/* In versions <= 3.23.52 we had forgotten to
@@ -697,7 +701,7 @@ btr_cur_open_at_rnd_pos(
 		}
 
 		if (height == 0) {
-			btr_cur_latch_leaves(tree, page, space, page_no,
+			btr_cur_latch_leaves(page, space, page_no,
 						latch_mode, cursor, mtr);
 		}
 
@@ -830,6 +834,24 @@ btr_cur_ins_lock_and_undo(
 }
 
 /*****************************************************************
+Report information about a transaction. */
+static
+void
+btr_cur_trx_report(
+/*===============*/
+	const trx_t*		trx,	/* in: transaction */
+	const dict_index_t*	index,	/* in: index */
+	const char*		op)	/* in: operation */
+{
+	fprintf(stderr, "Trx with id %lu %lu going to ",
+		ut_dulint_get_high(trx->id),
+		ut_dulint_get_low(trx->id));
+	fputs(op, stderr);
+	dict_index_name_print(stderr, index);
+	putc('\n', stderr);
+}
+
+/*****************************************************************
 Tries to perform an insert to a page in an index tree, next to cursor.
 It is assumed that mtr holds an x-latch on the page. The operation does
 not succeed if there is too little space on the page. If there is just
@@ -876,18 +898,13 @@ btr_cur_optimistic_insert(
 	index = cursor->index;
 
 	if (!dtuple_check_typed_no_assert(entry)) {
-		fprintf(stderr,
-"InnoDB: Error in a tuple to insert into table %s index %s\n",
-					index->table_name, index->name);
+		fputs("InnoDB: Error in a tuple to insert into ", stderr);
+		dict_index_name_print(stderr, index);
 	}
 	
 	if (btr_cur_print_record_ops && thr) {
-		printf(
-	"Trx with id %lu %lu going to insert to table %s index %s\n",
-		(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
-		(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
-		index->table_name, index->name);
-		dtuple_print(entry);
+		btr_cur_trx_report(thr_get_trx(thr), index, "insert into ");
+		dtuple_print(stderr, entry);
 	}
 	
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@@ -980,21 +997,15 @@ calculate_sizes_again:
 
 		*rec = page_cur_tuple_insert(page_cursor, entry, mtr);
 
-		if (!(*rec)) {
-			char* err_buf = mem_alloc(1000);
-
-			dtuple_sprintf(err_buf, 900, entry);
-			
-			fprintf(stderr,
-	"InnoDB: Error: cannot insert tuple %s to index %s of table %s\n"
-	"InnoDB: max insert size %lu\n",
-			err_buf, index->name, index->table->name,
-			(unsigned long) max_size);
-
-			mem_free(err_buf);
+		if (!*rec) {
+			fputs("InnoDB: Error: cannot insert tuple ", stderr);
+			dtuple_print(stderr, entry);
+			fputs(" into ", stderr);
+			dict_index_name_print(stderr, index);
+			fprintf(stderr, "\nInnoDB: max insert size %lu\n",
+				(ulong) max_size);
+			ut_error;
 		}
-		
-		ut_a(*rec); /* <- We calculated above the record would fit */
 	}
 
 #ifdef BTR_CUR_HASH_ADAPT
@@ -1010,7 +1021,8 @@ calculate_sizes_again:
 		lock_update_insert(*rec);
 	}
 
-/*	printf("Insert to page %lu, max ins size %lu, rec %lu ind type %lu\n",
+/*	fprintf(stderr, "Insert into page %lu, max ins size %lu,"
+		" rec %lu ind type %lu\n",
 			buf_frame_get_page_no(page), max_size,
 					rec_size + PAGE_DIR_SLOT_SIZE, type);
 */	
@@ -1363,12 +1375,8 @@ btr_cur_update_in_place(
 	trx = thr_get_trx(thr);
 	
 	if (btr_cur_print_record_ops && thr) {
-		printf(
-	"Trx with id %lu %lu going to update table %s index %s\n",
-		(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
-		(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
-		index->table_name, index->name);
-		rec_print(rec);
+		btr_cur_trx_report(trx, index, "update ");
+		rec_print(stderr, rec);
 	}
 
 	/* Do lock checking and undo logging */
@@ -1467,12 +1475,8 @@ btr_cur_optimistic_update(
 	index = cursor->index;
 	
 	if (btr_cur_print_record_ops && thr) {
-		printf(
-	"Trx with id %lu %lu going to update table %s index %s\n",
-		(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
-		(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
-		index->table_name, index->name);
-		rec_print(rec);
+		btr_cur_trx_report(thr_get_trx(thr), index, "update ");
+		rec_print(stderr, rec);
 	}
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@@ -2016,12 +2020,8 @@ btr_cur_del_mark_set_clust_rec(
 	index = cursor->index;
 	
 	if (btr_cur_print_record_ops && thr) {
-		printf(
-	"Trx with id %lu %lu going to del mark table %s index %s\n",
-		(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
-		(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
-		index->table_name, index->name);
-		rec_print(rec);
+		btr_cur_trx_report(thr_get_trx(thr), index, "del mark ");
+		rec_print(stderr, rec);
 	}
 
 	ut_ad(index->type & DICT_CLUSTERED);
@@ -2156,12 +2156,9 @@ btr_cur_del_mark_set_sec_rec(
 	rec = btr_cur_get_rec(cursor);
 
 	if (btr_cur_print_record_ops && thr) {
-		printf(
-	"Trx with id %lu %lu going to del mark table %s index %s\n",
-		(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
-		(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
-		cursor->index->table_name, cursor->index->name);
-		rec_print(rec);
+		btr_cur_trx_report(thr_get_trx(thr), cursor->index,
+				"del mark ");
+		rec_print(stderr, rec);
 	}
 
 	err = lock_sec_rec_modify_check_and_lock(flags, rec, cursor->index,
diff --git a/innobase/btr/btr0sea.c b/innobase/btr/btr0sea.c
index 2093d5ea757..f2b03f9f348 100644
--- a/innobase/btr/btr0sea.c
+++ b/innobase/btr/btr0sea.c
@@ -803,7 +803,7 @@ btr_search_guess_on_hash(
 
 		success = FALSE;
 /*
-		printf("Tree id %lu, page index id %lu fold %lu\n",
+		fprintf(stderr, "Tree id %lu, page index id %lu fold %lu\n",
 				ut_dulint_get_low(tree_id),
 				ut_dulint_get_low(btr_page_get_index_id(page)),
 				fold);
@@ -1517,8 +1517,9 @@ check_next_rec:
 
 			ha_insert_for_fold(table, ins_fold, ins_rec);
 /*
-			printf("Hash insert for %s, fold %lu\n",
-					cursor->index->name, ins_fold);
+			fputs("Hash insert for ", stderr);
+			dict_index_name_print(stderr, cursor->index);
+			fprintf(stderr, " fold %lu\n", ins_fold);
 */
 		} else {
 			ha_insert_for_fold(table, next_fold, next_rec);
@@ -1545,7 +1546,6 @@ btr_search_validate(void)
 	ulint		n_page_dumps	= 0;
 	ibool		ok		= TRUE;
 	ulint		i;
-	char		rec_str[500];
 	
 	rw_lock_x_lock(&btr_search_latch);
 
@@ -1566,29 +1566,25 @@ btr_search_validate(void)
 
 				fprintf(stderr,
 "  InnoDB: Error in an adaptive hash index pointer to page %lu\n"
-"ptr mem address %lu index id %lu %lu, node fold %lu, rec fold %lu\n",
-				(ulong) buf_frame_get_page_no(page),
-				(ulong)(node->data),
-			(ulong) ut_dulint_get_high(btr_page_get_index_id(page)),
-			(ulong) ut_dulint_get_low(btr_page_get_index_id(page)),
-			(ulong) node->fold,
-			(ulong) rec_fold((rec_t*)(node->data),
-					block->curr_n_fields,
-					block->curr_n_bytes,
-					btr_page_get_index_id(page)));
-
-				rec_sprintf(rec_str, 450, (rec_t*)(node->data));
-
-	  			fprintf(stderr,
-					"InnoDB: Record %s\n"
-					"InnoDB: on that page.", rec_str);
-
-				fprintf(stderr,
-"Page mem address %lu, is hashed %lu, n fields %lu, n bytes %lu\n"
+"ptr mem address %p index id %lu %lu, node fold %lu, rec fold %lu\n",
+					(ulong) buf_frame_get_page_no(page),
+					node->data,
+					(ulong) ut_dulint_get_high(btr_page_get_index_id(page)),
+					(ulong) ut_dulint_get_low(btr_page_get_index_id(page)),
+					(ulong) node->fold,
+					(ulong) rec_fold((rec_t*)(node->data),
+					  		  block->curr_n_fields,
+					  		  block->curr_n_bytes,
+					  		  btr_page_get_index_id(page)));
+
+				fputs("InnoDB: Record ", stderr);
+				rec_print(stderr, (rec_t*)(node->data));
+				fprintf(stderr, "\nInnoDB: on that page."
+"Page mem address %p, is hashed %lu, n fields %lu, n bytes %lu\n"
 "side %lu\n",
-			(ulong) page, (ulong) block->is_hashed,
-			(ulong) block->curr_n_fields,
-			(ulong) block->curr_n_bytes, (ulong) block->curr_side);
+			        page, (ulong) block->is_hashed,
+			        (ulong) block->curr_n_fields,
+			        (ulong) block->curr_n_bytes, (ulong) block->curr_side);
 
 				if (n_page_dumps < 20) {	
 					buf_page_print(page);