34 #include "xtrabackup_api.h"
36 #ifndef UNIV_HOTBACKUP
101 #ifdef UNIV_BTR_DEBUG
107 btr_root_fseg_validate(
109 const fseg_header_t* seg_header,
139 block =
btr_block_get(space, zip_size, root_page_no, RW_X_LATCH, mtr);
142 #ifdef UNIV_BTR_DEBUG
144 const page_t* root = buf_block_get_frame(block);
166 return(buf_block_get_frame(btr_root_block_get(index, mtr)));
175 btr_get_prev_user_rec(
205 zip_size = fil_space_get_zip_size(space);
209 prev_page = buf_block_get_frame(prev_block);
211 ut_ad(mtr_memo_contains(mtr, prev_block,
213 || mtr_memo_contains(mtr, prev_block,
214 MTR_MEMO_PAGE_X_FIX));
215 #ifdef UNIV_BTR_DEBUG
233 btr_get_next_user_rec(
262 zip_size = fil_space_get_zip_size(space);
266 next_page = buf_block_get_frame(next_block);
268 ut_ad(mtr_memo_contains(mtr, next_block, MTR_MEMO_PAGE_S_FIX)
269 || mtr_memo_contains(mtr, next_block,
270 MTR_MEMO_PAGE_X_FIX));
271 #ifdef UNIV_BTR_DEBUG
296 page_t* page = buf_block_get_frame(block);
298 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
300 if (UNIV_LIKELY_NULL(page_zip)) {
305 btr_page_set_level(page, NULL, level, mtr);
310 btr_page_set_index_id(page, page_zip, index->
id, mtr);
319 btr_page_alloc_for_ibuf(
329 root = btr_root_get(index, mtr);
332 + PAGE_BTR_IBUF_FREE_LIST, mtr);
337 node_addr.
page, RW_X_LATCH, mtr);
338 new_page = buf_block_get_frame(new_block);
339 buf_block_dbg_add_level(new_block, SYNC_TREE_NODE_NEW);
341 flst_remove(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
342 new_page + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE,
344 ut_ad(flst_validate(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
366 fseg_header_t* seg_header;
373 return(btr_page_alloc_for_ibuf(index, mtr));
376 root = btr_root_get(index, mtr);
379 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
381 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
388 new_page_no = fseg_alloc_free_page_general(seg_header, hint_page_no,
389 file_direction, TRUE, mtr);
397 new_page_no, RW_X_LATCH, mtr);
398 buf_block_dbg_add_level(new_block, SYNC_TREE_NODE_NEW);
413 fseg_header_t* seg_header;
423 root = btr_root_get(index, &mtr);
425 if (flag == BTR_N_LEAF_PAGES) {
426 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
428 fseg_n_reserved_pages(seg_header, &n, &mtr);
430 }
else if (flag == BTR_TOTAL_SIZE) {
431 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
433 n = fseg_n_reserved_pages(seg_header, &dummy, &mtr);
435 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
437 n += fseg_n_reserved_pages(seg_header, &dummy, &mtr);
452 btr_page_free_for_ibuf(
460 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
461 root = btr_root_get(index, mtr);
463 flst_add_first(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
464 buf_block_get_frame(block)
465 + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST_NODE, mtr);
467 ut_ad(flst_validate(root + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST,
484 fseg_header_t* seg_header;
487 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
495 btr_page_free_for_ibuf(index, block, mtr);
500 root = btr_root_get(index, mtr);
503 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
505 seg_header = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
508 fseg_free_page(seg_header,
528 btr_page_free_low(index, block, level, mtr);
535 btr_node_ptr_set_child_page_no(
540 const ulint* offsets,
552 field = rec_get_nth_field(rec, offsets,
555 ut_ad(len == REC_NODE_PTR_SIZE);
557 if (UNIV_LIKELY_NULL(page_zip)) {
570 btr_node_ptr_get_child(
572 const rec_t* node_ptr,
574 const ulint* offsets,
585 page_no, RW_X_LATCH, mtr));
594 btr_page_get_father_node_ptr_func(
624 tuple = dict_index_build_node_ptr(index, user_rec, 0, heap, level);
626 btr_cur_search_to_nth_level(index, level + 1, tuple, PAGE_CUR_LE,
633 offsets = rec_get_offsets(node_ptr, index, offsets,
634 ULINT_UNDEFINED, &heap);
639 fputs(
"InnoDB: Dump of the child page:\n", stderr);
641 fputs(
"InnoDB: Dump of the parent page:\n", stderr);
644 fputs(
"InnoDB: Corruption of an index tree: table ", stderr);
646 fputs(
", index ", stderr);
648 fprintf(stderr,
",\n"
649 "InnoDB: father ptr page no %lu, child page no %lu\n",
655 offsets = rec_get_offsets(print_rec, index,
656 offsets, ULINT_UNDEFINED, &heap);
658 offsets = rec_get_offsets(node_ptr, index, offsets,
659 ULINT_UNDEFINED, &heap);
662 fputs(
"InnoDB: You should dump + drop + reimport the table"
664 "InnoDB: corruption. If the crash happens at "
665 "the database startup, see\n"
666 "InnoDB: " REFMAN
"forcing-recovery.html about\n"
667 "InnoDB: forcing recovery. "
668 "Then dump + drop + reimport.\n", stderr);
676 #define btr_page_get_father_node_ptr(of,heap,cur,mtr) \
677 btr_page_get_father_node_ptr_func(of,heap,cur,__FILE__,__LINE__,mtr)
685 btr_page_get_father_block(
699 return(btr_page_get_father_node_ptr(offsets, heap, cursor, mtr));
722 btr_page_get_father_node_ptr(NULL, heap, cursor, mtr);
756 IBUF_HEADER + IBUF_TREE_SEG_HEADER, mtr);
758 buf_block_dbg_add_level(ibuf_hdr_block, SYNC_TREE_NODE_NEW);
761 == IBUF_HEADER_PAGE_NO);
765 page_no = fseg_alloc_free_page(buf_block_get_frame(
768 + IBUF_TREE_SEG_HEADER,
769 IBUF_TREE_ROOT_PAGE_NO,
771 ut_ad(page_no == IBUF_TREE_ROOT_PAGE_NO);
776 block = fseg_create(space, 0,
777 PAGE_HEADER + PAGE_BTR_SEG_TOP, mtr);
786 frame = buf_block_get_frame(block);
788 buf_block_dbg_add_level(block, SYNC_TREE_NODE_NEW);
790 if (type & DICT_IBUF) {
793 ut_ad(page_no == IBUF_TREE_ROOT_PAGE_NO);
795 flst_init(frame + PAGE_HEADER + PAGE_BTR_IBUF_FREE_LIST, mtr);
799 if (!fseg_create(space, page_no,
800 PAGE_HEADER + PAGE_BTR_SEG_LEAF, mtr)) {
803 btr_free_root(space, zip_size, page_no, mtr);
810 buf_block_dbg_add_level(block, SYNC_TREE_NODE_NEW);
816 if (UNIV_LIKELY_NULL(page_zip)) {
822 btr_page_set_level(page, NULL, 0, mtr);
828 btr_page_set_index_id(page, page_zip, index_id, mtr);
831 btr_page_set_next(page, page_zip,
FIL_NULL, mtr);
832 btr_page_set_prev(page, page_zip,
FIL_NULL, mtr);
839 ibuf_reset_free_bits(block);
856 btr_free_but_not_root(
870 root =
btr_page_get(space, zip_size, root_page_no, RW_X_LATCH, &mtr);
871 #ifdef UNIV_BTR_DEBUG
881 finished = fseg_free_step(root + PAGE_HEADER + PAGE_BTR_SEG_LEAF,
892 root =
btr_page_get(space, zip_size, root_page_no, RW_X_LATCH, &mtr);
893 #ifdef UNIV_BTR_DEBUG
898 finished = fseg_free_step_not_header(
899 root + PAGE_HEADER + PAGE_BTR_SEG_TOP, &mtr);
922 fseg_header_t* header;
924 block =
btr_block_get(space, zip_size, root_page_no, RW_X_LATCH, mtr);
926 btr_search_drop_page_hash_index(block);
928 header = buf_block_get_frame(block) + PAGE_HEADER + PAGE_BTR_SEG_TOP;
929 #ifdef UNIV_BTR_DEBUG
930 ut_a(btr_root_fseg_validate(header, space));
933 while (!fseg_free_step(header, mtr)) {};
941 btr_page_reorganize_low(
953 page_t* page = buf_block_get_frame(block);
962 ibool success = FALSE;
964 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
966 #ifdef UNIV_ZIP_DEBUG
967 ut_a(!page_zip || page_zip_validate(page_zip, page));
972 #ifndef UNIV_HOTBACKUP
982 #ifndef UNIV_HOTBACKUP
983 temp_block = buf_block_alloc(buf_pool, 0);
985 ut_ad(block == back_block1);
986 temp_block = back_block2;
988 temp_page = temp_block->
frame;
993 #ifndef UNIV_HOTBACKUP
994 if (UNIV_LIKELY(!recovery)) {
995 btr_search_drop_page_hash_index(block);
1010 page_get_infimum_rec(temp_page),
1020 ut_ad(max_trx_id != 0 || recovery);
1023 if (UNIV_LIKELY_NULL(page_zip)
1029 #if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
1031 ut_a(!memcmp(page, temp_page, PAGE_HEADER));
1032 ut_a(!memcmp(PAGE_HEADER + PAGE_N_RECS + page,
1033 PAGE_HEADER + PAGE_N_RECS + temp_page,
1034 PAGE_DATA - (PAGE_HEADER + PAGE_N_RECS)));
1040 memcpy(PAGE_HEADER + page, PAGE_HEADER + temp_page,
1041 PAGE_N_RECS - PAGE_N_DIR_SLOTS);
1042 memcpy(PAGE_DATA + page, PAGE_DATA + temp_page,
1045 #if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
1046 ut_a(!memcmp(page, temp_page, UNIV_PAGE_SIZE));
1052 #ifndef UNIV_HOTBACKUP
1053 if (UNIV_LIKELY(!recovery)) {
1062 if (UNIV_UNLIKELY(data_size1 != data_size2)
1063 || UNIV_UNLIKELY(max_ins_size1 != max_ins_size2)) {
1064 buf_page_print(page, 0);
1065 buf_page_print(temp_page, 0);
1067 "InnoDB: Error: page old data size %lu"
1068 " new data size %lu\n"
1069 "InnoDB: Error: page old max ins size %lu"
1070 " new max ins size %lu\n"
1071 "InnoDB: Submit a detailed bug report"
1072 " to http://bugs.mysql.com\n",
1073 (
unsigned long) data_size1, (
unsigned long) data_size2,
1074 (
unsigned long) max_ins_size1,
1075 (
unsigned long) max_ins_size2);
1081 #ifdef UNIV_ZIP_DEBUG
1082 ut_a(!page_zip || page_zip_validate(page_zip, page));
1084 #ifndef UNIV_HOTBACKUP
1094 #ifndef UNIV_HOTBACKUP
1104 btr_page_reorganize(
1110 return(btr_page_reorganize_low(FALSE, block, index, mtr));
1119 btr_parse_page_reorganize(
1128 ut_ad(ptr && end_ptr);
1132 if (UNIV_LIKELY(block != NULL)) {
1133 btr_page_reorganize_low(TRUE, block, index, mtr);
1139 #ifndef UNIV_HOTBACKUP
1152 page_t* page = buf_block_get_frame(block);
1154 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
1156 #ifdef UNIV_ZIP_DEBUG
1157 ut_a(!page_zip || page_zip_validate(page_zip, page));
1160 btr_search_drop_page_hash_index(block);
1165 if (UNIV_LIKELY_NULL(page_zip)) {
1169 btr_page_set_level(page, NULL, level, mtr);
1184 btr_root_raise_and_insert(
1202 rec_t* node_ptr_rec;
1212 #ifdef UNIV_ZIP_DEBUG
1213 ut_a(!root_page_zip || page_zip_validate(root_page_zip, root));
1216 #ifdef UNIV_BTR_DEBUG
1230 ut_ad(mtr_memo_contains(mtr, root_block, MTR_MEMO_PAGE_X_FIX));
1238 new_block = btr_page_alloc(index, 0, FSP_NO_DIR, level, mtr);
1239 new_page = buf_block_get_frame(new_block);
1241 ut_a(!new_page_zip == !root_page_zip);
1246 btr_page_create(new_block, new_page_zip, index, level, mtr);
1249 btr_page_set_next(new_page, new_page_zip,
FIL_NULL, mtr);
1250 btr_page_set_prev(new_page, new_page_zip,
FIL_NULL, mtr);
1255 #ifdef UNIV_ZIP_COPY
1260 page_get_infimum_rec(root),
1266 root_page_zip, root, index, mtr);
1271 page_get_infimum_rec(root));
1273 btr_search_move_or_delete_hash_entries(new_block, root_block,
1293 node_ptr = dict_index_build_node_ptr(index, rec, new_page_no, heap,
1300 | REC_INFO_MIN_REC_FLAG);
1303 btr_page_empty(root_block, root_page_zip, index, level + 1, mtr);
1310 btr_page_set_next(root, root_page_zip,
FIL_NULL, mtr);
1311 btr_page_set_prev(root, root_page_zip,
FIL_NULL, mtr);
1313 page_cursor = btr_cur_get_page_cur(cursor);
1332 fprintf(stderr,
"Root raise new page no %lu\n", new_page_no);
1336 ibuf_reset_free_bits(new_block);
1341 PAGE_CUR_LE, page_cursor);
1344 return(btr_page_split_and_insert(cursor, tuple, n_ext, mtr));
1353 btr_page_get_split_rec_to_left(
1362 rec_t* insert_point;
1371 infimum = page_get_infimum_rec(page);
1378 if (infimum != insert_point
1381 *split_rec = insert_point;
1398 btr_page_get_split_rec_to_right(
1407 rec_t* insert_point;
1441 *split_rec = next_next_rec;
1458 btr_page_get_split_rec(
1485 if (UNIV_LIKELY_NULL(page_zip)) {
1491 if (UNIV_LIKELY(free_space > (ulint) free_space_zip)) {
1492 free_space = (ulint) free_space_zip;
1500 ut_ad(total_n_recs >= 2);
1506 rec = page_get_infimum_rec(page);
1520 if (rec == ins_rec) {
1523 }
else if (rec == NULL) {
1531 incl_data += insert_size;
1533 offsets = rec_get_offsets(rec, cursor->
index,
1534 offsets, ULINT_UNDEFINED,
1548 if (rec == ins_rec) {
1552 }
else if (rec == NULL) {
1564 if (UNIV_LIKELY_NULL(heap)) {
1576 btr_page_insert_fits(
1580 const rec_t* split_rec,
1583 const ulint* offsets,
1595 const rec_t* end_rec;
1600 ut_ad(!split_rec == !offsets);
1618 if (split_rec == NULL) {
1625 end_rec = split_rec;
1628 end_rec = page_get_supremum_rec(page);
1642 while (rec != end_rec) {
1646 offs = rec_get_offsets(rec, cursor->
index, offs,
1647 ULINT_UNDEFINED, &heap);
1672 btr_insert_on_non_leaf_level_func(
1688 btr_cur_search_to_nth_level(index, level, tuple, PAGE_CUR_LE,
1690 &cursor, 0, file, line, mtr);
1692 err = btr_cur_pessimistic_insert(BTR_NO_LOCKING_FLAG
1694 | BTR_NO_UNDO_LOG_FLAG,
1695 &cursor, tuple, &rec,
1696 &dummy_big_rec, 0, NULL, mtr);
1697 ut_a(err == DB_SUCCESS);
1705 btr_attach_half_pages(
1720 page_t* page = buf_block_get_frame(block);
1723 ulint lower_page_no;
1724 ulint upper_page_no;
1730 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
1731 ut_ad(mtr_memo_contains(mtr, new_block, MTR_MEMO_PAGE_X_FIX));
1737 if (direction == FSP_DOWN) {
1742 lower_page = buf_block_get_frame(new_block);
1745 upper_page = buf_block_get_frame(block);
1750 offsets = btr_page_get_father_block(NULL, heap, index,
1751 block, mtr, &cursor);
1756 btr_node_ptr_set_child_page_no(
1759 offsets, lower_page_no, mtr);
1762 lower_page = buf_block_get_frame(block);
1765 upper_page = buf_block_get_frame(new_block);
1778 node_ptr_upper = dict_index_build_node_ptr(index, split_rec,
1779 upper_page_no, heap, level);
1784 btr_insert_on_non_leaf_level(index, level + 1, node_ptr_upper, mtr);
1802 #ifdef UNIV_BTR_DEBUG
1808 btr_page_set_next(buf_block_get_frame(prev_block),
1810 lower_page_no, mtr);
1817 #ifdef UNIV_BTR_DEBUG
1823 btr_page_set_prev(buf_block_get_frame(next_block),
1825 upper_page_no, mtr);
1828 btr_page_set_prev(lower_page, lower_page_zip, prev_page_no, mtr);
1829 btr_page_set_next(lower_page, lower_page_zip, upper_page_no, mtr);
1831 btr_page_set_prev(upper_page, upper_page_zip, lower_page_no, mtr);
1832 btr_page_set_next(upper_page, upper_page_zip, next_page_no, mtr);
1840 btr_page_tuple_smaller(
1850 const rec_t* first_rec;
1857 first_rec = page_cur_get_rec(&pcur);
1859 offsets = rec_get_offsets(
1860 first_rec, cursor->
index, offsets,
1877 btr_page_split_and_insert(
1903 ibool insert_will_fit;
1905 ulint n_iterations = 0;
1919 #ifdef UNIV_SYNC_DEBUG
1924 page = buf_block_get_frame(block);
1927 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
1935 insert_left = FALSE;
1937 if (n_iterations > 0) {
1939 hint_page_no = page_no + 1;
1940 split_rec = btr_page_get_split_rec(cursor, tuple, n_ext);
1942 if (UNIV_UNLIKELY(split_rec == NULL)) {
1943 insert_left = btr_page_tuple_smaller(
1944 cursor, tuple, offsets, n_uniq, &heap);
1946 }
else if (btr_page_get_split_rec_to_right(cursor, &split_rec)) {
1948 hint_page_no = page_no + 1;
1949 }
else if (btr_page_get_split_rec_to_left(cursor, &split_rec)) {
1950 direction = FSP_DOWN;
1951 hint_page_no = page_no - 1;
1955 hint_page_no = page_no + 1;
1963 }
else if (btr_page_tuple_smaller(cursor, tuple,
1964 offsets, n_uniq, &heap)) {
1966 page_get_infimum_rec(page));
1973 new_block = btr_page_alloc(cursor->
index, hint_page_no, direction,
1975 new_page = buf_block_get_frame(new_block);
1977 btr_page_create(new_block, new_page_zip, cursor->
index,
1985 first_rec = move_limit = split_rec;
1987 offsets = rec_get_offsets(split_rec, cursor->
index, offsets,
1992 if (UNIV_UNLIKELY(!insert_left && new_page_zip
1993 && n_iterations > 0)) {
2000 }
else if (UNIV_UNLIKELY(insert_left)) {
2001 ut_a(n_iterations > 0);
2007 ut_ad(!insert_left);
2018 btr_attach_half_pages(cursor->
index, block,
2019 first_rec, new_block, direction, mtr);
2027 insert_will_fit = !new_page_zip
2028 && btr_page_insert_fits(cursor, split_rec,
2029 offsets, tuple, n_ext, heap);
2036 insert_will_fit = !new_page_zip
2037 && btr_page_insert_fits(cursor, NULL,
2038 NULL, tuple, n_ext, heap);
2048 if (direction == FSP_DOWN) {
2052 #ifdef UNIV_ZIP_COPY
2057 cursor->
index, mtr))) {
2066 page_zip, page, cursor->
index, mtr);
2068 new_block, cursor->
index,
2070 ULINT_UNDEFINED, mtr);
2075 new_block, block, move_limit,
2076 new_page + PAGE_NEW_INFIMUM);
2078 btr_search_move_or_delete_hash_entries(
2079 new_block, block, cursor->
index);
2084 cursor->
index, mtr);
2087 left_block = new_block;
2088 right_block = block;
2095 #ifdef UNIV_ZIP_COPY
2100 cursor->
index, mtr))) {
2109 page_zip, page, cursor->
index, mtr);
2111 + new_page, new_block,
2112 cursor->
index, mtr);
2118 btr_search_move_or_delete_hash_entries(
2119 new_block, block, cursor->
index);
2126 ULINT_UNDEFINED, mtr);
2130 right_block = new_block;
2135 #ifdef UNIV_ZIP_DEBUG
2136 if (UNIV_LIKELY_NULL(page_zip)) {
2137 ut_a(page_zip_validate(page_zip, page));
2138 ut_a(page_zip_validate(new_page_zip, new_page));
2149 insert_block = left_block;
2151 insert_block = right_block;
2155 page_cursor = btr_cur_get_page_cur(cursor);
2158 PAGE_CUR_LE, page_cursor);
2161 cursor->
index, n_ext, mtr);
2163 #ifdef UNIV_ZIP_DEBUG
2166 = buf_block_get_frame(insert_block);
2171 ut_a(!insert_page_zip
2172 || page_zip_validate(insert_page_zip, insert_page));
2176 if (UNIV_LIKELY(rec != NULL)) {
2184 (!btr_page_reorganize(insert_block, cursor->
index, mtr))) {
2190 PAGE_CUR_LE, page_cursor);
2194 if (UNIV_UNLIKELY(rec == NULL)) {
2200 ibuf_reset_free_bits(new_block);
2206 ut_ad(n_iterations < 2
2208 ut_ad(!insert_will_fit);
2218 ibuf_update_free_bits_for_two_pages_low(
2220 left_block, right_block, mtr);
2224 fprintf(stderr,
"Split and insert done %lu %lu\n",
2240 btr_level_list_remove(
2252 ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX));
2266 = buf_block_get_frame(prev_block);
2267 #ifdef UNIV_BTR_DEBUG
2273 btr_page_set_next(prev_page,
2283 = buf_block_get_frame(next_block);
2284 #ifdef UNIV_BTR_DEBUG
2290 btr_page_set_prev(next_page,
2301 btr_set_min_rec_mark_log(
2313 # define btr_set_min_rec_mark_log(rec,comp,mtr) ((void) 0)
2322 btr_parse_set_min_rec_mark(
2332 if (end_ptr < ptr + 2) {
2342 btr_set_min_rec_mark(rec, mtr);
2352 btr_set_min_rec_mark(
2374 #ifndef UNIV_HOTBACKUP
2379 btr_node_ptr_delete(
2389 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
2392 btr_page_get_father(index, block, mtr, &cursor);
2394 compressed = btr_cur_pessimistic_delete(&err, TRUE, &cursor,
RB_NONE,
2396 ut_a(err == DB_SUCCESS);
2399 btr_cur_compress_if_useful(&cursor, mtr);
2421 page_t* page = buf_block_get_frame(block);
2429 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
2440 offsets = btr_page_get_father_block(NULL, heap, index,
2441 block, mtr, &cursor);
2444 father_page = buf_block_get_frame(father_block);
2453 for (b = father_block;
2457 offsets = btr_page_get_father_block(offsets, heap,
2467 btr_search_drop_page_hash_index(block);
2470 btr_page_empty(father_block, father_page_zip, index, page_level, mtr);
2474 #ifdef UNIV_ZIP_COPY
2479 page_get_infimum_rec(page),
2483 ut_a(father_page_zip);
2488 page_zip, page, index, mtr);
2493 page_get_infimum_rec(page));
2495 btr_search_move_or_delete_hash_entries(father_block, block,
2502 for (i = 0; i < n_blocks; i++, page_level++) {
2503 page_t* inner_page = buf_block_get_frame(blocks[i]);
2508 btr_page_set_level(inner_page, page_zip, page_level, mtr);
2509 #ifdef UNIV_ZIP_DEBUG
2510 ut_a(!page_zip || page_zip_validate(page_zip, inner_page));
2515 btr_page_free(index, block, mtr);
2519 ibuf_reset_free_bits(father_block);
2522 ut_ad(btr_check_node_ptr(index, father_block, mtr));
2549 ulint right_page_no;
2562 ulint max_ins_size_reorg;
2571 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
2579 fprintf(stderr,
"Merge left page %lu right %lu \n",
2580 left_page_no, right_page_no);
2584 offsets = btr_page_get_father_block(NULL, heap, index, block, mtr,
2590 is_left = left_page_no !=
FIL_NULL;
2596 merge_page = buf_block_get_frame(merge_block);
2597 #ifdef UNIV_BTR_DEBUG
2601 }
else if (right_page_no !=
FIL_NULL) {
2605 merge_page = buf_block_get_frame(merge_block);
2606 #ifdef UNIV_BTR_DEBUG
2613 btr_lift_page_up(index, block, mtr);
2620 #ifdef UNIV_BTR_DEBUG
2625 merge_page, n_recs);
2626 if (data_size > max_ins_size_reorg) {
2634 ibuf_reset_free_bits(merge_block);
2645 if (UNIV_UNLIKELY(data_size > max_ins_size)) {
2649 if (UNIV_UNLIKELY(!btr_page_reorganize(merge_block,
2658 ut_ad(max_ins_size == max_ins_size_reorg);
2660 if (UNIV_UNLIKELY(data_size > max_ins_size)) {
2670 #ifdef UNIV_ZIP_DEBUG
2671 if (UNIV_LIKELY_NULL(merge_page_zip)) {
2675 ut_a(page_zip_validate(merge_page_zip, merge_page));
2676 ut_a(page_zip_validate(page_zip, page));
2683 merge_block, block, page_get_supremum_rec(page),
2686 if (UNIV_UNLIKELY(!orig_pred)) {
2690 btr_search_drop_page_hash_index(block);
2693 btr_level_list_remove(space, zip_size, page, mtr);
2695 btr_node_ptr_delete(index, block, mtr);
2699 #ifdef UNIV_BTR_DEBUG
2700 byte fil_page_prev[4];
2703 if (UNIV_LIKELY_NULL(merge_page_zip)) {
2708 #ifdef UNIV_BTR_DEBUG
2711 #if FIL_NULL != 0xffffffff
2712 # error "FIL_NULL != 0xffffffff"
2718 page_get_infimum_rec(page),
2719 cursor->
index, mtr);
2721 if (UNIV_UNLIKELY(!orig_succ)) {
2722 ut_a(merge_page_zip);
2723 #ifdef UNIV_BTR_DEBUG
2725 ut_a(!memcmp(fil_page_prev,
2731 btr_search_drop_page_hash_index(block);
2733 #ifdef UNIV_BTR_DEBUG
2734 if (UNIV_LIKELY_NULL(merge_page_zip)) {
2746 btr_level_list_remove(space, zip_size, page, mtr);
2751 btr_node_ptr_set_child_page_no(
2754 offsets, right_page_no, mtr);
2755 btr_node_ptr_delete(index, merge_block, mtr);
2791 ibuf_reset_free_bits(merge_block);
2804 #ifdef UNIV_ZIP_DEBUG
2805 ut_a(!merge_page_zip || page_zip_validate(merge_page_zip, merge_page));
2809 btr_page_free(index, block, mtr);
2811 ut_ad(btr_check_node_ptr(index, merge_block, mtr));
2822 btr_discard_only_page_on_level(
2828 ulint page_level = 0;
2837 const page_t* page = buf_block_get_frame(block);
2844 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
2845 btr_search_drop_page_hash_index(block);
2847 btr_page_get_father(index, block, mtr, &cursor);
2853 btr_page_free(index, block, mtr);
2862 #ifdef UNIV_BTR_DEBUG
2864 const page_t* root = buf_block_get_frame(block);
2877 ibuf_reset_free_bits(block);
2904 ulint right_page_no;
2917 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
2929 merge_page = buf_block_get_frame(merge_block);
2930 #ifdef UNIV_BTR_DEBUG
2934 }
else if (right_page_no !=
FIL_NULL) {
2937 merge_page = buf_block_get_frame(merge_block);
2938 #ifdef UNIV_BTR_DEBUG
2943 btr_discard_only_page_on_level(index, block, mtr);
2948 page = buf_block_get_frame(block);
2950 btr_search_drop_page_hash_index(block);
2965 btr_set_min_rec_mark(node_ptr, mtr);
2968 btr_node_ptr_delete(index, block, mtr);
2971 btr_level_list_remove(space, zip_size, page, mtr);
2972 #ifdef UNIV_ZIP_DEBUG
2976 ut_a(!merge_page_zip
2977 || page_zip_validate(merge_page_zip, merge_page));
2991 btr_page_free(index, block, mtr);
2993 ut_ad(btr_check_node_ptr(index, merge_block, mtr));
2996 #ifdef UNIV_BTR_PRINT
3010 fputs(
"Sorry, cannot print info of an ibuf tree:"
3011 " use ibuf functions\n", stderr);
3018 root = btr_root_get(index, &mtr);
3020 seg = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
3022 fputs(
"INFO OF THE NON-LEAF PAGE SEGMENT\n", stderr);
3023 fseg_print(seg, &mtr);
3027 seg = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
3029 fputs(
"INFO OF THE LEAF PAGE SEGMENT\n", stderr);
3030 fseg_print(seg, &mtr);
3040 btr_print_recursive(
3050 const page_t* page = buf_block_get_frame(block);
3056 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
3057 fprintf(stderr,
"NODE ON LEVEL %lu page number %lu\n",
3074 }
else if ((i <= width) || (i >= n_recs - width)) {
3076 const rec_t* node_ptr;
3080 node_ptr = page_cur_get_rec(&cursor);
3082 *offsets = rec_get_offsets(node_ptr, index, *offsets,
3083 ULINT_UNDEFINED, heap);
3084 btr_print_recursive(index,
3085 btr_node_ptr_get_child(node_ptr,
3089 width, heap, offsets, &mtr2);
3111 ulint offsets_[REC_OFFS_NORMAL_SIZE];
3112 ulint* offsets = offsets_;
3113 rec_offs_init(offsets_);
3115 fputs(
"--------------------------\n"
3116 "INDEX TREE PRINT\n", stderr);
3120 root = btr_root_block_get(index, &mtr);
3122 btr_print_recursive(index, root, width, &heap, &offsets, &mtr);
3123 if (UNIV_LIKELY_NULL(heap)) {
3129 btr_validate_index(index, NULL);
3149 page_t* page = buf_block_get_frame(block);
3151 ut_ad(mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
3158 offsets = btr_page_get_father_block(NULL, heap, index, block, mtr,
3166 tuple = dict_index_build_node_ptr(
3182 btr_index_rec_validate_report(
3188 fputs(
"InnoDB: Record in ", stderr);
3189 dict_index_name_print(stderr, NULL, index);
3190 fprintf(stderr,
", page %lu, at offset %lu\n",
3200 btr_index_rec_validate(
3204 ibool dump_on_error)
3213 ulint offsets_[REC_OFFS_NORMAL_SIZE];
3214 ulint* offsets = offsets_;
3215 rec_offs_init(offsets_);
3229 btr_index_rec_validate_report(page, rec, index);
3230 fprintf(stderr,
"InnoDB: compact flag=%lu, should be %lu\n",
3241 btr_index_rec_validate_report(page, rec, index);
3242 fprintf(stderr,
"InnoDB: has %lu fields, should have %lu\n",
3245 if (dump_on_error) {
3246 buf_page_print(page, 0);
3248 fputs(
"InnoDB: corrupt record ", stderr);
3255 offsets = rec_get_offsets(rec, index, offsets, ULINT_UNDEFINED, &heap);
3257 for (i = 0; i < n; i++) {
3269 if ((dict_index_get_nth_field(index, i)->prefix_len == 0
3270 && len != UNIV_SQL_NULL && fixed_size
3271 && len != fixed_size)
3272 || (dict_index_get_nth_field(index, i)->prefix_len > 0
3273 && len != UNIV_SQL_NULL
3275 > dict_index_get_nth_field(index, i)->prefix_len)) {
3277 btr_index_rec_validate_report(page, rec, index);
3279 "InnoDB: field %lu len is %lu,"
3281 (ulong) i, (ulong) len, (ulong) fixed_size);
3283 if (dump_on_error) {
3284 buf_page_print(page, 0);
3286 fputs(
"InnoDB: corrupt record ", stderr);
3290 if (UNIV_LIKELY_NULL(heap)) {
3297 if (UNIV_LIKELY_NULL(heap)) {
3309 btr_index_page_validate(
3326 if (!btr_index_rec_validate(cur.
rec, index, TRUE)) {
3341 btr_validate_report1(
3347 fprintf(stderr,
"InnoDB: Error in page %lu of ",
3349 dict_index_name_print(stderr, NULL, index);
3351 fprintf(stderr,
", index tree level %lu", level);
3360 btr_validate_report2(
3367 fprintf(stderr,
"InnoDB: Error in pages %lu and %lu of ",
3370 dict_index_name_print(stderr, NULL, index);
3372 fprintf(stderr,
", index tree level %lu", level);
3398 ulint right_page_no;
3405 ulint* offsets = NULL;
3406 ulint* offsets2= NULL;
3407 #ifdef UNIV_ZIP_DEBUG
3415 block = btr_root_block_get(index, &mtr);
3416 page = buf_block_get_frame(block);
3422 const rec_t* node_ptr;
3426 #ifdef UNIV_ZIP_DEBUG
3428 ut_a(!page_zip || page_zip_validate(page_zip, page));
3435 node_ptr = page_cur_get_rec(&cursor);
3436 offsets = rec_get_offsets(node_ptr, index, offsets,
3437 ULINT_UNDEFINED, &heap);
3438 block = btr_node_ptr_get_child(node_ptr, index, offsets, &mtr);
3439 page = buf_block_get_frame(block);
3451 offsets = offsets2 = NULL;
3454 #ifdef UNIV_ZIP_DEBUG
3456 ut_a(!page_zip || page_zip_validate(page_zip, page));
3462 btr_validate_report1(index, level, block);
3465 }
else if (level == 0) {
3469 if (!btr_index_page_validate(block, index)) {
3485 const rec_t* right_rec;
3488 right_page = buf_block_get_frame(right_block);
3491 btr_validate_report2(index, level, block, right_block);
3492 fputs(
"InnoDB: broken FIL_PAGE_NEXT"
3493 " or FIL_PAGE_PREV links\n", stderr);
3494 buf_page_print(page, 0);
3495 buf_page_print(right_page, 0);
3502 btr_validate_report2(index, level, block, right_block);
3503 fputs(
"InnoDB: 'compact' flag mismatch\n", stderr);
3504 buf_page_print(page, 0);
3505 buf_page_print(right_page, 0);
3509 goto node_ptr_fails;
3515 offsets = rec_get_offsets(rec, index,
3516 offsets, ULINT_UNDEFINED, &heap);
3517 offsets2 = rec_get_offsets(right_rec, index,
3518 offsets2, ULINT_UNDEFINED, &heap);
3523 btr_validate_report2(index, level, block, right_block);
3525 fputs(
"InnoDB: records in wrong order"
3526 " on adjacent pages\n", stderr);
3528 buf_page_print(page, 0);
3529 buf_page_print(right_page, 0);
3531 fputs(
"InnoDB: record ", stderr);
3535 fputs(
"InnoDB: record ", stderr);
3537 page_get_infimum_rec(right_page));
3545 if (level > 0 && left_page_no ==
FIL_NULL) {
3557 offsets = btr_page_get_father_block(offsets, heap, index,
3558 block, &mtr, &node_cur);
3565 offsets = btr_page_get_father_node_ptr(offsets, heap,
3573 btr_validate_report1(index, level, block);
3575 fputs(
"InnoDB: node pointer to the page is wrong\n",
3578 buf_page_print(father_page, 0);
3579 buf_page_print(page, 0);
3581 fputs(
"InnoDB: node ptr ", stderr);
3585 fprintf(stderr,
"\n"
3586 "InnoDB: node ptr child page n:o %lu\n",
3590 fputs(
"InnoDB: record on page ", stderr);
3595 goto node_ptr_fails;
3599 node_ptr_tuple = dict_index_build_node_ptr(
3607 page_get_infimum_rec(page));
3609 btr_validate_report1(index, level, block);
3611 buf_page_print(father_page, 0);
3612 buf_page_print(page, 0);
3614 fputs(
"InnoDB: Error: node ptrs differ"
3616 "InnoDB: node ptr ", stderr);
3618 fputs(
"InnoDB: first rec ", stderr);
3623 goto node_ptr_fails;
3629 page_get_infimum_rec(father_page)));
3635 page_get_supremum_rec(father_page)));
3638 const rec_t* right_node_ptr
3641 offsets = btr_page_get_father_block(
3642 offsets, heap, index, right_block,
3643 &mtr, &right_node_cur);
3645 != page_get_supremum_rec(father_page)) {
3648 != right_node_ptr) {
3650 fputs(
"InnoDB: node pointer to"
3651 " the right page is wrong\n",
3654 btr_validate_report1(index, level,
3657 buf_page_print(father_page, 0);
3658 buf_page_print(page, 0);
3659 buf_page_print(right_page, 0);
3662 page_t* right_father_page
3667 page_get_infimum_rec(
3668 right_father_page))) {
3670 fputs(
"InnoDB: node pointer 2 to"
3671 " the right page is wrong\n",
3674 btr_validate_report1(index, level,
3677 buf_page_print(father_page, 0);
3678 buf_page_print(right_father_page, 0);
3679 buf_page_print(page, 0);
3680 buf_page_print(right_page, 0);
3687 fputs(
"InnoDB: node pointer 3 to"
3688 " the right page is wrong\n",
3691 btr_validate_report1(index, level,
3694 buf_page_print(father_page, 0);
3695 buf_page_print(right_father_page, 0);
3696 buf_page_print(page, 0);
3697 buf_page_print(right_page, 0);
3714 page = buf_block_get_frame(block);
3741 root = btr_root_get(index, &mtr);
3745 if (!btr_validate_level(index, trx, n - i)) {