InnoDB: Changed interface to rec_get_offsets(), to reduce the use of

memory heaps.  This changeset plugs also a few memory leaks that
were introduced with the compact InnoDB table format.


innobase/btr/btr0btr.c:
  Changed interface to rec_get_offsets()
innobase/btr/btr0cur.c:
  Changed interface to rec_get_offsets()
innobase/btr/btr0pcur.c:
  Changed interface to rec_get_offsets()
innobase/btr/btr0sea.c:
  Changed interface to rec_get_offsets()
innobase/include/rem0rec.h:
  Changed interface to rec_get_offsets()
innobase/include/rem0rec.ic:
  Changed interface to rec_get_offsets()
innobase/lock/lock0lock.c:
  Changed interface to rec_get_offsets()
innobase/page/page0cur.c:
  Changed interface to rec_get_offsets()
innobase/page/page0page.c:
  Changed interface to rec_get_offsets()
innobase/rem/rem0rec.c:
  Changed interface to rec_get_offsets()
innobase/row/row0ins.c:
  Changed interface to rec_get_offsets()
innobase/row/row0mysql.c:
  Changed interface to rec_get_offsets()
innobase/row/row0purge.c:
  Changed interface to rec_get_offsets()
innobase/row/row0row.c:
  Changed interface to rec_get_offsets()
innobase/row/row0sel.c:
  Changed interface to rec_get_offsets()
innobase/row/row0umod.c:
  Changed interface to rec_print()
innobase/row/row0undo.c:
  Changed interface to rec_get_offsets()
innobase/row/row0upd.c:
  Changed interface to rec_get_offsets()
innobase/row/row0vers.c:
  Changed interface to rec_get_offsets()
innobase/trx/trx0rec.c:
  Changed interface to rec_get_offsets()

4 files changed, 278 insertions, 247 deletions

diff --git a/innobase/btr/btr0btr.c b/innobase/btr/btr0btr.c
index c911124e705..9da422e927f 100644
--- a/innobase/btr/btr0btr.c
+++ b/innobase/btr/btr0btr.c
@@ -567,7 +567,8 @@ btr_page_get_father_for_rec(
 	btr_cur_t	cursor;
 	rec_t*		node_ptr;
 	dict_index_t*	index;
-	ulint*		offsets;
+	ulint		offsets_[100] = { 100, };
+	ulint*		offsets	= offsets_;
 
 	ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree),
 							MTR_MEMO_X_LOCK));
@@ -591,7 +592,8 @@ btr_page_get_father_for_rec(
 				BTR_CONT_MODIFY_TREE, &cursor, 0, mtr);
 
 	node_ptr = btr_cur_get_rec(&cursor);
-	offsets = rec_get_offsets(node_ptr, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(node_ptr, index, offsets,
+						ULINT_UNDEFINED, &heap);
 
 	if (btr_node_ptr_get_child_page_no(node_ptr, offsets) !=
                                                 buf_frame_get_page_no(page)) {
@@ -609,13 +611,13 @@ btr_page_get_father_for_rec(
 			(ulong)
 			btr_node_ptr_get_child_page_no(node_ptr, offsets),
 			(ulong) buf_frame_get_page_no(page));
-		offsets = rec_reget_offsets(page_rec_get_next(
+		offsets = rec_get_offsets(page_rec_get_next(
 				page_get_infimum_rec(page)), index,
-				offsets, ULINT_UNDEFINED, heap);
+				offsets, ULINT_UNDEFINED, &heap);
 		page_rec_print(page_rec_get_next(page_get_infimum_rec(page)),
 					offsets);
-		offsets = rec_reget_offsets(node_ptr, index, offsets,
-					ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(node_ptr, index, offsets,
+					ULINT_UNDEFINED, &heap);
 		page_rec_print(node_ptr, offsets);
 
 		fputs(
@@ -1231,7 +1233,7 @@ btr_page_get_sure_split_rec(
 	ins_rec = btr_cur_get_rec(cursor);
 	rec = page_get_infimum_rec(page);
 
-	heap = mem_heap_create(100);
+	heap = NULL;
 	offsets = NULL;
 
 	/* We start to include records to the left half, and when the
@@ -1256,8 +1258,8 @@ btr_page_get_sure_split_rec(
 			/* Include tuple */
 			incl_data += insert_size;
 		} else {
-			offsets = rec_reget_offsets(rec, cursor->index,
-					offsets, ULINT_UNDEFINED, heap);
+			offsets = rec_get_offsets(rec, cursor->index,
+					offsets, ULINT_UNDEFINED, &heap);
 			incl_data += rec_offs_size(offsets);
 		}
 
@@ -1280,12 +1282,16 @@ btr_page_get_sure_split_rec(
 					next_rec = page_rec_get_next(rec);
 				}
 				if (next_rec != page_get_supremum_rec(page)) {
-					mem_heap_free(heap);
+					if (heap) {
+						mem_heap_free(heap);
+					}
 					return(next_rec);
 				}
                     	}
 
-			mem_heap_free(heap);
+			if (heap) {
+				mem_heap_free(heap);
+			}
 			return(rec);
 		}
 	}
@@ -1367,8 +1373,8 @@ btr_page_insert_fits(
 		/* In this loop we calculate the amount of reserved
 		space after rec is removed from page. */
 
-		offs = rec_reget_offsets(rec, cursor->index, offs,
-						ULINT_UNDEFINED, heap);
+		offs = rec_get_offsets(rec, cursor->index, offs,
+						ULINT_UNDEFINED, &heap);
 
 		total_data -= rec_offs_size(offs);
 		total_n_recs--;
@@ -1459,7 +1465,7 @@ btr_attach_half_pages(
 	ut_a(page_is_comp(page) == page_is_comp(new_page));
 
 	/* Create a memory heap where the data tuple is stored */
-	heap = mem_heap_create(100);
+	heap = mem_heap_create(1024);
 
 	/* Based on split direction, decide upper and lower pages */
 	if (direction == FSP_DOWN) {
@@ -1478,7 +1484,7 @@ btr_attach_half_pages(
 		btr_node_ptr_set_child_page_no(node_ptr,
 			rec_get_offsets(node_ptr,
 					UT_LIST_GET_FIRST(tree->tree_indexes),
-					ULINT_UNDEFINED, heap),
+					NULL, ULINT_UNDEFINED, &heap),
 			lower_page_no, mtr);
 		mem_heap_empty(heap);
 	} else {
@@ -1656,8 +1662,8 @@ func_start:
 	thus reducing the tree latch contention. */
 
 	if (split_rec) {
-		offsets = rec_reget_offsets(split_rec, cursor->index,
-						offsets, n_uniq, heap);
+		offsets = rec_get_offsets(split_rec, cursor->index, offsets,
+							n_uniq, &heap);
 
 		insert_will_fit = btr_page_insert_fits(cursor,
 					split_rec, offsets, tuple, heap);
@@ -1700,8 +1706,8 @@ func_start:
 		insert_page = right_page;
 
 	} else {
-		offsets = rec_reget_offsets(first_rec, cursor->index,
-						offsets, n_uniq, heap);
+		offsets = rec_get_offsets(first_rec, cursor->index,
+						offsets, n_uniq, &heap);
 
 		if (cmp_dtuple_rec(tuple, first_rec, offsets) >= 0) {
 
@@ -2091,14 +2097,18 @@ btr_compress(
 	if (is_left) {
 		btr_node_ptr_delete(tree, page, mtr);
 	} else {
-		mem_heap_t*	heap = mem_heap_create(100);
+		mem_heap_t*	heap		= NULL;
+		ulint		offsets_[100]	= { 100, };
 		/* Replace the address of the old child node (= page) with the 
 		address of the merge page to the right */
 
 		btr_node_ptr_set_child_page_no(node_ptr,
 				rec_get_offsets(node_ptr, cursor->index,
-				ULINT_UNDEFINED, heap), right_page_no, mtr);
-		mem_heap_free(heap);
+				offsets_, ULINT_UNDEFINED, &heap),
+				right_page_no, mtr);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		btr_node_ptr_delete(tree, merge_page, mtr);
 	}
 	
@@ -2312,8 +2322,8 @@ btr_print_recursive(
 	page_t*		page,	/* in: index page */
 	ulint		width,	/* in: print this many entries from start
 				and end */
-	mem_heap_t*	heap,	/* in: heap for rec_reget_offsets() */
-	ulint**		offsets,/* in/out: buffer for rec_reget_offsets() */
+	mem_heap_t**	heap,	/* in/out: heap for rec_get_offsets() */
+	ulint**		offsets,/* in/out: buffer for rec_get_offsets() */
 	mtr_t*		mtr)	/* in: mtr */
 {
 	page_cur_t	cursor;
@@ -2350,8 +2360,8 @@ btr_print_recursive(
 
 			node_ptr = page_cur_get_rec(&cursor);
 
-			*offsets = rec_reget_offsets(node_ptr, index,
-					*offsets, ULINT_UNDEFINED, heap);
+			*offsets = rec_get_offsets(node_ptr, index, *offsets,
+					ULINT_UNDEFINED, heap);
 			child = btr_node_ptr_get_child(node_ptr,
 					*offsets, &mtr2);
 			btr_print_recursive(tree, child, width,
@@ -2362,8 +2372,6 @@ btr_print_recursive(
 		page_cur_move_to_next(&cursor);
 		i++;
 	}
-
-	mem_heap_free(heap);
 }
 
 /******************************************************************
@@ -2378,8 +2386,10 @@ btr_print_tree(
 {
 	mtr_t		mtr;
 	page_t*		root;
-	mem_heap_t*	heap	= mem_heap_create(100);
-	ulint*		offsets	= NULL;
+	mem_heap_t*	heap	= NULL;
+	ulint		offsets_[100]
+				= { 100, };
+	ulint*		offsets	= offsets_;
 
 	fputs("--------------------------\n"
 		"INDEX TREE PRINT\n", stderr);
@@ -2388,8 +2398,10 @@ btr_print_tree(
 
 	root = btr_root_get(tree, &mtr);
 
-	btr_print_recursive(tree, root, width, heap, &offsets, &mtr);
-	mem_heap_free(heap);
+	btr_print_recursive(tree, root, width, &heap, &offsets, &mtr);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 
 	mtr_commit(&mtr);
 
@@ -2435,7 +2447,7 @@ btr_check_node_ptr(
 	ut_a(cmp_dtuple_rec(node_ptr_tuple, node_ptr,
 			rec_get_offsets(node_ptr,
 			dict_tree_find_index(tree, node_ptr),
-			ULINT_UNDEFINED, heap)) == 0);
+			NULL, ULINT_UNDEFINED, &heap)) == 0);
 
 	mem_heap_free(heap);
 
@@ -2476,8 +2488,10 @@ btr_index_rec_validate(
 	ulint		n;
 	ulint		i;
 	page_t*		page;
-	mem_heap_t*	heap;
-	ulint*		offsets;
+	mem_heap_t*	heap	= NULL;
+	ulint		offsets_[100]
+				= { 100, };
+	ulint*		offsets	= offsets_;
 
 	page = buf_frame_align(rec);
 	
@@ -2496,22 +2510,17 @@ btr_index_rec_validate(
 		fprintf(stderr, "InnoDB: has %lu fields, should have %lu\n",
 			(ulong) rec_get_n_fields_old(rec), (ulong) n);
 
-		if (!dump_on_error) {
+		if (dump_on_error) {
+			buf_page_print(page);
 
-			return(FALSE);
+			fputs("InnoDB: corrupt record ", stderr);
+			rec_print_old(stderr, rec);
+			putc('\n', stderr);
 		}
-
-		buf_page_print(page);
-
-		fputs("InnoDB: corrupt record ", stderr);
-		rec_print_old(stderr, rec);
-		putc('\n', stderr);
-
 		return(FALSE);
 	}
 
-	heap = mem_heap_create(100);
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
 
 	for (i = 0; i < n; i++) {
 		dtype_t*	type = dict_index_get_nth_type(index, i);
@@ -2536,23 +2545,23 @@ btr_index_rec_validate(
 "InnoDB: field %lu len is %lu, should be %lu\n",
 				(ulong) i, (ulong) len, (ulong) dtype_get_fixed_size(type));
 
-			if (!dump_on_error) {
+			if (dump_on_error) {
+				buf_page_print(page);
+
+				fputs("InnoDB: corrupt record ", stderr);
+				rec_print_new(stderr, rec, offsets);
+				putc('\n', stderr);
+			}
+			if (heap) {
 				mem_heap_free(heap);
-				return(FALSE);
 			}
-
-			buf_page_print(page);
-
-			fputs("InnoDB: corrupt record ", stderr);
-			rec_print(stderr, rec, offsets);
-			putc('\n', stderr);
-
-			mem_heap_free(heap);
 			return(FALSE);
 		}
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	return(TRUE);			
 }
 
@@ -2677,8 +2686,8 @@ btr_validate_level(
 		page_cur_move_to_next(&cursor);
 
 		node_ptr = page_cur_get_rec(&cursor);
-		offsets = rec_reget_offsets(node_ptr, index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(node_ptr, index, offsets,
+					ULINT_UNDEFINED, &heap);
 		page = btr_node_ptr_get_child(node_ptr, offsets, &mtr);
 	}
 
@@ -2722,10 +2731,10 @@ loop:
 		rec = page_rec_get_prev(page_get_supremum_rec(page));
 		right_rec = page_rec_get_next(
 					page_get_infimum_rec(right_page));
-		offsets = rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
-		offsets2 = rec_reget_offsets(right_rec, index,
-					offsets2, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(rec, index,
+					offsets, ULINT_UNDEFINED, &heap);
+		offsets2 = rec_get_offsets(right_rec, index,
+					offsets2, ULINT_UNDEFINED, &heap);
 		if (cmp_rec_rec(rec, right_rec, offsets, offsets2,
 			dict_index_get_n_fields(index),
 			index) >= 0) {
@@ -2740,16 +2749,12 @@ loop:
 
 			fputs("InnoDB: record ", stderr);
 			rec = page_rec_get_prev(page_get_supremum_rec(page));
-			offsets	= rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
-			rec_print(stderr, rec, offsets);
+			rec_print(stderr, rec, index);
 			putc('\n', stderr);
 			fputs("InnoDB: record ", stderr);
 			rec = page_rec_get_next(page_get_infimum_rec(
 						right_page));
-			offsets	= rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
-			rec_print(stderr, rec, offsets);
+			rec_print(stderr, rec, index);
 			putc('\n', stderr);
 
 	  		ret = FALSE;
@@ -2768,8 +2773,8 @@ loop:
 	
 		node_ptr = btr_page_get_father_node_ptr(tree, page, &mtr);
 		father_page = buf_frame_align(node_ptr);
-		offsets	= rec_reget_offsets(node_ptr, index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets	= rec_get_offsets(node_ptr, index,
+					offsets, ULINT_UNDEFINED, &heap);
 
 		if (btr_node_ptr_get_child_page_no(node_ptr, offsets) !=
 						buf_frame_get_page_no(page)
@@ -2785,7 +2790,7 @@ loop:
 			buf_page_print(page);
 
 			fputs("InnoDB: node ptr ", stderr);
-			rec_print(stderr, node_ptr, offsets);
+			rec_print_new(stderr, node_ptr, offsets);
 
 			fprintf(stderr, "\n"
 				"InnoDB: node ptr child page n:o %lu\n",
@@ -2796,9 +2801,7 @@ loop:
 			rec = btr_page_get_father_for_rec(tree, page,
 				page_rec_get_prev(page_get_supremum_rec(page)),
 				&mtr);
-			offsets = rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
-			rec_print(stderr, rec, offsets);
+			rec_print(stderr, rec, index);
 			putc('\n', stderr);
 		   	ret = FALSE;
 
@@ -2806,8 +2809,8 @@ loop:
 		}
 
 		if (btr_page_get_level(page, &mtr) > 0) {
-			offsets	= rec_reget_offsets(node_ptr, index,
-					offsets, ULINT_UNDEFINED, heap);
+			offsets	= rec_get_offsets(node_ptr, index,
+					offsets, ULINT_UNDEFINED, &heap);
 		
 			node_ptr_tuple = dict_tree_build_node_ptr(
 					tree,
@@ -2829,11 +2832,9 @@ loop:
 				fputs("InnoDB: Error: node ptrs differ"
 					" on levels > 0\n"
 					"InnoDB: node ptr ", stderr);
-				rec_print(stderr, node_ptr, offsets);
+				rec_print_new(stderr, node_ptr, offsets);
 				fputs("InnoDB: first rec ", stderr);
-				offsets = rec_reget_offsets(first_rec, index,
-					offsets, ULINT_UNDEFINED, heap);
-				rec_print(stderr, first_rec, offsets);
+				rec_print(stderr, first_rec, index);
 				putc('\n', stderr);
 		   		ret = FALSE;
 
diff --git a/innobase/btr/btr0cur.c b/innobase/btr/btr0cur.c
index f5e146172ed..a3083e0e545 100644
--- a/innobase/btr/btr0cur.c
+++ b/innobase/btr/btr0cur.c
@@ -274,8 +274,9 @@ btr_cur_search_to_nth_level(
 #ifdef BTR_CUR_ADAPT
 	btr_search_t*	info;
 #endif
-	mem_heap_t*	heap;
-	ulint*		offsets;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 	/* Currently, PAGE_CUR_LE is the only search mode used for searches
 	ending to upper levels */
 
@@ -395,8 +396,6 @@ btr_cur_search_to_nth_level(
 		break;
 	}
 
-	heap = mem_heap_create(100);
-	offsets = NULL;
 	/* Loop and search until we arrive at the desired level */
 
 	for (;;) {
@@ -431,7 +430,9 @@ retry_page_get:
 							cursor->thr)) {
 				/* Insertion to the insert buffer succeeded */
 				cursor->flag = BTR_CUR_INSERT_TO_IBUF;
-				mem_heap_free(heap);
+				if (heap) {
+					mem_heap_free(heap);
+				}
 				return;
 			}
 
@@ -517,13 +518,15 @@ retry_page_get:
 		guess = NULL;
 
 		node_ptr = page_cur_get_rec(page_cursor);
-		offsets = rec_reget_offsets(node_ptr, cursor->index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(node_ptr, cursor->index, offsets,
+						ULINT_UNDEFINED, &heap);
 		/* Go to the child node */
 		page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets);
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 
 	if (level == 0) {
 		cursor->low_match = low_match;
@@ -574,8 +577,9 @@ btr_cur_open_at_index_side(
 	rec_t*		node_ptr;
 	ulint		estimate;
 	ulint           savepoint;
-	mem_heap_t*	heap;
-	ulint*		offsets	= NULL;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	estimate = latch_mode & BTR_ESTIMATE;
 	latch_mode = latch_mode & ~BTR_ESTIMATE;
@@ -600,7 +604,6 @@ btr_cur_open_at_index_side(
 	page_no = dict_tree_get_page(tree);
 
 	height = ULINT_UNDEFINED;
-	heap = mem_heap_create(100);
 
 	for (;;) {
 		page = buf_page_get_gen(space, page_no, RW_NO_LATCH, NULL,
@@ -670,13 +673,15 @@ btr_cur_open_at_index_side(
 		height--;
 
 		node_ptr = page_cur_get_rec(page_cursor);
-		offsets = rec_reget_offsets(node_ptr, cursor->index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(node_ptr, cursor->index, offsets,
+						ULINT_UNDEFINED, &heap);
 		/* Go to the child node */
 		page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets);
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 }
 	
 /**************************************************************************
@@ -697,8 +702,9 @@ btr_cur_open_at_rnd_pos(
 	ulint		space;
 	ulint		height;
 	rec_t*		node_ptr;
-	mem_heap_t*	heap	= mem_heap_create(100);
-	ulint*		offsets	= NULL;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	tree = index->tree;
 	
@@ -747,13 +753,15 @@ btr_cur_open_at_rnd_pos(
 		height--;
 
 		node_ptr = page_cur_get_rec(page_cursor);
-		offsets = rec_reget_offsets(node_ptr, cursor->index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(node_ptr, cursor->index, offsets,
+						ULINT_UNDEFINED, &heap);
 		/* Go to the child node */
 		page_no = btr_node_ptr_get_child_page_no(node_ptr, offsets);
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 }	
 
 /*==================== B-TREE INSERT =========================*/
@@ -1242,11 +1250,14 @@ btr_cur_upd_lock_and_undo(
 	err = DB_SUCCESS;
 
 	if (!(flags & BTR_NO_LOCKING_FLAG)) {
-		mem_heap_t*	heap = mem_heap_create(100);
+		mem_heap_t*	heap		= NULL;
+		ulint		offsets_[100]	= { 100, };
 		err = lock_clust_rec_modify_check_and_lock(flags, rec, index,
-			rec_get_offsets(rec, index, ULINT_UNDEFINED, heap),
-			thr);
-		mem_heap_free(heap);
+			rec_get_offsets(rec, index, offsets_,
+				ULINT_UNDEFINED, &heap), thr);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		if (err != DB_SUCCESS) {
 
 			return(err);
@@ -1374,7 +1385,7 @@ btr_cur_parse_update_in_place(
 	/* We do not need to reserve btr_search_latch, as the page is only
 	being recovered, and there cannot be a hash index to it. */
 
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap);
 
 	if (!(flags & BTR_KEEP_SYS_FLAG)) {
 		row_upd_rec_sys_fields_in_recovery(rec, offsets,
@@ -1413,18 +1424,19 @@ btr_cur_update_in_place(
 	dulint		roll_ptr	= ut_dulint_zero;
 	trx_t*		trx;
 	ibool		was_delete_marked;
-	mem_heap_t*	heap;
-	const ulint*	offsets;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	rec = btr_cur_get_rec(cursor);
 	index = cursor->index;
 	trx = thr_get_trx(thr);
 	heap = mem_heap_create(100);
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
 
 	if (btr_cur_print_record_ops && thr) {
 		btr_cur_trx_report(trx, index, "update ");
-		rec_print(stderr, rec, offsets);
+		rec_print_new(stderr, rec, offsets);
 	}
 
 	/* Do lock checking and undo logging */
@@ -1432,7 +1444,9 @@ btr_cur_update_in_place(
 							thr, &roll_ptr);
 	if (err != DB_SUCCESS) {
 
-		mem_heap_free(heap);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		return(err);
 	}
 
@@ -1477,7 +1491,9 @@ btr_cur_update_in_place(
 		btr_cur_unmark_extern_fields(rec, mtr, offsets);
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	return(DB_SUCCESS);
 }
 
@@ -1526,11 +1542,11 @@ btr_cur_optimistic_update(
 	index = cursor->index;
 	
 	heap = mem_heap_create(1024);
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap);
 
 	if (btr_cur_print_record_ops && thr) {
 		btr_cur_trx_report(thr_get_trx(thr), index, "update ");
-		rec_print(stderr, rec, offsets);
+		rec_print_new(stderr, rec, offsets);
 	}
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@@ -1646,8 +1662,8 @@ btr_cur_optimistic_update(
 		/* The new inserted record owns its possible externally
 		stored fields */
 
-		offsets = rec_reget_offsets(rec, index,
-				offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(rec, index, offsets,
+						ULINT_UNDEFINED, &heap);
 		btr_cur_unmark_extern_fields(rec, mtr, offsets);
 	}
 
@@ -1801,7 +1817,7 @@ btr_cur_pessimistic_update(
 	}
 	
 	heap = mem_heap_create(1024);
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap);
 
 	trx = thr_get_trx(thr);
 	
@@ -1836,8 +1852,8 @@ btr_cur_pessimistic_update(
 	ext_vect = mem_heap_alloc(heap, sizeof(ulint)
 					* dict_index_get_n_fields(index));
 	ut_ad(!cursor->index->table->comp || !rec_get_node_ptr_flag(rec));
-	offsets = rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, offsets,
+					ULINT_UNDEFINED, &heap);
 	n_ext_vect = btr_push_update_extern_fields(ext_vect, offsets, update);
 
 	if (rec_get_converted_size(index, new_entry) >=
@@ -1877,8 +1893,8 @@ btr_cur_pessimistic_update(
 	ut_a(rec || optim_err != DB_UNDERFLOW);
 
 	if (rec) {
-		offsets = rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
+		offsets = rec_get_offsets(rec, index, offsets,
+					ULINT_UNDEFINED, &heap);
 
 		lock_rec_restore_from_page_infimum(rec, page);
 		rec_set_field_extern_bits(rec, index,
@@ -1918,8 +1934,7 @@ btr_cur_pessimistic_update(
 	ut_a(dummy_big_rec == NULL);
 
 	rec_set_field_extern_bits(rec, index, ext_vect, n_ext_vect, mtr);
-	offsets = rec_reget_offsets(rec, index,
-					offsets, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
 
 	if (!rec_get_deleted_flag(rec, rec_offs_comp(offsets))) {
 		/* The new inserted record owns its possible externally
@@ -2048,12 +2063,15 @@ btr_cur_parse_del_mark_set_clust_rec(
 		rec = page + offset;
 	
 		if (!(flags & BTR_KEEP_SYS_FLAG)) {
-			mem_heap_t*	heap = mem_heap_create(100);
+			mem_heap_t*	heap		= NULL;
+			ulint		offsets_[100]	= { 100, };
 			row_upd_rec_sys_fields_in_recovery(rec,
-					rec_get_offsets(rec, index,
-					ULINT_UNDEFINED, heap),
+					rec_get_offsets(rec, index, offsets_,
+					ULINT_UNDEFINED, &heap),
 					pos, trx_id, roll_ptr);
-			mem_heap_free(heap);
+			if (heap) {
+				mem_heap_free(heap);
+			}
 		}
 
 		/* We do not need to reserve btr_search_latch, as the page
@@ -2089,17 +2107,17 @@ btr_cur_del_mark_set_clust_rec(
 	ulint		err;
 	rec_t*		rec;
 	trx_t*		trx;
-	mem_heap_t*	heap;
-	const ulint*	offsets;
-	
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
+
 	rec = btr_cur_get_rec(cursor);
 	index = cursor->index;
-	heap = mem_heap_create(100);
-	offsets = rec_get_offsets(rec, index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
 
 	if (btr_cur_print_record_ops && thr) {
 		btr_cur_trx_report(thr_get_trx(thr), index, "del mark ");
-		rec_print(stderr, rec, offsets);
+		rec_print_new(stderr, rec, offsets);
 	}
 
 	ut_ad(index->type & DICT_CLUSTERED);
@@ -2110,7 +2128,9 @@ btr_cur_del_mark_set_clust_rec(
 
 	if (err != DB_SUCCESS) {
 
-		mem_heap_free(heap);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		return(err);
 	}
 
@@ -2119,7 +2139,9 @@ btr_cur_del_mark_set_clust_rec(
 						&roll_ptr);
 	if (err != DB_SUCCESS) {
 
-		mem_heap_free(heap);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		return(err);
 	}
 
@@ -2143,7 +2165,9 @@ btr_cur_del_mark_set_clust_rec(
 
 	btr_cur_del_mark_set_clust_rec_log(flags, rec, index, val, trx,
 							roll_ptr, mtr);
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	return(DB_SUCCESS);
 }
 
@@ -2246,12 +2270,9 @@ btr_cur_del_mark_set_sec_rec(
 	rec = btr_cur_get_rec(cursor);
 
 	if (btr_cur_print_record_ops && thr) {
-		mem_heap_t*	heap = mem_heap_create(100);
 		btr_cur_trx_report(thr_get_trx(thr), cursor->index,
 				"del mark ");
-		rec_print(stderr, rec, rec_get_offsets(rec, cursor->index,
-						ULINT_UNDEFINED, heap));
-		mem_heap_free(heap);
+		rec_print(stderr, rec, cursor->index);
 	}
 
 	err = lock_sec_rec_modify_check_and_lock(flags, rec, cursor->index,
@@ -2375,9 +2396,10 @@ btr_cur_optimistic_delete(
 {
 	page_t*		page;
 	ulint		max_ins_size;
-	mem_heap_t*	heap;
 	rec_t*		rec;
-	const ulint*	offsets;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_page(cursor)),
 							MTR_MEMO_PAGE_X_FIX));
@@ -2387,9 +2409,9 @@ btr_cur_optimistic_delete(
 	
 	ut_ad(btr_page_get_level(page, mtr) == 0);
 
-	heap = mem_heap_create(100);
 	rec = btr_cur_get_rec(cursor);
-	offsets = rec_get_offsets(rec, cursor->index, ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(rec, cursor->index, offsets,
+					ULINT_UNDEFINED, &heap);
 
 	if (!rec_offs_any_extern(offsets)
 			&& btr_cur_can_delete_without_compress(
@@ -2406,11 +2428,15 @@ btr_cur_optimistic_delete(
 
 		ibuf_update_free_bits_low(cursor->index, page, max_ins_size,
 									mtr);
-		mem_heap_free(heap);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 		return(TRUE);
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	return(FALSE);
 }
 
@@ -2487,8 +2513,9 @@ btr_cur_pessimistic_delete(
 			: !rec_get_1byte_offs_flag(rec)) {
 		btr_rec_free_externally_stored_fields(cursor->index,
 			rec, rec_get_offsets(rec, cursor->index,
-					ULINT_UNDEFINED, heap),
+					NULL, ULINT_UNDEFINED, &heap),
 			in_rollback, mtr);
+		mem_heap_empty(heap);
 	}
 
 	if ((page_get_n_recs(page) < 2)
@@ -2772,13 +2799,14 @@ btr_estimate_number_of_different_key_vals(
 	ulint		j;
 	ulint		add_on;
 	mtr_t		mtr;
-	mem_heap_t*	heap;
-	ulint*		offsets1 = 0;
-	ulint*		offsets2 = 0;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets1_[100]	= { 100, };
+	ulint		offsets2_[100]	= { 100, };
+	ulint*		offsets1	= offsets1_;
+	ulint*		offsets2	= offsets2_;
 
 	n_cols = dict_index_get_n_unique(index);
 
-	heap = mem_heap_create(100);
 	n_diff = mem_alloc((n_cols + 1) * sizeof(ib_longlong));
 
 	for (j = 0; j <= n_cols; j++) {
@@ -2813,10 +2841,10 @@ btr_estimate_number_of_different_key_vals(
 			rec_t*	next_rec = page_rec_get_next(rec);
 			matched_fields = 0;
 			matched_bytes = 0;
-			offsets1 = rec_reget_offsets(rec, index,
-					offsets1, ULINT_UNDEFINED, heap);
-			offsets2 = rec_reget_offsets(next_rec, index,
-						offsets2, n_cols, heap);
+			offsets1 = rec_get_offsets(rec, index, offsets1,
+						ULINT_UNDEFINED, &heap);
+			offsets2 = rec_get_offsets(next_rec, index, offsets2,
+						n_cols, &heap);
 
 			cmp_rec_rec_with_match(rec, next_rec,
 						offsets1, offsets2,
@@ -2856,8 +2884,8 @@ btr_estimate_number_of_different_key_vals(
 			}
 		}
 
-		offsets1 = rec_reget_offsets(rec, index,
-					offsets1, ULINT_UNDEFINED, heap);
+		offsets1 = rec_get_offsets(rec, index, offsets1,
+						ULINT_UNDEFINED, &heap);
 		total_external_size +=
 				btr_rec_get_externally_stored_len(rec,
 								offsets1);
@@ -2901,7 +2929,9 @@ btr_estimate_number_of_different_key_vals(
 	}
 		
 	mem_free(n_diff);
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 }
 
 /*================== EXTERNAL STORAGE OF BIG FIELDS ===================*/
diff --git a/innobase/btr/btr0pcur.c b/innobase/btr/btr0pcur.c
index 7df8e53cd07..ad7613e0655 100644
--- a/innobase/btr/btr0pcur.c
+++ b/innobase/btr/btr0pcur.c
@@ -262,9 +262,10 @@ btr_pcur_restore_position(
 
 				heap = mem_heap_create(256);
 				offsets1 = rec_get_offsets(cursor->old_rec,
-						index, ULINT_UNDEFINED, heap);
-				offsets2 = rec_get_offsets(rec,
-						index, ULINT_UNDEFINED, heap);
+						index, NULL,
+						cursor->old_n_fields, &heap);
+				offsets2 = rec_get_offsets(rec, index, NULL,
+						cursor->old_n_fields, &heap);
 
 				ut_ad(cmp_rec_rec(cursor->old_rec,
 					rec, offsets1, offsets2,
@@ -310,7 +311,7 @@ btr_pcur_restore_position(
 	    && 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,
-				ULINT_UNDEFINED, heap))) {
+				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
diff --git a/innobase/btr/btr0sea.c b/innobase/btr/btr0sea.c
index c18fa9a923d..dc712f650e7 100644
--- a/innobase/btr/btr0sea.c
+++ b/innobase/btr/btr0sea.c
@@ -419,7 +419,9 @@ btr_search_update_hash_ref(
 	    && (block->curr_n_fields == info->n_fields)
 	    && (block->curr_n_bytes == info->n_bytes)
 	    && (block->curr_side == info->side)) {
-		mem_heap_t*	heap;
+		mem_heap_t*	heap		= NULL;
+		ulint		offsets_[100]	= { 100, };
+
 	    	rec = btr_cur_get_rec(cursor);
 
 	    	if (!page_rec_is_user_rec(rec)) {
@@ -428,11 +430,13 @@ btr_search_update_hash_ref(
 	    	}
 	    
 		tree_id = ((cursor->index)->tree)->id;
-		heap = mem_heap_create(100);
 		fold = rec_fold(rec, rec_get_offsets(rec, cursor->index,
-				ULINT_UNDEFINED, heap), block->curr_n_fields,
+				offsets_, ULINT_UNDEFINED, &heap),
+				block->curr_n_fields,
 				block->curr_n_bytes, tree_id);
-		mem_heap_free(heap);
+		if (heap) {
+			mem_heap_free(heap);
+		}
 #ifdef UNIV_SYNC_DEBUG
 		ut_ad(rw_lock_own(&btr_search_latch, RW_LOCK_EX));
 #endif /* UNIV_SYNC_DEBUG */
@@ -547,8 +551,10 @@ btr_search_check_guess(
 	ulint		match;
 	ulint		bytes;
 	int		cmp;
-	mem_heap_t*	heap	= mem_heap_create(100);
-	ulint*		offsets	= NULL;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
+	ibool		success		= FALSE;
 
 	n_unique = dict_index_get_n_unique_in_tree(cursor->index);
 	
@@ -560,47 +566,43 @@ btr_search_check_guess(
 	match = 0;
 	bytes = 0;
 
-	offsets = rec_get_offsets(rec, cursor->index, n_unique, heap);
+	offsets = rec_get_offsets(rec, cursor->index, offsets,
+						n_unique, &heap);
 	cmp = page_cmp_dtuple_rec_with_match(tuple, rec,
 						offsets, &match, &bytes);
 
 	if (mode == PAGE_CUR_GE) {
 		if (cmp == 1) {
-			mem_heap_free(heap);
-			return(FALSE);
+			goto exit_func;
 		}
 
 		cursor->up_match = match;
 
 		if (match >= n_unique) {
-			mem_heap_free(heap);
-			return(TRUE);
+			success = TRUE;
+			goto exit_func;
 		}	
 	} else if (mode == PAGE_CUR_LE) {
 		if (cmp == -1) {
-			mem_heap_free(heap);
-			return(FALSE);
+			goto exit_func;
 		}
 
 		cursor->low_match = match;
 
 	} else if (mode == PAGE_CUR_G) {
 		if (cmp != -1) {
-			mem_heap_free(heap);
-			return(FALSE);
+			goto exit_func;
 		}
 	} else if (mode == PAGE_CUR_L) {
 		if (cmp != 1) {
-			mem_heap_free(heap);
-			return(FALSE);
+			goto exit_func;
 		}
 	}
 
 	if (can_only_compare_to_cursor_rec) {
 	        /* Since we could not determine if our guess is right just by
 	        looking at the record under the cursor, return FALSE */
-		mem_heap_free(heap);
-	        return(FALSE);
+		goto exit_func;
 	}
 
 	match = 0;
@@ -613,28 +615,21 @@ btr_search_check_guess(
 		prev_rec = page_rec_get_prev(rec);
 
 		if (prev_rec == page_get_infimum_rec(page)) {
-			mem_heap_free(heap);
-	    		return(btr_page_get_prev(page, mtr) == FIL_NULL);
+			success = btr_page_get_prev(page, mtr) == FIL_NULL;
+			goto exit_func;
 		}
 
-		offsets = rec_reget_offsets(prev_rec, cursor->index,
-						offsets, n_unique, heap);
+		offsets = rec_get_offsets(prev_rec, cursor->index, offsets,
+						n_unique, &heap);
 		cmp = page_cmp_dtuple_rec_with_match(tuple, prev_rec,
 					offsets, &match, &bytes);
-		mem_heap_free(heap);
 		if (mode == PAGE_CUR_GE) {
-			if (cmp != 1) {
-
-				return(FALSE);
-			}
+			success = cmp == 1;
 		} else {
-			if (cmp == -1) {
-
-				return(FALSE);
-			}
+			success = cmp != -1;
 		}
 
-		return(TRUE);
+		goto exit_func;
 	}
 		
 	ut_ad(rec != page_get_supremum_rec(page));
@@ -642,39 +637,30 @@ btr_search_check_guess(
 	next_rec = page_rec_get_next(rec);
 
 	if (next_rec == page_get_supremum_rec(page)) {
-		mem_heap_free(heap);
-
     		if (btr_page_get_next(page, mtr) == FIL_NULL) {
 
 			cursor->up_match = 0;
-
-			return(TRUE);
+			success = TRUE;
 		}
 
-		return(FALSE);
+		goto exit_func;
 	}
 
-	offsets = rec_reget_offsets(next_rec, cursor->index,
-						offsets, n_unique, heap);
+	offsets = rec_get_offsets(next_rec, cursor->index, offsets,
+						n_unique, &heap);
 	cmp = page_cmp_dtuple_rec_with_match(tuple, next_rec,
 					offsets, &match, &bytes);
-	mem_heap_free(heap);
-
 	if (mode == PAGE_CUR_LE) {
-		if (cmp != -1) {
-
-			return(FALSE);
-		}
-
+		success = cmp == -1;
 		cursor->up_match = match;
 	} else {
-		if (cmp == 1) {
-
-			return(FALSE);
-		}
+		success = cmp != 1;
 	}
-
-	return(TRUE);
+exit_func:
+	if (heap) {
+		mem_heap_free(heap);
+	}
+	return(success);
 }
 
 /**********************************************************************
@@ -997,14 +983,14 @@ btr_search_drop_page_hash_index(
 	
 	prev_fold = 0;
 
-	heap = mem_heap_create(100);
+	heap = NULL;
 	offsets = NULL;
 
 	while (rec != sup) {
 		/* FIXME: in a mixed tree, not all records may have enough
 		ordering fields: */
-		offsets = rec_reget_offsets(rec, block->index,
-				offsets, n_fields + (n_bytes > 0), heap);
+		offsets = rec_get_offsets(rec, block->index,
+				offsets, n_fields + (n_bytes > 0), &heap);
 		fold = rec_fold(rec, offsets, n_fields, n_bytes, tree_id);
 
 		if (fold == prev_fold && prev_fold != 0) {
@@ -1022,7 +1008,9 @@ next_rec:
 		prev_fold = fold;
 	}
 
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 
 	rw_lock_x_lock(&btr_search_latch);
 
@@ -1109,8 +1097,9 @@ btr_search_build_page_hash_index(
 	ulint*		folds;
 	rec_t**		recs;
 	ulint		i;
-	mem_heap_t*	heap;
-	ulint*		offsets;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	ut_ad(index);
 
@@ -1161,7 +1150,6 @@ btr_search_build_page_hash_index(
 
 	folds = mem_alloc(n_recs * sizeof(ulint));
 	recs = mem_alloc(n_recs * sizeof(rec_t*));
-	heap = mem_heap_create(100);
 
 	n_cached = 0;
 
@@ -1172,7 +1160,8 @@ btr_search_build_page_hash_index(
 	rec = page_get_infimum_rec(page);
 	rec = page_rec_get_next(rec);
 
-	offsets = rec_get_offsets(rec, index, n_fields + (n_bytes > 0), heap);
+	offsets = rec_get_offsets(rec, index, offsets,
+					n_fields + (n_bytes > 0), &heap);
 
 	if (rec != sup) {
 		ut_a(n_fields <= rec_offs_n_fields(offsets));
@@ -1208,8 +1197,8 @@ btr_search_build_page_hash_index(
 		 	break;
 		}
 
-		offsets = rec_reget_offsets(next_rec, index,
-				offsets, n_fields + (n_bytes > 0), heap);
+		offsets = rec_get_offsets(next_rec, index, offsets,
+					n_fields + (n_bytes > 0), &heap);
 		next_fold = rec_fold(next_rec, offsets, n_fields,
 						n_bytes, tree_id);
 
@@ -1260,7 +1249,9 @@ exit_func:
 
 	mem_free(folds);
 	mem_free(recs);
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 }
 
 /************************************************************************
@@ -1350,7 +1341,8 @@ btr_search_update_hash_on_delete(
 	ulint		fold;
 	dulint		tree_id;
 	ibool		found;
-	mem_heap_t*	heap;
+	ulint		offsets_[100]	= { 100, };
+	mem_heap_t*	heap		= NULL;
 
 	rec = btr_cur_get_rec(cursor);
 
@@ -1371,11 +1363,12 @@ btr_search_update_hash_on_delete(
 	table = btr_search_sys->hash_index;
 
 	tree_id = cursor->index->tree->id;
-	heap = mem_heap_create(100);
-	fold = rec_fold(rec, rec_get_offsets(rec, cursor->index,
-				ULINT_UNDEFINED, heap), block->curr_n_fields,
+	fold = rec_fold(rec, rec_get_offsets(rec, cursor->index, offsets_,
+				ULINT_UNDEFINED, &heap), block->curr_n_fields,
 				block->curr_n_bytes, tree_id);
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	rw_lock_x_lock(&btr_search_latch);
 
 	found = ha_search_and_delete_if_found(table, fold, rec);
@@ -1457,9 +1450,10 @@ btr_search_update_hash_on_insert(
 	ulint		n_fields;
 	ulint		n_bytes;
 	ulint		side;
-	ibool		locked	= FALSE;
-	mem_heap_t*	heap;
-	ulint*		offsets;
+	ibool		locked		= FALSE;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 
 	table = btr_search_sys->hash_index;
 
@@ -1490,21 +1484,20 @@ btr_search_update_hash_on_insert(
 	next_rec = page_rec_get_next(ins_rec);
 
 	page = buf_frame_align(rec);
-	heap = mem_heap_create(100);
-	offsets = rec_get_offsets(ins_rec, cursor->index,
-					ULINT_UNDEFINED, heap);
+	offsets = rec_get_offsets(ins_rec, cursor->index, offsets,
+					ULINT_UNDEFINED, &heap);
 	ins_fold = rec_fold(ins_rec, offsets, n_fields, n_bytes, tree_id);
 
 	if (next_rec != page_get_supremum_rec(page)) {
-		offsets = rec_reget_offsets(next_rec, cursor->index,
-				offsets, n_fields + (n_bytes > 0), heap);
+		offsets = rec_get_offsets(next_rec, cursor->index, offsets,
+					n_fields + (n_bytes > 0), &heap);
 		next_fold = rec_fold(next_rec, offsets, n_fields,
 							n_bytes, tree_id);
 	}
 
 	if (rec != page_get_infimum_rec(page)) {
-		offsets = rec_reget_offsets(rec, cursor->index,
-				offsets, n_fields + (n_bytes > 0), heap);
+		offsets = rec_get_offsets(rec, cursor->index, offsets,
+					n_fields + (n_bytes > 0), &heap);
 		fold = rec_fold(rec, offsets, n_fields, n_bytes, tree_id);
 	} else {
 		if (side == BTR_SEARCH_LEFT_SIDE) {
@@ -1575,7 +1568,9 @@ check_next_rec:
 	}	
 		
 function_exit:
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 	if (locked) {
 		rw_lock_x_unlock(&btr_search_latch);
 	}
@@ -1595,8 +1590,9 @@ btr_search_validate(void)
 	ulint		n_page_dumps	= 0;
 	ibool		ok		= TRUE;
 	ulint		i;
-	mem_heap_t*	heap		= mem_heap_create(100);
-	ulint*		offsets		= NULL;
+	mem_heap_t*	heap		= NULL;
+	ulint		offsets_[100]	= { 100, };
+	ulint*		offsets		= offsets_;
 	
 	rw_lock_x_lock(&btr_search_latch);
 
@@ -1606,10 +1602,10 @@ btr_search_validate(void)
 		while (node != NULL) {
 			block = buf_block_align(node->data);
 			page = buf_frame_align(node->data);
-			offsets = rec_reget_offsets((rec_t*) node->data,
+			offsets = rec_get_offsets((rec_t*) node->data,
 					block->index, offsets,
 					block->curr_n_fields
-					+ (block->curr_n_bytes > 0), heap);
+					+ (block->curr_n_bytes > 0), &heap);
 
 			if (!block->is_hashed
 			    || node->fold != rec_fold((rec_t*)(node->data),
@@ -1635,7 +1631,8 @@ btr_search_validate(void)
 					  		  btr_page_get_index_id(page)));
 
 				fputs("InnoDB: Record ", stderr);
-				rec_print(stderr, (rec_t*)node->data, offsets);
+				rec_print_new(stderr, (rec_t*)node->data,
+						offsets);
 				fprintf(stderr, "\nInnoDB: on that page."
 "Page mem address %p, is hashed %lu, n fields %lu, n bytes %lu\n"
 "side %lu\n",
@@ -1659,7 +1656,9 @@ btr_search_validate(void)
 	}
 
 	rw_lock_x_unlock(&btr_search_latch);
-	mem_heap_free(heap);
+	if (heap) {
+		mem_heap_free(heap);
+	}
 
 	return(ok);
 }