diff options
Diffstat (limited to 'storage/innobase/page/page0cur.cc')
| -rw-r--r-- | storage/innobase/page/page0cur.cc | 372 |
1 files changed, 188 insertions, 184 deletions
diff --git a/storage/innobase/page/page0cur.cc b/storage/innobase/page/page0cur.cc index 2327d11f1fa..b4775d19e1d 100644 --- a/storage/innobase/page/page0cur.cc +++ b/storage/innobase/page/page0cur.cc @@ -359,19 +359,15 @@ page_cur_search_with_match( #ifdef BTR_CUR_HASH_ADAPT if (is_leaf - && (mode == PAGE_CUR_LE) + && page_get_direction(page) == PAGE_RIGHT + && page_header_get_offs(page, PAGE_LAST_INSERT) + && mode == PAGE_CUR_LE && !dict_index_is_spatial(index) - && (page_header_get_field(page, PAGE_N_DIRECTION) > 3) - && (page_header_get_ptr(page, PAGE_LAST_INSERT)) - && (page_header_get_field(page, PAGE_DIRECTION) == PAGE_RIGHT)) { - - if (page_cur_try_search_shortcut( - block, index, tuple, - iup_matched_fields, - ilow_matched_fields, - cursor)) { - return; - } + && page_header_get_field(page, PAGE_N_DIRECTION) > 3 + && page_cur_try_search_shortcut( + block, index, tuple, + iup_matched_fields, ilow_matched_fields, cursor)) { + return; } # ifdef PAGE_CUR_DBG if (mode == PAGE_CUR_DBG) { @@ -415,7 +411,7 @@ page_cur_search_with_match( owned by the upper limit directory slot. */ low = 0; - up = page_dir_get_n_slots(page) - 1; + up = ulint(page_dir_get_n_slots(page)) - 1; /* Perform binary search until the lower and upper limit directory slots come to the distance 1 of each other */ @@ -523,7 +519,7 @@ up_rec_match: ulint rec_info = rec_get_info_bits(mid_rec, rec_offs_comp(offsets)); ut_ad(rec_info & REC_INFO_MIN_REC_FLAG); - ut_ad(btr_page_get_prev(page, &mtr) == FIL_NULL); + ut_ad(!page_has_prev(page)); mtr_commit(&mtr); #endif @@ -601,6 +597,7 @@ page_cur_search_with_match_bytes( rec_offs_init(offsets_); ut_ad(dtuple_validate(tuple)); + ut_ad(!(tuple->info_bits & REC_INFO_MIN_REC_FLAG)); #ifdef UNIV_DEBUG # ifdef PAGE_CUR_DBG if (mode != PAGE_CUR_DBG) @@ -620,18 +617,16 @@ page_cur_search_with_match_bytes( #ifdef BTR_CUR_HASH_ADAPT if (page_is_leaf(page) - && (mode == PAGE_CUR_LE) - && (page_header_get_field(page, PAGE_N_DIRECTION) > 3) - && (page_header_get_ptr(page, PAGE_LAST_INSERT)) - && (page_header_get_field(page, PAGE_DIRECTION) == PAGE_RIGHT)) { - - if (page_cur_try_search_shortcut_bytes( - block, index, tuple, - iup_matched_fields, iup_matched_bytes, - ilow_matched_fields, ilow_matched_bytes, - cursor)) { - return; - } + && page_get_direction(page) == PAGE_RIGHT + && page_header_get_offs(page, PAGE_LAST_INSERT) + && mode == PAGE_CUR_LE + && page_header_get_field(page, PAGE_N_DIRECTION) > 3 + && page_cur_try_search_shortcut_bytes( + block, index, tuple, + iup_matched_fields, iup_matched_bytes, + ilow_matched_fields, ilow_matched_bytes, + cursor)) { + return; } # ifdef PAGE_CUR_DBG if (mode == PAGE_CUR_DBG) { @@ -662,11 +657,11 @@ page_cur_search_with_match_bytes( owned by the upper limit directory slot. */ low = 0; - up = page_dir_get_n_slots(page) - 1; + up = ulint(page_dir_get_n_slots(page)) - 1; /* Perform binary search until the lower and upper limit directory slots come to the distance 1 of each other */ - ut_d(bool is_leaf = page_is_leaf(page)); + const bool is_leaf = page_is_leaf(page); while (up - low > 1) { mid = (low + up) / 2; @@ -734,6 +729,17 @@ up_slot_match: low_matched_fields, low_matched_bytes, up_matched_fields, up_matched_bytes); + if (UNIV_UNLIKELY(rec_get_info_bits( + mid_rec, + dict_table_is_comp(index->table)) + & REC_INFO_MIN_REC_FLAG)) { + ut_ad(!page_has_prev(page_align(mid_rec))); + ut_ad(!page_rec_is_leaf(mid_rec) + || rec_is_metadata(mid_rec, index)); + cmp = 1; + goto low_rec_match; + } + offsets = rec_get_offsets( mid_rec, index, offsets_, is_leaf, dtuple_get_n_fields_cmp(tuple), &heap); @@ -767,23 +773,6 @@ up_rec_match: || mode == PAGE_CUR_LE_OR_EXTENDS #endif /* PAGE_CUR_LE_OR_EXTENDS */ ) { - if (!cmp && !cur_matched_fields) { -#ifdef UNIV_DEBUG - mtr_t mtr; - mtr_start(&mtr); - - /* We got a match, but cur_matched_fields is - 0, it must have REC_INFO_MIN_REC_FLAG */ - ulint rec_info = rec_get_info_bits(mid_rec, - rec_offs_comp(offsets)); - ut_ad(rec_info & REC_INFO_MIN_REC_FLAG); - ut_ad(btr_page_get_prev(page, &mtr) == FIL_NULL); - mtr_commit(&mtr); -#endif - - cur_matched_fields = dtuple_get_n_fields_cmp(tuple); - } - goto low_rec_match; } else { @@ -854,19 +843,19 @@ page_cur_insert_rec_write_log( const byte* log_end; ulint i; - if (dict_table_is_temporary(index->table)) { + if (index->table->is_temporary()) { mtr->set_modified(); ut_ad(mtr->get_log_mode() == MTR_LOG_NO_REDO); return; } - ut_a(rec_size < UNIV_PAGE_SIZE); - ut_ad(mtr->is_named_space(index->space)); + ut_a(rec_size < srv_page_size); + ut_ad(mtr->is_named_space(index->table->space)); ut_ad(page_align(insert_rec) == page_align(cursor_rec)); ut_ad(!page_rec_is_comp(insert_rec) == !dict_table_is_comp(index->table)); - ut_d(const bool is_leaf = page_rec_is_leaf(cursor_rec)); + const bool is_leaf = page_rec_is_leaf(cursor_rec); { mem_heap_t* heap = NULL; @@ -1003,8 +992,8 @@ need_extra_info: /* Write the mismatch index */ log_ptr += mach_write_compressed(log_ptr, i); - ut_a(i < UNIV_PAGE_SIZE); - ut_a(extra_size < UNIV_PAGE_SIZE); + ut_a(i < srv_page_size); + ut_a(extra_size < srv_page_size); } else { /* Write the record end segment length and the extra info storage flag */ @@ -1021,7 +1010,7 @@ need_extra_info: mlog_close(mtr, log_ptr + rec_size); } else { mlog_close(mtr, log_ptr); - ut_a(rec_size < UNIV_PAGE_SIZE); + ut_a(rec_size < srv_page_size); mlog_catenate_string(mtr, ins_ptr, rec_size); } } @@ -1073,7 +1062,7 @@ page_cur_parse_insert_rec( cursor_rec = page + offset; - if (offset >= UNIV_PAGE_SIZE) { + if (offset >= srv_page_size) { recv_sys->found_corrupt_log = TRUE; @@ -1088,7 +1077,7 @@ page_cur_parse_insert_rec( return(NULL); } - if (end_seg_len >= UNIV_PAGE_SIZE << 1) { + if (end_seg_len >= srv_page_size << 1) { recv_sys->found_corrupt_log = TRUE; return(NULL); @@ -1112,7 +1101,7 @@ page_cur_parse_insert_rec( return(NULL); } - ut_a(origin_offset < UNIV_PAGE_SIZE); + ut_a(origin_offset < srv_page_size); mismatch_index = mach_parse_compressed(&ptr, end_ptr); @@ -1121,7 +1110,7 @@ page_cur_parse_insert_rec( return(NULL); } - ut_a(mismatch_index < UNIV_PAGE_SIZE); + ut_a(mismatch_index < srv_page_size); } if (end_ptr < ptr + (end_seg_len >> 1)) { @@ -1140,7 +1129,7 @@ page_cur_parse_insert_rec( /* Read from the log the inserted index record end segment which differs from the cursor record */ - ut_d(bool is_leaf = page_is_leaf(page)); + const bool is_leaf = page_is_leaf(page); offsets = rec_get_offsets(cursor_rec, index, offsets, is_leaf, ULINT_UNDEFINED, &heap); @@ -1163,7 +1152,7 @@ page_cur_parse_insert_rec( /* Build the inserted record to buf */ - if (UNIV_UNLIKELY(mismatch_index >= UNIV_PAGE_SIZE)) { + if (UNIV_UNLIKELY(mismatch_index >= srv_page_size)) { ib::fatal() << "is_short " << is_short << ", " << "info_and_status_bits " << info_and_status_bits @@ -1177,15 +1166,13 @@ page_cur_parse_insert_rec( ut_memcpy(buf + mismatch_index, ptr, end_seg_len); if (page_is_comp(page)) { - /* Make rec_get_offsets() and rec_offs_make_valid() happy. */ - ut_d(rec_set_heap_no_new(buf + origin_offset, - PAGE_HEAP_NO_USER_LOW)); + rec_set_heap_no_new(buf + origin_offset, + PAGE_HEAP_NO_USER_LOW); rec_set_info_and_status_bits(buf + origin_offset, info_and_status_bits); } else { - /* Make rec_get_offsets() and rec_offs_make_valid() happy. */ - ut_d(rec_set_heap_no_old(buf + origin_offset, - PAGE_HEAP_NO_USER_LOW)); + rec_set_heap_no_old(buf + origin_offset, + PAGE_HEAP_NO_USER_LOW); rec_set_info_bits_old(buf + origin_offset, info_and_status_bits); } @@ -1214,6 +1201,50 @@ page_cur_parse_insert_rec( return(const_cast<byte*>(ptr + end_seg_len)); } +/** Reset PAGE_DIRECTION and PAGE_N_DIRECTION. +@param[in,out] ptr the PAGE_DIRECTION_B field +@param[in,out] page index tree page frame +@param[in] page_zip compressed page descriptor, or NULL */ +static inline +void +page_direction_reset(byte* ptr, page_t* page, page_zip_des_t* page_zip) +{ + ut_ad(ptr == PAGE_HEADER + PAGE_DIRECTION_B + page); + page_ptr_set_direction(ptr, PAGE_NO_DIRECTION); + if (page_zip) { + page_zip_write_header(page_zip, ptr, 1, NULL); + } + ptr = PAGE_HEADER + PAGE_N_DIRECTION + page; + *reinterpret_cast<uint16_t*>(ptr) = 0; + if (page_zip) { + page_zip_write_header(page_zip, ptr, 2, NULL); + } +} + +/** Increment PAGE_N_DIRECTION. +@param[in,out] ptr the PAGE_DIRECTION_B field +@param[in,out] page index tree page frame +@param[in] page_zip compressed page descriptor, or NULL +@param[in] dir PAGE_RIGHT or PAGE_LEFT */ +static inline +void +page_direction_increment( + byte* ptr, + page_t* page, + page_zip_des_t* page_zip, + uint dir) +{ + ut_ad(ptr == PAGE_HEADER + PAGE_DIRECTION_B + page); + ut_ad(dir == PAGE_RIGHT || dir == PAGE_LEFT); + page_ptr_set_direction(ptr, dir); + if (page_zip) { + page_zip_write_header(page_zip, ptr, 1, NULL); + } + page_header_set_field( + page, page_zip, PAGE_N_DIRECTION, + 1U + page_header_get_field(page, PAGE_N_DIRECTION)); +} + /***********************************************************//** Inserts a record next to page cursor on an uncompressed page. Returns pointer to inserted record if succeed, i.e., enough @@ -1247,7 +1278,7 @@ page_cur_insert_rec_low( == (ibool) !!page_is_comp(page)); ut_ad(fil_page_index_page_check(page)); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) == index->id - || recv_recovery_is_on() + || index->is_dummy || (mtr ? mtr->is_inside_ibuf() : dict_index_is_ibuf(index))); ut_ad(!page_rec_is_supremum(current_rec)); @@ -1324,28 +1355,7 @@ use_heap: /* 3. Create the record */ insert_rec = rec_copy(insert_buf, rec, offsets); - rec_offs_make_valid(insert_rec, index, offsets); - - /* This is because assertion below is debug assertion */ -#ifdef UNIV_DEBUG - if (UNIV_UNLIKELY(current_rec == insert_rec)) { - ulint extra_len, data_len; - extra_len = rec_offs_extra_size(offsets); - data_len = rec_offs_data_size(offsets); - - fprintf(stderr, "InnoDB: Error: current_rec == insert_rec " - " extra_len " ULINTPF - " data_len " ULINTPF " insert_buf %p rec %p\n", - extra_len, data_len, insert_buf, rec); - fprintf(stderr, "InnoDB; Physical record: \n"); - rec_print(stderr, rec, index); - fprintf(stderr, "InnoDB: Inserted record: \n"); - rec_print(stderr, insert_rec, index); - fprintf(stderr, "InnoDB: Current record: \n"); - rec_print(stderr, current_rec, index); - ut_a(current_rec != insert_rec); - } -#endif /* UNIV_DEBUG */ + rec_offs_make_valid(insert_rec, index, page_is_leaf(page), offsets); /* 4. Insert the record in the linked list of records */ ut_ad(current_rec != insert_rec); @@ -1355,9 +1365,24 @@ use_heap: rec_t* next_rec = page_rec_get_next(current_rec); #ifdef UNIV_DEBUG if (page_is_comp(page)) { - ut_ad(rec_get_status(current_rec) - <= REC_STATUS_INFIMUM); - ut_ad(rec_get_status(insert_rec) < REC_STATUS_INFIMUM); + switch (rec_get_status(current_rec)) { + case REC_STATUS_ORDINARY: + case REC_STATUS_NODE_PTR: + case REC_STATUS_COLUMNS_ADDED: + case REC_STATUS_INFIMUM: + break; + case REC_STATUS_SUPREMUM: + ut_ad(!"wrong status on current_rec"); + } + switch (rec_get_status(insert_rec)) { + case REC_STATUS_ORDINARY: + case REC_STATUS_NODE_PTR: + case REC_STATUS_COLUMNS_ADDED: + break; + case REC_STATUS_INFIMUM: + case REC_STATUS_SUPREMUM: + ut_ad(!"wrong status on insert_rec"); + } ut_ad(rec_get_status(next_rec) != REC_STATUS_INFIMUM); } #endif @@ -1366,7 +1391,7 @@ use_heap: } page_header_set_field(page, NULL, PAGE_N_RECS, - 1 + page_get_n_recs(page)); + 1U + page_get_n_recs(page)); /* 5. Set the n_owned field in the inserted record to zero, and set the heap_no field */ @@ -1388,34 +1413,18 @@ use_heap: == rec_get_node_ptr_flag(insert_rec)); if (!dict_index_is_spatial(index)) { + byte* ptr = PAGE_HEADER + PAGE_DIRECTION_B + page; if (UNIV_UNLIKELY(last_insert == NULL)) { - page_header_set_field(page, NULL, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(page, NULL, PAGE_N_DIRECTION, 0); - - } else if ((last_insert == current_rec) - && (page_header_get_field(page, PAGE_DIRECTION) - != PAGE_LEFT)) { - - page_header_set_field(page, NULL, PAGE_DIRECTION, - PAGE_RIGHT); - page_header_set_field(page, NULL, PAGE_N_DIRECTION, - page_header_get_field( - page, PAGE_N_DIRECTION) + 1); - - } else if ((page_rec_get_next(insert_rec) == last_insert) - && (page_header_get_field(page, PAGE_DIRECTION) - != PAGE_RIGHT)) { - - page_header_set_field(page, NULL, PAGE_DIRECTION, - PAGE_LEFT); - page_header_set_field(page, NULL, PAGE_N_DIRECTION, - page_header_get_field( - page, PAGE_N_DIRECTION) + 1); +no_direction: + page_direction_reset(ptr, page, NULL); + } else if (last_insert == current_rec + && page_ptr_get_direction(ptr) != PAGE_LEFT) { + page_direction_increment(ptr, page, NULL, PAGE_RIGHT); + } else if (page_ptr_get_direction(ptr) != PAGE_RIGHT + && page_rec_get_next(insert_rec) == last_insert) { + page_direction_increment(ptr, page, NULL, PAGE_LEFT); } else { - page_header_set_field(page, NULL, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(page, NULL, PAGE_N_DIRECTION, 0); + goto no_direction; } } @@ -1496,9 +1505,9 @@ page_cur_insert_rec_zip( ut_ad(page_is_comp(page)); ut_ad(fil_page_index_page_check(page)); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) == index->id - || (mtr ? mtr->is_inside_ibuf() : dict_index_is_ibuf(index)) - || recv_recovery_is_on()); - + || index->is_dummy + || (mtr ? mtr->is_inside_ibuf() : dict_index_is_ibuf(index))); + ut_ad(!page_get_instant(page)); ut_ad(!page_cur_is_after_last(cursor)); #ifdef UNIV_ZIP_DEBUG ut_a(page_zip_validate(page_zip, page, index)); @@ -1616,11 +1625,13 @@ page_cur_insert_rec_zip( because the MLOG_COMP_REC_INSERT should only be logged after a successful operation. */ ut_ad(!recv_recovery_is_on()); + ut_ad(!index->is_dummy); } else if (recv_recovery_is_on()) { /* This should be followed by MLOG_ZIP_PAGE_COMPRESS_NO_DATA, which should succeed. */ - rec_offs_make_valid(insert_rec, index, offsets); + rec_offs_make_valid(insert_rec, index, + page_is_leaf(page), offsets); } else { ulint pos = page_rec_get_n_recs_before(insert_rec); ut_ad(pos > 0); @@ -1636,7 +1647,8 @@ page_cur_insert_rec_zip( level, page, index, mtr); rec_offs_make_valid( - insert_rec, index, offsets); + insert_rec, index, + page_is_leaf(page), offsets); return(insert_rec); } @@ -1679,7 +1691,8 @@ page_cur_insert_rec_zip( insert_rec = page + rec_get_next_offs( cursor->rec, TRUE); rec_offs_make_valid( - insert_rec, index, offsets); + insert_rec, index, + page_is_leaf(page), offsets); return(insert_rec); } @@ -1730,14 +1743,13 @@ too_small: /* On compressed pages, do not relocate records from the free list. If extra_size would grow, use the heap. */ - extra_size_diff - = rec_offs_extra_size(offsets) - - rec_offs_extra_size(foffsets); + extra_size_diff = lint(rec_offs_extra_size(offsets) + - rec_offs_extra_size(foffsets)); if (UNIV_UNLIKELY(extra_size_diff < 0)) { /* Add an offset to the extra_size. */ if (rec_offs_size(foffsets) - < rec_size - extra_size_diff) { + < rec_size - ulint(extra_size_diff)) { goto too_small; } @@ -1821,7 +1833,7 @@ use_heap: /* 3. Create the record */ insert_rec = rec_copy(insert_buf, rec, offsets); - rec_offs_make_valid(insert_rec, index, offsets); + rec_offs_make_valid(insert_rec, index, page_is_leaf(page), offsets); /* 4. Insert the record in the linked list of records */ ut_ad(cursor->rec != insert_rec); @@ -1840,7 +1852,7 @@ use_heap: } page_header_set_field(page, page_zip, PAGE_N_RECS, - 1 + page_get_n_recs(page)); + 1U + page_get_n_recs(page)); /* 5. Set the n_owned field in the inserted record to zero, and set the heap_no field */ @@ -1860,36 +1872,20 @@ use_heap: == rec_get_node_ptr_flag(insert_rec)); if (!dict_index_is_spatial(index)) { + byte* ptr = PAGE_HEADER + PAGE_DIRECTION_B + page; if (UNIV_UNLIKELY(last_insert == NULL)) { - page_header_set_field(page, page_zip, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(page, page_zip, - PAGE_N_DIRECTION, 0); - - } else if ((last_insert == cursor->rec) - && (page_header_get_field(page, PAGE_DIRECTION) - != PAGE_LEFT)) { - - page_header_set_field(page, page_zip, PAGE_DIRECTION, - PAGE_RIGHT); - page_header_set_field(page, page_zip, PAGE_N_DIRECTION, - page_header_get_field( - page, PAGE_N_DIRECTION) + 1); - - } else if ((page_rec_get_next(insert_rec) == last_insert) - && (page_header_get_field(page, PAGE_DIRECTION) - != PAGE_RIGHT)) { - - page_header_set_field(page, page_zip, PAGE_DIRECTION, - PAGE_LEFT); - page_header_set_field(page, page_zip, PAGE_N_DIRECTION, - page_header_get_field( - page, PAGE_N_DIRECTION) + 1); +no_direction: + page_direction_reset(ptr, page, page_zip); + } else if (last_insert == cursor->rec + && page_ptr_get_direction(ptr) != PAGE_LEFT) { + page_direction_increment(ptr, page, page_zip, + PAGE_RIGHT); + } else if (page_ptr_get_direction(ptr) != PAGE_RIGHT + && page_rec_get_next(insert_rec) == last_insert) { + page_direction_increment(ptr, page, page_zip, + PAGE_LEFT); } else { - page_header_set_field(page, page_zip, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(page, page_zip, - PAGE_N_DIRECTION, 0); + goto no_direction; } } @@ -1940,7 +1936,7 @@ page_copy_rec_list_to_created_page_write_log( byte* log_ptr; ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table)); - ut_ad(mtr->is_named_space(index->space)); + ut_ad(mtr->is_named_space(index->table->space)); log_ptr = mlog_open_and_write_index(mtr, page, index, page_is_comp(page) @@ -1970,6 +1966,8 @@ page_parse_copy_rec_list_to_created_page( page_t* page; page_zip_des_t* page_zip; + ut_ad(index->is_dummy); + if (ptr + 4 > end_ptr) { return(NULL); @@ -1990,6 +1988,13 @@ page_parse_copy_rec_list_to_created_page( return(rec_end); } + /* This function is never invoked on the clustered index root page, + except in the redo log apply of + page_copy_rec_list_end_to_created_page() which was logged by. + page_copy_rec_list_to_created_page_write_log(). + For other pages, this field must be zero-initialized. */ + ut_ad(!page_get_instant(block->frame) || page_is_root(block->frame)); + while (ptr < rec_end) { ptr = page_cur_parse_insert_rec(TRUE, ptr, end_ptr, block, index, mtr); @@ -2003,9 +2008,8 @@ page_parse_copy_rec_list_to_created_page( page_header_set_ptr(page, page_zip, PAGE_LAST_INSERT, NULL); if (!dict_index_is_spatial(index)) { - page_header_set_field(page, page_zip, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(page, page_zip, PAGE_N_DIRECTION, 0); + page_direction_reset(PAGE_HEADER + PAGE_DIRECTION_B + page, + page, page_zip); } return(rec_end); @@ -2045,6 +2049,9 @@ page_copy_rec_list_end_to_created_page( ut_ad(page_dir_get_n_heap(new_page) == PAGE_HEAP_NO_USER_LOW); ut_ad(page_align(rec) != new_page); ut_ad(page_rec_is_comp(rec) == page_is_comp(new_page)); + /* This function is never invoked on the clustered index root page, + except in btr_lift_page_up(). */ + ut_ad(!page_get_instant(new_page) || page_is_root(new_page)); if (page_rec_is_infimum(rec)) { @@ -2059,9 +2066,9 @@ page_copy_rec_list_end_to_created_page( #ifdef UNIV_DEBUG /* To pass the debug tests we have to set these dummy values in the debug version */ - page_dir_set_n_slots(new_page, NULL, UNIV_PAGE_SIZE / 2); + page_dir_set_n_slots(new_page, NULL, srv_page_size / 2); page_header_set_ptr(new_page, NULL, PAGE_HEAP_TOP, - new_page + UNIV_PAGE_SIZE - 1); + new_page + srv_page_size - 1); #endif log_ptr = page_copy_rec_list_to_created_page_write_log(new_page, index, mtr); @@ -2070,7 +2077,7 @@ page_copy_rec_list_end_to_created_page( /* Individual inserts are logged in a shorter form */ - const mtr_log_t log_mode = dict_table_is_temporary(index->table) + const mtr_log_t log_mode = index->table->is_temporary() || !index->is_readable() /* IMPORT TABLESPACE */ ? mtr_get_log_mode(mtr) : mtr_set_log_mode(mtr, MTR_LOG_SHORT_INSERTS); @@ -2085,7 +2092,7 @@ page_copy_rec_list_end_to_created_page( slot_index = 0; n_recs = 0; - ut_d(const bool is_leaf = page_is_leaf(new_page)); + const bool is_leaf = page_is_leaf(new_page); do { offsets = rec_get_offsets(rec, index, offsets, is_leaf, @@ -2126,11 +2133,11 @@ page_copy_rec_list_end_to_created_page( rec_size = rec_offs_size(offsets); - ut_ad(heap_top < new_page + UNIV_PAGE_SIZE); + ut_ad(heap_top < new_page + srv_page_size); heap_top += rec_size; - rec_offs_make_valid(insert_rec, index, offsets); + rec_offs_make_valid(insert_rec, index, is_leaf, offsets); page_cur_insert_rec_write_log(insert_rec, rec_size, prev_rec, index, mtr); prev_rec = insert_rec; @@ -2158,9 +2165,13 @@ page_copy_rec_list_end_to_created_page( mem_heap_free(heap); } + /* Restore the log mode */ + + mtr_set_log_mode(mtr, log_mode); + log_data_len = mtr->get_log()->size() - log_data_len; - ut_a(log_data_len < 100 * UNIV_PAGE_SIZE); + ut_a(log_data_len < 100U << srv_page_size_shift); if (log_ptr != NULL) { mach_write_to_4(log_ptr, log_data_len); @@ -2182,15 +2193,10 @@ page_copy_rec_list_end_to_created_page( page_dir_set_n_heap(new_page, NULL, PAGE_HEAP_NO_USER_LOW + n_recs); page_header_set_field(new_page, NULL, PAGE_N_RECS, n_recs); - page_header_set_ptr(new_page, NULL, PAGE_LAST_INSERT, NULL); - - page_header_set_field(new_page, NULL, PAGE_DIRECTION, - PAGE_NO_DIRECTION); - page_header_set_field(new_page, NULL, PAGE_N_DIRECTION, 0); - - /* Restore the log mode */ - - mtr_set_log_mode(mtr, log_mode); + *reinterpret_cast<uint16_t*>(PAGE_HEADER + PAGE_LAST_INSERT + new_page) + = 0; + page_direction_reset(PAGE_HEADER + PAGE_DIRECTION_B + new_page, + new_page, NULL); } /***********************************************************//** @@ -2206,7 +2212,7 @@ page_cur_delete_rec_write_log( byte* log_ptr; ut_ad(!!page_rec_is_comp(rec) == dict_table_is_comp(index->table)); - ut_ad(mtr->is_named_space(index->space)); + ut_ad(mtr->is_named_space(index->table->space)); log_ptr = mlog_open_and_write_index(mtr, rec, index, page_rec_is_comp(rec) @@ -2317,9 +2323,9 @@ page_cur_delete_rec( ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table)); ut_ad(fil_page_index_page_check(page)); ut_ad(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID) == index->id - || (mtr ? mtr->is_inside_ibuf() : dict_index_is_ibuf(index)) - || recv_recovery_is_on()); - ut_ad(mtr == NULL || mtr->is_named_space(index->space)); + || index->is_dummy + || (mtr ? mtr->is_inside_ibuf() : dict_index_is_ibuf(index))); + ut_ad(!mtr || mtr->is_named_space(index->table->space)); /* The record must not be the supremum or infimum record. */ ut_ad(page_rec_is_user_rec(current_rec)); @@ -2395,9 +2401,7 @@ page_cur_delete_rec( prev_rec is owned by the same slot, i.e., PAGE_DIR_SLOT_MIN_N_OWNED >= 2. */ -#if PAGE_DIR_SLOT_MIN_N_OWNED < 2 -# error "PAGE_DIR_SLOT_MIN_N_OWNED < 2" -#endif + compile_time_assert(PAGE_DIR_SLOT_MIN_N_OWNED >= 2); ut_ad(cur_n_owned > 1); if (current_rec == page_dir_slot_get_rec(cur_dir_slot)) { |