Commit aa19176e authored by unknown's avatar unknown
Browse files

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
parents e469cedf 09356a1f

sql/sql_yacc.yy

+2 −2
Original line number Diff line number Diff line
@@ -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/btr0btr.c

+211 −232

File changed.

Preview size limit exceeded, changes collapsed.

storage/innobase/btr/btr0cur.c

+88 −106
Original line number Diff line number Diff line
@@ -272,7 +272,6 @@ btr_cur_search_to_nth_level( 
				RW_S_LATCH, or 0 */

	mtr_t*		mtr)	/* in: mtr */

{

	dict_tree_t*	tree;

	page_cur_t*	page_cursor;

	page_t*		page;

	page_t*		guess;
@@ -303,7 +302,7 @@ btr_cur_search_to_nth_level( 
	ending to upper levels */



	ut_ad(level == 0 || mode == PAGE_CUR_LE);

	ut_ad(dict_tree_check_search_tuple(index->tree, tuple));

	ut_ad(dict_index_check_search_tuple(index, tuple));

	ut_ad(!(index->type & DICT_IBUF) || ibuf_inside());

	ut_ad(dtuple_check_typed(tuple));
@@ -374,23 +373,21 @@ btr_cur_search_to_nth_level( 


	savepoint = mtr_set_savepoint(mtr);



	tree = index->tree;



	if (latch_mode == BTR_MODIFY_TREE) {

		mtr_x_lock(dict_tree_get_lock(tree), mtr);

		mtr_x_lock(dict_index_get_lock(index), mtr);



	} else if (latch_mode == BTR_CONT_MODIFY_TREE) {

		/* Do nothing */

		ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree),

		ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),

					MTR_MEMO_X_LOCK));

	} else {

		mtr_s_lock(dict_tree_get_lock(tree), mtr);

		mtr_s_lock(dict_index_get_lock(index), mtr);

	}



	page_cursor = btr_cur_get_page_cur(cursor);



	space = dict_tree_get_space(tree);

	page_no = dict_tree_get_page(tree);

	space = dict_index_get_space(index);

	page_no = dict_index_get_page(index);



	up_match = 0;

	up_bytes = 0;
@@ -478,7 +475,7 @@ btr_cur_search_to_nth_level( 
			buf_page_dbg_add_level(page, SYNC_TREE_NODE);

		}

#endif

		ut_ad(0 == ut_dulint_cmp(tree->id,

		ut_ad(0 == ut_dulint_cmp(index->id,

					 btr_page_get_index_id(page)));



		if (height == ULINT_UNDEFINED) {
@@ -507,9 +504,9 @@ btr_cur_search_to_nth_level( 


				/* Release the tree s-latch */



				mtr_release_s_latch_at_savepoint

					(mtr, savepoint,

					 dict_tree_get_lock(tree));

				mtr_release_s_latch_at_savepoint(

					mtr, savepoint,

					dict_index_get_lock(index));

			}



			page_mode = mode;
@@ -525,8 +522,8 @@ btr_cur_search_to_nth_level( 


		/* If this is the desired level, leave the loop */



		ut_ad(height == btr_page_get_level

		      (page_cur_get_page(page_cursor), mtr));

		ut_ad(height == btr_page_get_level(

			      page_cur_get_page(page_cursor), mtr));



		if (level == height) {
@@ -598,7 +595,6 @@ btr_cur_open_at_index_side( 
	mtr_t*		mtr)		/* in: mtr */

{

	page_cur_t*	page_cursor;

	dict_tree_t*	tree;

	page_t*		page;

	ulint		page_no;

	ulint		space;
@@ -615,24 +611,22 @@ btr_cur_open_at_index_side( 
	estimate = latch_mode & BTR_ESTIMATE;

	latch_mode = latch_mode & ~BTR_ESTIMATE;



	tree = index->tree;



	/* Store the position of the tree latch we push to mtr so that we

	know how to release it when we have latched the leaf node */



	savepoint = mtr_set_savepoint(mtr);



	if (latch_mode == BTR_MODIFY_TREE) {

		mtr_x_lock(dict_tree_get_lock(tree), mtr);

		mtr_x_lock(dict_index_get_lock(index), mtr);

	} else {

		mtr_s_lock(dict_tree_get_lock(tree), mtr);

		mtr_s_lock(dict_index_get_lock(index), mtr);

	}



	page_cursor = btr_cur_get_page_cur(cursor);

	cursor->index = index;



	space = dict_tree_get_space(tree);

	page_no = dict_tree_get_page(tree);

	space = dict_index_get_space(index);

	page_no = dict_index_get_page(index);



	height = ULINT_UNDEFINED;
@@ -641,7 +635,7 @@ btr_cur_open_at_index_side( 
					BUF_GET,

					__FILE__, __LINE__,

					mtr);

		ut_ad(0 == ut_dulint_cmp(tree->id,

		ut_ad(0 == ut_dulint_cmp(index->id,

					 btr_page_get_index_id(page)));



		buf_block_align(page)->check_index_page_at_flush = TRUE;
@@ -668,9 +662,9 @@ btr_cur_open_at_index_side( 


				/* Release the tree s-latch */



				mtr_release_s_latch_at_savepoint

					(mtr, savepoint,

					 dict_tree_get_lock(tree));

				mtr_release_s_latch_at_savepoint(

					mtr, savepoint,

					dict_index_get_lock(index));

			}

		}
@@ -727,7 +721,6 @@ btr_cur_open_at_rnd_pos( 
	mtr_t*		mtr)		/* in: mtr */

{

	page_cur_t*	page_cursor;

	dict_tree_t*	tree;

	page_t*		page;

	ulint		page_no;

	ulint		space;
@@ -738,19 +731,17 @@ btr_cur_open_at_rnd_pos( 
	ulint*		offsets		= offsets_;

	*offsets_ = (sizeof offsets_) / sizeof *offsets_;



	tree = index->tree;



	if (latch_mode == BTR_MODIFY_TREE) {

		mtr_x_lock(dict_tree_get_lock(tree), mtr);

		mtr_x_lock(dict_index_get_lock(index), mtr);

	} else {

		mtr_s_lock(dict_tree_get_lock(tree), mtr);

		mtr_s_lock(dict_index_get_lock(index), mtr);

	}



	page_cursor = btr_cur_get_page_cur(cursor);

	cursor->index = index;



	space = dict_tree_get_space(tree);

	page_no = dict_tree_get_page(tree);

	space = dict_index_get_space(index);

	page_no = dict_index_get_page(index);



	height = ULINT_UNDEFINED;
@@ -759,7 +750,7 @@ btr_cur_open_at_rnd_pos( 
					BUF_GET,

					__FILE__, __LINE__,

					mtr);

		ut_ad(0 == ut_dulint_cmp(tree->id,

		ut_ad(0 == ut_dulint_cmp(index->id,

					 btr_page_get_index_id(page)));



		if (height == ULINT_UNDEFINED) {
@@ -1017,7 +1008,7 @@ btr_cur_optimistic_insert( 
	type = index->type;



	if ((type & DICT_CLUSTERED)

	    && (dict_tree_get_space_reserve(index->tree) + rec_size > max_size)

	    && (dict_index_get_space_reserve() + rec_size > max_size)

	    && (page_get_n_recs(page) >= 2)

	    && (0 == level)

	    && (btr_page_get_split_rec_to_right(cursor, &dummy_rec)
@@ -1156,7 +1147,7 @@ btr_cur_pessimistic_insert( 
	page = btr_cur_get_page(cursor);



	ut_ad(mtr_memo_contains(mtr,

				dict_tree_get_lock(btr_cur_get_tree(cursor)),

				dict_index_get_lock(btr_cur_get_index(cursor)),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),

				MTR_MEMO_PAGE_X_FIX));
@@ -1218,8 +1209,7 @@ btr_cur_pessimistic_insert( 
		}

	}



	if (dict_tree_get_page(index->tree)

	    == buf_frame_get_page_no(page)) {

	if (dict_index_get_page(index) == buf_frame_get_page_no(page)) {



		/* The page is the root page */

		*rec = btr_root_raise_and_insert(cursor, entry, mtr);
@@ -1292,8 +1282,8 @@ btr_cur_upd_lock_and_undo( 
		ulint		offsets_[REC_OFFS_NORMAL_SIZE];

		*offsets_ = (sizeof offsets_) / sizeof *offsets_;



		err = lock_clust_rec_modify_check_and_lock

			(flags, rec, index,

		err = lock_clust_rec_modify_check_and_lock(

			flags, rec, index,

			rec_get_offsets(rec, index, offsets_,

					ULINT_UNDEFINED, &heap), thr);

		if (UNIV_LIKELY_NULL(heap)) {
@@ -1328,7 +1318,7 @@ btr_cur_update_in_place_log( 
	mtr_t*		mtr)		/* in: mtr */

{

	byte*	log_ptr;

	page_t*	page	= ut_align_down(rec, UNIV_PAGE_SIZE);

	page_t*	page	= page_align(rec);

	ut_ad(flags < 256);

	ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table));
@@ -1355,7 +1345,7 @@ btr_cur_update_in_place_log( 


	log_ptr = row_upd_write_sys_vals_to_log(index, trx, roll_ptr, log_ptr,

						mtr);

	mach_write_to_2(log_ptr, ut_align_offset(rec, UNIV_PAGE_SIZE));

	mach_write_to_2(log_ptr, page_offset(rec));

	log_ptr += 2;



	row_upd_index_write_log(update, log_ptr, mtr);
@@ -1514,11 +1504,8 @@ btr_cur_update_in_place( 
		row_upd_rec_sys_fields(rec, index, offsets, trx, roll_ptr);

	}



	/* FIXME: in a mixed tree, all records may not have enough ordering

	fields for btr search: */



	was_delete_marked = rec_get_deleted_flag

		(rec, page_is_comp(buf_block_get_frame(block)));

	was_delete_marked = rec_get_deleted_flag(

		rec, page_is_comp(buf_block_get_frame(block)));



	row_upd_rec_in_place(rec, offsets, update);
@@ -1529,8 +1516,8 @@ btr_cur_update_in_place( 
	btr_cur_update_in_place_log(flags, rec, index, update, trx, roll_ptr,

				    mtr);

	if (was_delete_marked

	    && !rec_get_deleted_flag(rec, page_is_comp

				     (buf_block_get_frame(block)))) {

	    && !rec_get_deleted_flag(rec, page_is_comp(

					     buf_block_get_frame(block)))) {

		/* The new updated record owns its possible externally

		stored fields */
@@ -1801,7 +1788,6 @@ btr_cur_pessimistic_update( 
	big_rec_t*	dummy_big_rec;

	dict_index_t*	index;

	page_t*		page;

	dict_tree_t*	tree;

	rec_t*		rec;

	page_cur_t*	page_cursor;

	dtuple_t*	new_entry;
@@ -1825,9 +1811,8 @@ btr_cur_pessimistic_update( 
	page = btr_cur_get_page(cursor);

	rec = btr_cur_get_rec(cursor);

	index = cursor->index;

	tree = index->tree;



	ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree),

	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),

				MTR_MEMO_PAGE_X_FIX));
@@ -1912,8 +1897,8 @@ btr_cur_pessimistic_update( 
	n_ext_vect = btr_push_update_extern_fields(ext_vect, offsets, update);



	if (UNIV_UNLIKELY(rec_get_converted_size(index, new_entry)

			  >= ut_min(page_get_free_space_of_empty

				    (page_is_comp(page)) / 2,

			  >= ut_min(page_get_free_space_of_empty(

					    page_is_comp(page)) / 2,

				    REC_MAX_DATA_SIZE))) {



		big_rec_vec = dtuple_convert_big_rec(index, new_entry,
@@ -2064,7 +2049,7 @@ btr_cur_del_mark_set_clust_rec_log( 


	log_ptr = row_upd_write_sys_vals_to_log(index, trx, roll_ptr, log_ptr,

						mtr);

	mach_write_to_2(log_ptr, ut_align_offset(rec, UNIV_PAGE_SIZE));

	mach_write_to_2(log_ptr, page_offset(rec));

	log_ptr += 2;



	mlog_close(mtr, log_ptr);
@@ -2129,8 +2114,8 @@ btr_cur_parse_del_mark_set_clust_rec( 
			ulint		offsets_[REC_OFFS_NORMAL_SIZE];

			*offsets_ = (sizeof offsets_) / sizeof *offsets_;



			row_upd_rec_sys_fields_in_recovery

				(rec, rec_get_offsets(rec, index, offsets_,

			row_upd_rec_sys_fields_in_recovery(

				rec, rec_get_offsets(rec, index, offsets_,

						     ULINT_UNDEFINED, &heap),

				pos, trx_id, roll_ptr);

			if (UNIV_LIKELY_NULL(heap)) {
@@ -2261,12 +2246,12 @@ btr_cur_del_mark_set_sec_rec_log( 
		return;

	}



	log_ptr = mlog_write_initial_log_record_fast

		(rec, MLOG_REC_SEC_DELETE_MARK, log_ptr, mtr);

	log_ptr = mlog_write_initial_log_record_fast(

		rec, MLOG_REC_SEC_DELETE_MARK, log_ptr, mtr);

	mach_write_to_1(log_ptr, val);

	log_ptr++;



	mach_write_to_2(log_ptr, ut_align_offset(rec, UNIV_PAGE_SIZE));

	mach_write_to_2(log_ptr, page_offset(rec));

	log_ptr += 2;



	mlog_close(mtr, log_ptr);
@@ -2404,7 +2389,7 @@ btr_cur_compress( 
	mtr_t*		mtr)	/* in: mtr */

{

	ut_ad(mtr_memo_contains(mtr,

				dict_tree_get_lock(btr_cur_get_tree(cursor)),

				dict_index_get_lock(btr_cur_get_index(cursor)),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_rec(cursor)),

				MTR_MEMO_PAGE_X_FIX));
@@ -2430,7 +2415,7 @@ btr_cur_compress_if_useful( 
	mtr_t*		mtr)	/* in: mtr */

{

	ut_ad(mtr_memo_contains(mtr,

				dict_tree_get_lock(btr_cur_get_tree(cursor)),

				dict_index_get_lock(btr_cur_get_index(cursor)),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(mtr, buf_block_align(btr_cur_get_rec(cursor)),

				MTR_MEMO_PAGE_X_FIX));
@@ -2483,8 +2468,8 @@ btr_cur_optimistic_delete( 
				  ULINT_UNDEFINED, &heap);



	no_compress_needed = !rec_offs_any_extern(offsets)

		&& btr_cur_can_delete_without_compress

		(cursor, rec_offs_size(offsets), mtr);

		&& btr_cur_can_delete_without_compress(

			cursor, rec_offs_size(offsets), mtr);



	if (no_compress_needed) {
@@ -2492,8 +2477,8 @@ btr_cur_optimistic_delete( 


		btr_search_update_hash_on_delete(cursor);



		max_ins_size = page_get_max_insert_size_after_reorganize

			(page, 1);

		max_ins_size = page_get_max_insert_size_after_reorganize(

			page, 1);

		page_cur_delete_rec(btr_cur_get_page_cur(cursor),

				    cursor->index, offsets, mtr);
@@ -2537,7 +2522,7 @@ btr_cur_pessimistic_delete( 
	mtr_t*		mtr)	/* in: mtr */

{

	page_t*		page;

	dict_tree_t*	tree;

	dict_index_t*	index;

	rec_t*		rec;

	dtuple_t*	node_ptr;

	ulint		n_extents	= 0;
@@ -2549,9 +2534,9 @@ btr_cur_pessimistic_delete( 
	ulint*		offsets;



	page = btr_cur_get_page(cursor);

	tree = btr_cur_get_tree(cursor);

	index = btr_cur_get_index(cursor);



	ut_ad(mtr_memo_contains(mtr, dict_tree_get_lock(tree),

	ut_ad(mtr_memo_contains(mtr, dict_index_get_lock(index),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(mtr, buf_block_align(page),

				MTR_MEMO_PAGE_X_FIX));
@@ -2563,7 +2548,7 @@ btr_cur_pessimistic_delete( 
		n_extents = cursor->tree_height / 32 + 1;



		success = fsp_reserve_free_extents(&n_reserved,

						   cursor->index->space,

						   index->space,

						   n_extents,

						   FSP_CLEANING, mtr);

		if (!success) {
@@ -2576,8 +2561,7 @@ btr_cur_pessimistic_delete( 
	heap = mem_heap_create(1024);

	rec = btr_cur_get_rec(cursor);



	offsets = rec_get_offsets(rec, cursor->index,

				  NULL, ULINT_UNDEFINED, &heap);

	offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap);



	/* Free externally stored fields if the record is neither

	a node pointer nor in two-byte format.
@@ -2585,13 +2569,13 @@ btr_cur_pessimistic_delete( 
	if (page_is_comp(page)

	    ? !rec_get_node_ptr_flag(rec)

	    : !rec_get_1byte_offs_flag(rec)) {

		btr_rec_free_externally_stored_fields(cursor->index,

		btr_rec_free_externally_stored_fields(index,

						      rec, offsets,

						      in_rollback, mtr);

	}



	if (UNIV_UNLIKELY(page_get_n_recs(page) < 2)

	    && UNIV_UNLIKELY(dict_tree_get_page(btr_cur_get_tree(cursor))

	    && UNIV_UNLIKELY(dict_index_get_page(btr_cur_get_index(cursor))

			     != buf_frame_get_page_no(page))) {



		/* If there is only one record, drop the whole page in
@@ -2609,8 +2593,8 @@ btr_cur_pessimistic_delete( 
	level = btr_page_get_level(page, mtr);



	if (level > 0

	    && UNIV_UNLIKELY(rec == page_rec_get_next

			     (page_get_infimum_rec(page)))) {

	    && UNIV_UNLIKELY(rec == page_rec_get_next(

				     page_get_infimum_rec(page)))) {



		rec_t*	next_rec = page_rec_get_next(rec);
@@ -2628,23 +2612,22 @@ btr_cur_pessimistic_delete( 
			so that it is equal to the new leftmost node pointer

			on the page */



			btr_node_ptr_delete(tree, page, mtr);

			btr_node_ptr_delete(index, page, mtr);



			node_ptr = dict_tree_build_node_ptr

				(tree, next_rec, buf_frame_get_page_no(page),

			node_ptr = dict_index_build_node_ptr(

				index, next_rec, buf_frame_get_page_no(page),

				heap, level);



			btr_insert_on_non_leaf_level(tree,

			btr_insert_on_non_leaf_level(index,

						     level + 1, node_ptr, mtr);

		}

	}



	btr_search_update_hash_on_delete(cursor);



	page_cur_delete_rec(btr_cur_get_page_cur(cursor), cursor->index,

			    offsets, mtr);

	page_cur_delete_rec(btr_cur_get_page_cur(cursor), index, offsets, mtr);



	ut_ad(btr_check_node_ptr(tree, page, mtr));

	ut_ad(btr_check_node_ptr(index, page, mtr));



	*err = DB_SUCCESS;
@@ -2656,8 +2639,7 @@ btr_cur_pessimistic_delete( 
	}



	if (n_extents > 0) {

		fil_space_release_free_extents(cursor->index->space,

					       n_reserved);

		fil_space_release_free_extents(index->space, n_reserved);

	}



	return(ret);
@@ -2939,8 +2921,8 @@ btr_estimate_number_of_different_key_vals( 
			}



			total_external_size

				+= btr_rec_get_externally_stored_len

				(rec, offsets_rec);

				+= btr_rec_get_externally_stored_len(

					rec, offsets_rec);



			rec = next_rec;

			/* Initialize offsets_rec for the next round
@@ -2974,8 +2956,8 @@ btr_estimate_number_of_different_key_vals( 


		offsets_rec = rec_get_offsets(rec, index, offsets_rec,

					      ULINT_UNDEFINED, &heap);

		total_external_size += btr_rec_get_externally_stored_len

			(rec, offsets_rec);

		total_external_size += btr_rec_get_externally_stored_len(

			rec, offsets_rec);

		mtr_commit(&mtr);

	}
@@ -3137,8 +3119,8 @@ btr_cur_mark_extern_inherited_fields( 
			}



			if (!is_updated) {

				btr_cur_set_ownership_of_extern_field

					(rec, offsets, i, FALSE, mtr);

				btr_cur_set_ownership_of_extern_field(

					rec, offsets, i, FALSE, mtr);

			}

		}

	}
@@ -3291,8 +3273,8 @@ btr_push_update_extern_fields( 


			if (upd_get_nth_field(update, i)->extern_storage) {



				ext_vect[n_pushed] = upd_get_nth_field

					(update, i)->field_no;

				ext_vect[n_pushed] = upd_get_nth_field(

					update, i)->field_no;



				n_pushed++;

			}
@@ -3389,7 +3371,7 @@ btr_store_big_rec_extern_fields( 
	mtr_t	mtr;



	ut_ad(rec_offs_validate(rec, index, offsets));

	ut_ad(mtr_memo_contains(local_mtr, dict_tree_get_lock(index->tree),

	ut_ad(mtr_memo_contains(local_mtr, dict_index_get_lock(index),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(local_mtr, buf_block_align(rec),

				MTR_MEMO_PAGE_X_FIX));
@@ -3422,7 +3404,7 @@ btr_store_big_rec_extern_fields( 
				hint_page_no = prev_page_no + 1;

			}



			page = btr_page_alloc(index->tree, hint_page_no,

			page = btr_page_alloc(index, hint_page_no,

					      FSP_NO_DIR, 0, &mtr);

			if (page == NULL) {
@@ -3509,8 +3491,8 @@ btr_store_big_rec_extern_fields( 
				/* Set the bit denoting that this field

				in rec is stored externally */



				rec_set_nth_field_extern_bit

					(rec, index,

				rec_set_nth_field_extern_bit(

					rec, index,

					big_rec_vec->fields[i].field_no,

					TRUE, &mtr);

			}
@@ -3563,7 +3545,7 @@ btr_free_externally_stored_field( 
	mtr_t	mtr;



	ut_a(local_len >= BTR_EXTERN_FIELD_REF_SIZE);

	ut_ad(mtr_memo_contains(local_mtr, dict_tree_get_lock(index->tree),

	ut_ad(mtr_memo_contains(local_mtr, dict_index_get_lock(index),

				MTR_MEMO_X_LOCK));

	ut_ad(mtr_memo_contains(local_mtr, buf_block_align(data),

				MTR_MEMO_PAGE_X_FIX));
@@ -3635,7 +3617,7 @@ btr_free_externally_stored_field( 
		because we did not store it on the page (we save the space

		overhead from an index page header. */



		btr_page_free_low(index->tree, page, 0, &mtr);

		btr_page_free_low(index, page, 0, &mtr);



		mlog_write_ulint(data + local_len + BTR_EXTERN_PAGE_NO,

				 next_page_no,

storage/innobase/btr/btr0pcur.c

+39 −42
Original line number Diff line number Diff line
@@ -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/btr/btr0sea.c

+84 −87

File changed.

Preview size limit exceeded, changes collapsed.